@tangle-network/agent-runtime 0.121.0 → 0.123.0

package/dist/{index-CGADWaa_.d.ts → index-CyXinqJw.d.ts}

@@ -2,7 +2,7 @@ import { d as AgentTaskStatus, f as BackendErrorDetail, i as AgentExecutionBacke
 import { n as AnalystRegistryLike } from "./types-zWfqDjeL.js";
 import { l as RuntimeHooks } from "./runtime-hooks-sbRpjStq.js";
 import { C as MountRecorder, D as SelectionReceipt, E as SandboxClient, a as Iteration, b as LoopTraceEvent, d as LoopLineageOptions, i as ExecCtx, k as Validator, m as LoopResult, r as Driver, t as AgentRunSpec, w as OutputAdapter, x as LoopWinner, y as LoopTraceEmitter } from "./types-DnNGJ5Gz.js";
-import { B as DefaultVerdict, Cn as WaitProbeRegistry, Ct as SupervisedResult, Et as TreeView, Fn as TraceSource, H as Executor, Hn as ExecutorProgress, I as Agent, K as ExecutorFactory, L as AgentExecutionRef, Nt as WorkerTraceResolver, Ot as UsageEvent, R as AgentSpec, Rt as TraceContext, St as SteerableRootHandle, V as ExecutionBindingReceipt, Wn as WorkerProgress, Xt as OtelExporter, Y as ExecutorRegistry, Yt as OtelExportConfig, _t as SpawnJournal, at as ProfileMaterializationReceipt, bn as PendingWait, ct as ResumedKeyState, gt as SpawnEvent, ht as Settled, i as AgentEnvironmentProvider, jt as WorkerTraceEvidence, mt as Scope, nt as NodeId, o as AgentEnvironmentProviderRegistry, pt as Runtime, rt as NodeSnapshot, st as ResultBlobStore, tt as NodeExecutionIdentity, ut as RootHandle, vt as SpawnOpts, w as ProviderExecutorOptions, wt as Supervisor, xt as Spend, z as Budget } from "./environment-provider-Bh4nX2qt.js";
+import { B as DefaultVerdict, Cn as PendingWait, Ct as SupervisedResult, En as WaitProbeRegistry, Et as TreeView, Gn as ExecutorProgress, H as Executor, I as Agent, K as ExecutorFactory, L as AgentExecutionRef, Nt as WorkerTraceResolver, Ot as UsageEvent, R as AgentSpec, Rn as TraceSource, Rt as TraceContext, St as SteerableRootHandle, V as ExecutionBindingReceipt, Xt as OtelExportConfig, Y as ExecutorRegistry, Zt as OtelExporter, _t as SpawnJournal, at as ProfileMaterializationReceipt, ct as ResumedKeyState, gt as SpawnEvent, ht as Settled, i as AgentEnvironmentProvider, jt as WorkerTraceEvidence, mt as Scope, nt as NodeId, o as AgentEnvironmentProviderRegistry, pt as Runtime, qn as WorkerProgress, rt as NodeSnapshot, st as ResultBlobStore, tt as NodeExecutionIdentity, ut as RootHandle, vt as SpawnOpts, w as ProviderExecutorOptions, wt as Supervisor, xt as Spend, z as Budget } from "./environment-provider-CEjwunXO.js";
 import { o as UiLens, r as UiFinding, s as CoderTask } from "./substrate-BcnuSHXm.js";
 import { E as ToolLoopCompactionOptions, f as runLocalHarness, h as RouterConfig, n as CodexExecutionPolicy, o as LocalHarness, r as CodexTokenUsage, v as ToolSpec, w as ToolLoopChat } from "./local-harness-BIajef4A.js";
 import { AgentEvalError, AgentEvalError as AgentEvalError$1, AgentEvalErrorCode, AgentProfile, AnalystFinding, AnalystFinding as AnalystFinding$1, AnalystFinding as AnalystFinding$2, AnalystRunInputs, ChatClient, ConfigError, DetectorSignal, HarnessType, JudgeError, MaximumCharge, NotFoundError, ProposalFinding, RankTestMethod, RunRecord, StreamingDetector, ToolSpan, TraceAnalysisStore, ValidationError, buildTrajectory, computeFindingId as computeFindingId$1, makeFinding as makeFinding$1 } from "@tangle-network/agent-eval";
@@ -2017,7 +2017,24 @@ interface SandboxSeam {
    */
   steering?: SandboxSteeringOptions;
 }
-/** CLI subprocess seam. `bin` + `args` describe the Halo/RLM process to spawn. */
+/**
+ * UNMETERED CLI subprocess seam. `bin` + `args` describe the process to spawn.
+ *
+ * READ THIS BEFORE CHOOSING `backend: 'cli'`. This backend pipes a prompt to a subprocess's stdin
+ * and reads its stdout. It has no usage receipt of any kind, so it reports its spend with
+ * `Spend.tokensKnown: false`: the work is recorded, its `{0,0}` tokens and `$0` are a FLOOR rather
+ * than a measurement, and a ceiling priced from either is a ceiling that cannot fire. The executor
+ * is also `budgetExempt: true`, which is why `driveHarnessFromBackend` refuses it outright rather
+ * than pretending to budget it.
+ *
+ * If you need a metered harness worker, use `backend: 'bridge'` (a cli-bridge session, which
+ * reports the harness's real per-turn tokens and cost) or `backend: 'cli-worktree'` with
+ * `codexReproducible`. Reach for this seam only when the subprocess genuinely is not an inference
+ * agent, or when you have accepted that its cost is invisible.
+ *
+ * `args` is argv for a LOCAL, in-process spawn under this process's own privileges. It is not a
+ * remote channel and nothing forwards it over a wire.
+ */
 interface CliSeam {
   bin: string;
   args?: string[];
@@ -2084,6 +2101,40 @@ interface CliWorktreeBridgeSeam {
  * harness conversation across turns; each turn also receives its own durable run id.
  * A dropped HTTP reader reattaches to that exact run and explicit cancel is the only
  * operation allowed to stop it. Omit `sessionId` and the executor mints one per spawn.
+ *
+ * ── HOW TO CONTROL WHAT THE HARNESS LOADS (there is no argv field, by design) ──
+ *
+ * A worker often needs the harness started in a KNOWN state — no ambient extensions, skills,
+ * context files, or prompt templates — because ambient state is how a paired experiment silently
+ * loses its pairing: an installed extension that persists memory across runs carries arm A's state
+ * into arm B, and nothing reports it.
+ *
+ * That is what the `AgentProfile` on this seam (and on the spawn spec) is FOR. `agent_profile`
+ * rides every request verbatim, and cli-bridge maps it onto each harness's own native controls:
+ *
+ *   - Materializing any profile at all already starts the harness isolated from ambient
+ *     workspace state — for pi that is `--no-context-files --no-skills --no-prompt-templates`,
+ *     applied to every request that carries an `agent_profile`.
+ *   - `AgentProfile.extensions.<harness>` is the named, per-harness control channel. An explicit
+ *     `extensions: { pi: { load: [] } }` disables ambient extension discovery outright
+ *     (pi's `--no-extensions`); listing package names loads exactly those and nothing else.
+ *   - `permissions` / `tools` / `mcp` map onto the harness's native tool and server controls.
+ *
+ * A caller therefore does NOT need to hand-roll an `Executor` to isolate a harness run, and the
+ * profile expressing it stays portable: the same declaration means the same thing on a different
+ * harness, whereas an argv string means nothing anywhere else.
+ *
+ * WHY NOT A GENERAL ARGV PASSTHROUGH. `bridgeUrl` addresses a process-spawning server. Forwarding
+ * an arbitrary argv array to it would let any caller holding a bearer token choose the flags of a
+ * process on the bridge host — which for real harness CLIs includes flags that load code from a
+ * path, read a file into the prompt, redirect the working directory, or turn off the isolation the
+ * bridge applies. cli-bridge deliberately confines workers (a filesystem jail and deny-by-default
+ * network egress), and every one of those confinements is expressed as spawn configuration, so an
+ * argv channel is a channel for unwinding them. It would also break this executor's own contract:
+ * the durable-run replay protocol, session pinning, and streaming mode are all argv the bridge
+ * owns, and a caller-supplied duplicate silently wins or corrupts the parse. The structured profile
+ * channel is validated, per-harness, portable, and refuses controls it does not understand — keep
+ * new harness capability there.
  */
 interface BridgeSeam {
   bridgeUrl: string;
@@ -2418,8 +2469,46 @@ interface AnalystRegistry {
 interface AnalystFindingEvent {
   readonly fromWorker: string;
   readonly analyst: string;
-  readonly findings: unknown;
-}
+  /** The analyst's result. ABSENT when the analyst returned `undefined` (no findings); any other
+   *  value is canonicalized to finite RFC 8785 JSON at publish (`canonicalFindingEvent`), so
+   *  digesting subscribers (the coordination-event id) never throw on analyst-shaped data. */
+  readonly findings?: unknown;
+}
+/** 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. */
+declare function canonicalFindingEvent(finding: AnalystFindingEvent): AnalystFindingEvent;
+/**
+ * One analyst-on-settle ROUTE: which lens runs (`kind`), over WHICH settled workers (`over`),
+ * delivered to WHOM (`to`), wrapped in WHAT standing instruction (`directive`). The generalized
+ * form of the bare-string entry — a string `k` is exactly `{ kind: k }`: every settle feeds the
+ * lens and the findings go to the driver via the bus. This is the analyzes-edge of an agent
+ * graph expressed at the coordination layer; the finding is ALWAYS also published on the bus
+ * (the audit trail), routing adds delivery, never replaces the record.
+ */
+interface AnalyzeOnSettleRoute {
+  /** The analyst lens id (resolved against the `analysts` registry). */
+  readonly kind: string;
+  /** Deliver the findings to this live worker, named by its PROFILE NAME (the stable node
+   *  identity a graph pins) or its spawn label. Omit = the driver (bus only). Delivery goes
+   *  through the same authorization + steer machinery a driver-authored steer uses and is
+   *  recorded as a `steer` event carrying `analyst`, so a routed delivery is observable and a
+   *  failed one (`delivered: false`) is a recorded outcome, never a silent drop. */
+  readonly to?: string;
+  /** Standing instruction wrapped around the findings on a routed delivery — what the recipient
+   *  should DO with the analysis. Omit = the bare findings JSON. */
+  readonly directive?: string;
+  /** Restrict which settled workers feed this lens, by profile name or spawn label. Omit =
+   *  every settled `done` worker. */
+  readonly over?: ReadonlyArray<string>;
+}
+/** Normalize the two spellings of an analyst-on-settle entry to the route form. */
+declare function normalizeAnalyzeOnSettle(entry: string | AnalyzeOnSettleRoute): AnalyzeOnSettleRoute;
 /** The exact result of one parent→child delivery attempt. */
 type DownMessageDeliveryOutcome = 'delivered' | 'unknown-worker' | 'already-settled' | 'runtime-has-no-inbox' | 'scope-stopped' | 'runtime-error';
 /** A durable marker written after authorization and immediately before Runtime calls `Scope.send`.
@@ -2489,6 +2578,9 @@ type CoordinationEvent = {
 } | {
   readonly type: 'steer';
   readonly down: DownMessageEvent;
+  /** Present when this steer DELIVERED an analyst's routed findings (an analyzes-edge
+   *  traversal), naming the lens — absent on an ordinary driver-authored steer. */
+  readonly analyst?: string;
 } | {
   readonly type: 'answer';
   readonly down: DownMessageEvent;
@@ -2542,11 +2634,15 @@ interface CoordinationToolsOptions {
    * detached, recorded durably through `onEvent`, and only then delivered. */
   readonly authorizeDownMessage?: AuthorizeDownMessage;
   readonly questionPolicy?: QuestionPolicy;
-  /** Analyst kind ids to run AUTOMATICALLY when a worker settles `done` (the analyst-on-settle
-   *  hook). Each result is published as a `finding` event on the bus — pass-through to subscribers
-   *  and queued for the driver to pull via `await_event`. Omit/empty = no auto-analysis (default;
-   *  the driver can still run lenses on demand via `run_analyst`). Requires `analysts`. */
-  readonly analyzeOnSettle?: ReadonlyArray<string>;
+  /** Analyst lenses run AUTOMATICALLY when a worker settles `done` (the analyst-on-settle hook).
+   *  A bare string names a lens whose findings go to THE DRIVER: published as a `finding` event on
+   *  the bus — pass-through to subscribers and queued for `await_event`. An
+   *  {@link AnalyzeOnSettleRoute} generalizes the DESTINATION: findings can be delivered to a
+   *  named live WORKER (wrapped in the route's directive, through the same authorized steer
+   *  machinery a driver steer uses) instead of being hardwired to the spawning driver, and `over`
+   *  restricts which settled workers feed the lens. Omit/empty = no auto-analysis (default; the
+   *  driver can still run lenses on demand via `run_analyst`). Requires `analysts`. */
+  readonly analyzeOnSettle?: ReadonlyArray<string | AnalyzeOnSettleRoute>;
   /** Hard cap on how many workers may be LIVE (spawned but not yet settled) at once. `spawn_agent`
    *  counts the scope's non-terminal nodes and fails closed (`error: 'max-live-workers'`) BEFORE
    *  reserving from the pool when the cap is already met — a concurrency fence on top of the
@@ -3159,7 +3255,7 @@ interface LeaderboardSpec<TCase, TArtifact = string> {
    *  print (+ write) the ranked leaderboard markdown under the export dir. */
   export?: (result: RunProfileMatrixResult<TArtifact, LeaderboardScenario<TCase>>, ctx: LeaderboardRunContext) => Promise<void> | void;
   /** LEVEL 2 — full dispatch replacement (in-process products bring their own).
-   *  The default is `loopDispatch` + `naiveDriver` over the resolved backend. */
+   *  The default is `loopDispatch` + the naive steering directive over the resolved backend. */
   dispatch?: ProfileDispatchFn<LeaderboardScenario<TCase>, TArtifact>;
   /** LEVEL 2 — full judge replacement. Default: `score` wrapped as one judge. */
   judges?: JudgeConfig<TArtifact, LeaderboardScenario<TCase>>[];
@@ -5503,6 +5599,34 @@ declare function materializeLocalMcp(profile: AgentProfile$1, opts?: Materialize
  * for another round). Identical to the reference refine driver's decision set.
  */
 type SteeringDecision = 'refine' | 'pick-winner' | 'fail';
+/**
+ * A steering POLICY as plain data — the delegates-edge directive form of the two control
+ * drivers. `kind` names how much of the verdict the policy may read (the experimental axis);
+ * the continuation strings are the payload. Because this is JSON-able data, it is versionable
+ * in a prompt registry and attachable to a graph edge — the same policy that used to exist
+ * only as a builder FUNCTION, which made it invisible to any optimizer. Default texts are
+ * seeded in the kernel prompt registry (`delegates/naive-continuation`,
+ * `delegates/dumb-continuation-pass` / `-fail`); a caller may carry its own.
+ */
+type SteeringDirectiveData = {
+  /** Reads NOTHING from the verdict: one fixed continuation every round. */
+  readonly kind: 'naive';
+  readonly continuation: string;
+  /** Hard traversal cap: the loop stops refining once history reaches this length. */
+  readonly maxTraversals: number;
+} | {
+  /** Reads ONLY `verdict.valid` (the boolean): one of two fixed continuations. */
+  readonly kind: 'dumb';
+  readonly onPass: string;
+  readonly onFail: string;
+  readonly maxTraversals: number;
+};
+/**
+ * Interpret a {@link SteeringDirectiveData} as a loop `Driver` — the ONE interpreter both
+ * control policies share. The directive is data; only `applyContinuation` (how the caller's
+ * opaque Task carries a steering string) remains code, exactly as `taskToPrompt` does.
+ */
+declare function steeringDriver<Task, Output>(directive: SteeringDirectiveData, applyContinuation: ApplyContinuation<Task>, name?: string): Driver<Task, Output, SteeringDecision>;
 /**
  * Fold a steering string into the caller's Task shape, producing the Task for
  * the next shot. The substrate never assumes how a Task carries its prompt, so
@@ -5538,6 +5662,10 @@ interface NaiveDriverOptions<Task> {
  * attributable to the pass/fail bit, and any lift of `refine` over `dumb` is
  * attributable to the grader's findings.
  */
+/** Thin compatibility wrapper over {@link steeringDriver} for the naive (no-signal) control.
+ *  @deprecated The policy is DATA now — build the directive and interpret it:
+ *  `steeringDriver({ kind: 'naive', continuation, maxTraversals }, applyContinuation)`. This
+ *  wrapper survives for existing callers and will be removed in the next major. */
 declare function naiveDriver<Task, Output>(options: NaiveDriverOptions<Task>): Driver<Task, Output, SteeringDecision>;
 /** Options for {@link dumbDriver}. */
 interface DumbDriverOptions<Task> {
@@ -5571,6 +5699,10 @@ interface DumbDriverOptions<Task> {
  * grader's `notes`, dumb reads only the pass/fail bit, so the difference is
  * exactly the value the findings add over a bare boolean.
  */
+/** Thin compatibility wrapper over {@link steeringDriver} for the dumb (pass/fail-only) control.
+ *  @deprecated The policy is DATA now — build the directive and interpret it:
+ *  `steeringDriver({ kind: 'dumb', onPass, onFail, maxTraversals }, applyContinuation)`. This
+ *  wrapper survives for existing callers and will be removed in the next major. */
 declare function dumbDriver<Task, Output>(options: DumbDriverOptions<Task>): Driver<Task, Output, SteeringDecision>;
 //#endregion
 //#region src/runtime/strategy-author.d.ts
@@ -6150,7 +6282,12 @@ declare function asAuthoredProfile(raw: unknown): AuthoredProfile | null;
  */
 declare function canonicalizeAuthoredProfile(raw: unknown): AgentProfile$1;
 /** 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. */
 declare function supervisorInstructions(opts?: {
   goal?: string;
 }): string;
@@ -6605,7 +6742,7 @@ interface DriverAgentOptions {
   /** Analyst kind ids run AUTOMATICALLY when a worker settles `done` — each result re-enters as a
    *  `finding` the driver pulls and composes its next steer from. The UP-leg of the self-improving
    *  loop. Omit/empty = no auto-analysis (status quo). Requires `analysts`. */
-  readonly analyzeOnSettle?: ReadonlyArray<string>;
+  readonly analyzeOnSettle?: ReadonlyArray<string | AnalyzeOnSettleRoute>;
   /** Run the ONLINE detector panel over each worker's LIVE tool trace and raise a `finding` the
    *  moment it loops/error-storms — mid-run evidence to steer on, not a settle-time post-mortem.
    *  Omit = no online watching. */
@@ -6754,7 +6891,7 @@ declare function serveCoordinationMcp(opts: {
   /** Trace-analyst lenses the driver can run (`run_analyst`) or auto-fire on settle. */
   analysts?: AnalystRegistry;
   /** Analyst kinds to auto-run when a worker settles `done` — findings flow up the bus. */
-  analyzeOnSettle?: ReadonlyArray<string>;
+  analyzeOnSettle?: ReadonlyArray<string | AnalyzeOnSettleRoute>;
   /** Run the ONLINE detector panel over each worker's live tool trace (raises `finding` events). */
   watchWorkers?: WorkerWatchOptions;
   /** Idle time after which `observe_agent` reports a worker as stalled. */
@@ -6913,16 +7050,90 @@ declare function queueOf<Out>(units: ReadonlyArray<{
   label: string;
 }>, budget: Budget): () => DispatchUnit<Out> | undefined;
 //#endregion
-//#region src/runtime/supervise/model-policy.d.ts
+//#region src/runtime/supervise/prompt-registry.d.ts
 /**
- * Throw a `ConfigError` when `allowed` is set, `model` is defined, and `model` is not a
- * member of `allowed`. No-op when `allowed` is unset (the unrestricted default) or when
- * `model` is undefined (nothing was configured to check).
+ *
+ * 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
  */
-declare function assertModelAllowed(model: string | undefined, allowed: readonly string[] | undefined): void;
-/** Check every canonical model-bearing field in a complete profile, including the models a
- * backend may select for cheap work, named subagents, or modes. */
-declare function assertProfileModelsAllowed(profile: AgentProfile$1, allowed: readonly string[] | undefined): void;
+/** A versioned reference into a prompt registry: `surface` names the role/edge the text serves,
+ *  `version` pins the exact text. The string form is `<surface>/v<n>` (e.g. `delegates/worker-brief/v1`). */
+interface PromptHandle {
+  readonly surface: string;
+  readonly version: number;
+}
+/** One registry entry: the handle plus the text it pins. */
+interface RegisteredPrompt {
+  readonly surface: string;
+  readonly version: number;
+  readonly text: string;
+  /** What the surface is FOR — shown by `list()`, never sent to a model. */
+  readonly description?: string;
+}
+/** Versioned prompt store. `resolve` fails loud on an unknown handle: a directive that silently
+ *  resolved to nothing is the unobservable-edge failure this whole design exists to end. */
+interface PromptRegistry {
+  resolve(handle: PromptHandle): RegisteredPrompt;
+  /** Register a new entry; a duplicate (surface, version) fails loud — versions are immutable. */
+  register(entry: RegisteredPrompt): void;
+  list(): ReadonlyArray<RegisteredPrompt>;
+}
+/**
+ * Parse `'<surface>/v<n>'` into a {@link PromptHandle}. The shorthand for authoring a graph edge:
+ * `directive: promptHandle('delegates/worker-brief/v1')`.
+ */
+declare function promptHandle(ref: string): PromptHandle;
+/** The string form of a handle: `<surface>/v<n>`. */
+declare function formatPromptHandle(handle: PromptHandle): string;
+/** Create a registry, optionally seeded. Entries are copied; the registry never aliases caller state. */
+declare function createPromptRegistry(seed?: ReadonlyArray<RegisteredPrompt>): PromptRegistry;
+/**
+ * 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.
+ */
+declare const supervisorPolicyPrompt: RegisteredPrompt;
+/**
+ * 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.
+ */
+declare const delegatesWorkerBriefPrompt: RegisteredPrompt;
+/**
+ * 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.
+ */
+declare const analyzesFindingsReportPrompt: RegisteredPrompt;
+/**
+ * Default NAIVE steering continuation — the no-signal control re-expressed as data: the same
+ * fixed continuation every round, reading nothing from any verdict.
+ */
+declare const naiveContinuationPrompt: RegisteredPrompt;
+/**
+ * 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.
+ */
+declare const dumbContinuationFailPrompt: RegisteredPrompt;
+/** The pass branch of the dumb steering control — see {@link dumbContinuationFailPrompt}. */
+declare const dumbContinuationPassPrompt: RegisteredPrompt;
+/** 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. */
+declare function kernelPromptRegistry(): PromptRegistry;
 //#endregion
 //#region src/runtime/supervise/otel-spans.d.ts
 /** OTLP span attribute values. Exported because `SupervisorSpanOptions.attributes` is public and
@@ -6997,885 +7208,1038 @@ interface SupervisorSpanRecorder {
  */
 declare function createSupervisorSpanRecorder(opts: SupervisorSpanOptions): SupervisorSpanRecorder | undefined;
 //#endregion
-//#region src/runtime/supervise/patch-checks.d.ts
-/** @experimental The per-task constraints the mechanical gate enforces. */
-interface CoderCheckConstraints {
-  /** Default 400. Hard cap; gate fails when exceeded. */
-  maxDiffLines?: number;
-  /** Literal path prefixes the patch must not touch. */
-  forbiddenPaths?: string[];
-}
-//#endregion
-//#region src/runtime/supervise/worktree-cli-executor.d.ts
-/** Terminal artifact of one worktree-CLI run — the canonical worktree-harness result (the captured
- *  diff + the harness's run record + the derived checks). */
-type WorktreePatchArtifact = WorktreeHarnessResult;
-/** @experimental */
-interface WorktreeCliExecutorOptions {
-  /** Absolute path to the git checkout the worktree is cut from. */
-  repoRoot: string;
-  /**
-   * The supervisor-authored prompt/model plus materializable structural resources.
-   * `model.default` selects the one-shot model. Routing-only model hints, placement concerns,
-   * provider extensions, and `resources.failOnError` fail before execution because this path
-   * cannot honor them. Harness-specific values the materializer cannot preserve also fail closed.
-   */
-  profile: AgentProfile$1;
-  /** Local CLI for this leaf. This explicit choice overrides `profile.harness`. */
-  harness: LocalHarness;
-  /** Default instruction for direct `execute(undefined, signal)` calls. An execution-time task
-   *  is authoritative. Omit when the caller always supplies the task to `execute`. */
-  taskPrompt?: string;
-  /** Unique id for the worktree path + branch. Defaults to a fresh UUID. */
-  runId?: string;
-  /** Override the base ref the worktree is cut from (default `HEAD`). */
-  baseRef?: string;
-  /** Wall-clock cap per harness subprocess (ms). Default 5 min (the `runLocalHarness` default). */
-  harnessTimeoutMs?: number;
-  /** Run Codex with an ephemeral session, isolated config/instructions, network disabled, and
-   *  JSONL usage capture. Requires `harness: 'codex'`; metered by default. */
-  codexReproducible?: boolean;
-  /** Absolute host paths denied to reproducible Codex (for benchmark answer copies, credentials,
-   *  or other task-specific ambient state). */
-  codexReadDeniedPaths?: ReadonlyArray<string>;
-  /**
-   * Shell command run in the live worktree to derive the tests-PASS signal (e.g. `pnpm test`).
-   * Its exit code becomes `artifact.checks.tests.passed`. Omit to skip (no signal derived).
-   */
-  testCmd?: string;
-  /** Shell command run in the live worktree to derive the typecheck-PASS signal (e.g. `pnpm typecheck`). */
-  typecheckCmd?: string;
-  /** Wall-clock cap per verification command (ms). Default = `harnessTimeoutMs` or 5 min. */
-  checkTimeoutMs?: number;
-  /** Cap on each check's captured output. Default 16k. */
-  checkOutputCap?: number;
-  /** Test seam — inject a git runner so unit tests drive the worktree helpers without git. */
-  runGit?: GitRunner;
-  /** Test seam — inject the harness runner so unit tests script a `LocalHarnessResult`. */
-  runHarness?: typeof runLocalHarness;
-  /** Test seam — inject the verification-command runner so unit tests script test/typecheck
-   *  outcomes without spawning a real shell. Defaults to a `/bin/sh -c` spawn in the worktree. */
-  runCommand?: WorktreeCheckRunner;
-  /**
-   * Exclude this leaf's spend from accounting. Defaults to `true` for ordinary CLI runs and
-   * `false` for `codexReproducible`, which captures real token usage. A metered custom runner must
-   * likewise return `LocalHarnessResult.usage`.
-   */
-  budgetExempt?: boolean;
-  /** @internal Kernel-minted attempt identity threaded by the built-in registry. */
-  executionAttemptId?: string;
-}
+//#region src/runtime/supervise/supervisor-agent.d.ts
 /**
- * Build a worktree-CLI leaf `Executor`. Per-spawn (a fresh worktree + abort + teardown each), so a
- * fanout of N profiles = N parallel worktrees that never clobber each other.
+ * The supervisor's profile — the subset of an `AgentProfile` that selects + shapes its brain.
+ * `harness` is the backend-as-data discriminant; `systemPrompt` is the standing instruction.
  *
- * Fail-loud: an empty `repoRoot`/`harness` or an explicitly empty `taskPrompt` throws at
- * construction. Calling `execute(undefined, signal)` without a configured prompt throws before a
- * worktree is created. `resultArtifact()` before `execute()` resolves throws.
+ * A canonical `AgentProfile` from `@tangle-network/agent-interface` satisfies this interface
+ * structurally: its `model` is a hints OBJECT and its system prompt lives at `prompt.systemPrompt`,
+ * so both spellings are accepted here and reduced by {@link resolveSupervisorProfile}. Before that,
+ * a canonical profile's model object reached `RouterConfig.model` (a string) as an object and its
+ * `prompt.systemPrompt` was dropped — a request the provider rejects, and a supervisor running the
+ * default strategy while its profile named another.
  *
- * @experimental
+ * WHAT EACH ARM HONORS — the two brains read different amounts of a profile, so state it rather
+ * than let a caller infer that a field took effect:
+ *
+ *  - ROUTER arm (`harness` null): only `name`, the resolved model id (`model`, or
+ *    `model.default`), and the resolved system prompt (`prompt.systemPrompt`/`systemPrompt` plus
+ *    `prompt.instructions` and `resources.instructions`) reach the brain. A full `AgentProfile`'s
+ *    `tools`, `mcp`, `permissions`, `resources.skills`/`files`, `hooks`, `modes`, `subagents`,
+ *    `model.provider`, `model.small` and `model.reasoningEffort` are NOT honored here: the router
+ *    brain is one `ToolLoopChat` over the coordination verbs, and neither of its two tool-calling
+ *    transports (`routerChatWithTools` buffered, `streamRouterChatWithTools` when
+ *    `RouterConfig.stream` is set) has a parameter for any of them.
+ *  - HARNESS arm (`harness` set): the WHOLE profile object is handed to `deps.driveHarness`
+ *    untouched, plus the resolved system prompt as a separate argument. Everything the profile
+ *    declares is the harness's to materialize; this module changes none of it.
  */
-declare function createWorktreeCliExecutor(options: WorktreeCliExecutorOptions): Executor<WorktreePatchArtifact>;
-//#endregion
-//#region src/runtime/supervise/patch-deliverable.d.ts
-/** @experimental */
-interface PatchDeliverableOptions extends CoderCheckConstraints {
-  /**
-   * Which verification signals the gate REQUIRES to be present-and-passing. A required signal
-   * that the artifact never derived (the command was not configured on the executor) fails the
-   * gate closed. Unlisted signals default to passed-when-absent (the executor simply didn't run
-   * that command). Default `[]` — gate on no-op / secret / forbidden / diff-size only.
-   */
-  require?: ReadonlyArray<'tests' | 'typecheck'>;
+interface SupervisorProfile {
+  readonly name?: string;
+  /** null/undefined/`cli-base` → router brain (in-process tool-loop); a coding-CLI harness → an
+   *  external harness brain. */
+  readonly harness?: string | null;
+  /** The router model when the brain is router-driven: a model id, or a canonical profile's model
+   *  hints whose `default` IS the id. Absent (including a hints object with no `default`) → the
+   *  deps router config's model applies. Other hints (`small`, `provider`, `reasoningEffort`) are
+   *  harness-arm material only. */
+  readonly model?: string | AgentProfileModelHints;
+  /** Canonical `AgentProfile` prompt shaping. `prompt.systemPrompt` and the top-level `systemPrompt`
+   *  are the same standing instruction in two spellings; disagreeing values are a fault, not a pick.
+   *  `prompt.instructions` lines are appended to the resolved prompt, one per line. */
+  readonly prompt?: AgentProfilePrompt;
+  /** Canonical `AgentProfile` resources. Only `instructions` shapes the brain here (appended to the
+   *  resolved system prompt); every other resource is the harness's to materialize. */
+  readonly resources?: AgentProfileResources;
+  /** The standing instructions ("you delegate, you do not solve"). */
+  readonly systemPrompt?: string;
 }
-/**
- * Build the `DeliverableSpec<WorktreePatchArtifact>`: `check(artifact)` runs the shared mechanical
- * gate (`runCoderChecks`) over the captured patch + the worktree-derived pass signals and returns
- * whether the patch is DELIVERED (the `valid` conjunction).
+/** A `SupervisorProfile` reduced to the scalars the two brain arms consume. `modelId`/`systemPrompt`
+ *  stay `undefined` when the profile named none — the caller's fallback (`deps.router.model`,
+ *  the built-in default supervisor prompt) then applies, and this type cannot hide which happened.
  *
- * @experimental
- */
-declare function patchDelivered(options?: PatchDeliverableOptions): DeliverableSpec<WorktreePatchArtifact>;
-//#endregion
-//#region src/runtime/supervise/run-context.d.ts
-/** Options for a supervised run context. */
-interface InMemoryRunContextOptions {
-  /**
-   * Wrap the executor registry with `withDriverExecutor` so a spawned child marked
-   * `role: 'driver'` resolves to the recursive driver-executor (agents driving agents
-   * over a nested `Scope` on the same conserved pool). Leave `false` for a flat tree of
-   * leaf workers. Default `false`.
-   */
-  readonly withDriver?: boolean;
+ *  There is deliberately no `reasoningEffort` here: the router brain runs on `chatWithTools` (the
+ *  buffered/streamed switch in the router client), and neither transport has a `reasoning_effort`
+ *  parameter — only the chat-only `routerChatWithUsage` does — so a field carrying it would be a
+ *  public promise nothing keeps. `model.reasoningEffort` still reaches the harness arm inside the
+ *  profile. */
+interface ResolvedSupervisorProfile {
+  readonly name: string;
+  readonly harness: string | null;
+  readonly modelId?: string;
+  readonly systemPrompt?: string;
 }
 /**
- * The bundle of stores a supervised run needs, shaped to spread into `SupervisorOpts`.
- * The fields are exactly `SupervisorOpts`' `journal` / `blobs` / `executors`.
+ * Reduce either profile spelling — a hand-written `SupervisorProfile` or a canonical `AgentProfile`
+ * — to the scalars the brain arms consume:
+ *
+ *  - `modelId`: a string `model` verbatim, else `model.default`. Absent or unresolvable → the
+ *    router config's own model applies unchanged.
+ *  - `systemPrompt`: the system prompt plus the `prompt.instructions` and `resources.instructions`
+ *    lines, one per line.
+ *
+ * `supervisorAgent` resolves each piece only where it is consumed (the model id on the router arm
+ * only); this whole-profile reduction is the caller-facing view of the same rules.
  */
-interface InMemoryRunContext {
-  readonly journal: SpawnJournal;
-  readonly blobs: ResultBlobStore;
-  readonly executors: ExecutorRegistry;
-  /**
-   * Present (and `true`) only on a DURABLE context (`createFileRunContext`), so spreading the
-   * context into `SupervisorOpts` also opts the run into resume-first. An in-memory context
-   * leaves it undefined: there is never a prior tree to resume, and the default stays fresh-run.
-   */
-  readonly resume?: boolean;
-  /**
-   * Present only on a DURABLE context: the coordination side-log stores questions, analyst
-   * findings, answer decisions, and authorized continuation receipts that the spawn journal does
-   * not own. `supervise({ runDir })` appends them as they publish and loads them on resume.
-   * Continuation receipts are evidence and are never auto-delivered to a replacement worker.
-   * In-memory contexts have none: nothing outlives the process.
-   */
-  readonly coordinationLog?: CoordinationLog;
+declare function resolveSupervisorProfile(profile: SupervisorProfile): ResolvedSupervisorProfile;
+/** Where the coordination MCP binds. Omit = an ephemeral port on `127.0.0.1` (the local-harness
+ *  default); set `host` when the root or the harness runs off-host. */
+interface CoordinationBinding {
+  readonly host?: string;
+  readonly port?: number;
+  /** Explicit acknowledgment required to bind a NON-loopback host — see
+   *  {@link assertCoordinationBinding} for what is being accepted. */
+  readonly allowUnauthenticatedRemote?: boolean;
 }
-/** The stores a supervised run needs, in-memory or file-backed. `InMemoryRunContext` is the
- *  historical name for the same shape. */
-type RunContext = InMemoryRunContext;
 /**
- * Build a fresh in-memory run context. Every call returns NEW stores (no shared global
- * state between runs), so two runs never cross-contaminate their journals/blobs.
+ * Fail closed on a non-loopback coordination bind. `serveCoordinationMcp` mounts spawn_agent /
+ * steer_agent / stop with NO authentication of any kind (it is a bare JSON-RPC-over-HTTP handler),
+ * so a non-loopback bind lets anyone who can reach the port spawn agents and spend the run's
+ * conserved budget. There is no token to require yet, so the only honest options are loopback or an
+ * explicit, recorded acknowledgment — never a silent bind.
  */
-declare function createInMemoryRunContext(opts?: InMemoryRunContextOptions): InMemoryRunContext;
-/**
- * Build a DURABLE run context: the spawn journal and the result blobs are file-backed (fsynced
- * per append/write) under `dir`, and the context carries `resume: true` so spreading it into
- * `SupervisorOpts` makes the supervisor `loadTree`-first. A run that dies mid-flight therefore
- * resumes when it is re-run with the SAME `runId` and the SAME `dir`: the committed children come
- * back on `Scope.resume` (rehydrated by `replaySpawnTree`) instead of being re-executed.
- *
- * Layout: `${dir}/spawn-journal.jsonl` (one JSONL record per event), `${dir}/blobs/` (one
- * content-addressed JSON file per settled result), and `${dir}/coordination-log.jsonl`
- * (questions, findings, answer decisions, and authorized continuation receipts retained as
- * evidence). The directory is created on first write.
- *
- * Opt-in by construction — `createInMemoryRunContext()` is unchanged and stays the default, so no
- * existing consumer writes to disk or resumes unless it asks for this.
- */
-declare function createFileRunContext(dir: string, opts?: InMemoryRunContextOptions): RunContext;
+declare function assertCoordinationBinding(binding: CoordinationBinding | undefined): void;
+/** Trusted run/node identity Runtime binds to one manager. Model-authored tool arguments cannot
+ *  provide or replace any of these fields. */
+interface SupervisorNodeContext {
+  readonly runId: string;
+  /** Stable across a durable restart; unique per in-memory invocation. */
+  readonly runNamespace: string;
+  /** Concrete Scope node that owns this manager's coordination stream. */
+  readonly nodeId: string;
+  /** Stable identity of this manager's coordination stream. */
+  readonly ownerId: string;
+  readonly depth: number;
+  readonly identity: NodeExecutionIdentity;
+  /** Assignment identity within the parent manager; absent only for the root. */
+  readonly assignmentId?: string;
+  readonly profile: SupervisorProfile;
+  readonly task: unknown;
+}
+/** Context known before `Agent.act`; Runtime adds the concrete node, profile, and task. */
+type SupervisorNodeContextSeed = Omit<SupervisorNodeContext, 'nodeId' | 'profile' | 'task'>;
+/** Trusted context for one product-tool invocation. The node identity remains the same detached,
+ * immutable snapshot supplied to the resolver; `signal` is the one live control reference Runtime
+ * adds. It aborts when this manager's scope is cancelled by the caller, RootHandle, deadline,
+ * breaker, or a recursive parent. */
+interface SupervisorToolInvocationContext extends SupervisorNodeContext {
+  readonly signal: AbortSignal;
+}
+/** One product-owned tool. It reuses the canonical MCP descriptor fields while Runtime supplies
+ *  the trusted invocation context as a separate argument and binds the result for either
+ *  transport. Existing handlers remain compatible: the second argument only gains `signal`. */
+interface SupervisorToolDescriptor extends Omit<McpToolDescriptor$1, 'handler'> {
+  readonly handler: (raw: unknown, context: SupervisorToolInvocationContext) => Promise<unknown>;
+}
+/** Product policy for the tools one exact supervisor node may call. Resolved once per node. */
+type ResolveSupervisorTools = (context: SupervisorNodeContext) => ReadonlyArray<SupervisorToolDescriptor> | Promise<ReadonlyArray<SupervisorToolDescriptor>>;
+/** Context-aware observer used internally to bind product transactions to the actual live node. */
+type ObserveSupervisorNodeEvent = (context: SupervisorNodeContext, event: CoordinationEvent, record: BusRecord<CoordinationEvent>) => void | Promise<void>;
+/** How to run an external harness as the DRIVER, with the coordination verbs mounted — the substrate
+ *  seam the caller supplies (mirrors `makeWorkerAgent` for spawned children). It runs `profile` on
+ *  `task` in its backend (remote sandbox or local CLI bridge) with `coordinationMcpUrl` mounted as an MCP server,
+ *  so the harness calls spawn_agent / await_event / stop as native tools over the live scope. */
+interface DriveHarness {
+  (args: {
+    /** The caller's profile, EXACTLY as passed to `supervisorAgent` — never rewritten. A canonical
+     *  `AgentProfile` stays schema-valid here (the canonical schema rejects unknown top-level keys,
+     *  so hoisting a resolved prompt onto it would make a profile its own validator refuses). */
+    readonly profile: SupervisorProfile;
+    /** The standing instruction assembled from the profile: its system prompt in either spelling,
+     *  plus the `prompt.instructions` and `resources.instructions` lines. Absent when the profile
+     *  names none — the harness's own default then applies. This, not `profile.systemPrompt`, is
+     *  what the harness should run under. */
+    readonly systemPrompt?: string;
+    readonly task: unknown;
+    readonly scope: Scope<unknown>;
+    readonly coordinationMcpUrl: string;
+    /** Data-only product tool surface mounted on the coordination MCP. Runtime-owned drivers include
+     *  this in their materialization evidence without persisting executable handlers. */
+    readonly coordinationTools: ReadonlyArray<Omit<McpToolDescriptor$1, 'handler'>>;
+  }): Promise<void>;
+  /** Optional live inbox for the manager session this adapter currently drives. Return `false`
+   * when no executor inbox is active instead of claiming a message was delivered. */
+  deliver?(message: unknown): boolean;
+}
+/** Trusted manager identity available before its external harness starts. A product uses this to
+ * return one independently steerable harness session per recursive manager. */
+type DriveHarnessOwnerContext = Omit<SupervisorNodeContext, 'nodeId'>;
+/** Resolve an external harness for one exact Runtime-owned manager identity. */
+type ResolveDriveHarness = (context: DriveHarnessOwnerContext) => DriveHarness;
+interface SupervisorAgentDeps {
+  readonly blobs: ResultBlobStore;
+  /** Resolve a spawned worker `profile` to a leaf agent — the recursion seam (same for both arms). */
+  readonly makeWorkerAgent: MakeWorkerAgent;
+  /** Product authorization for every down-leg continuation to a child. */
+  readonly authorizeDownMessage?: AuthorizeDownMessage;
+  /** Per-child budget reserved from the conserved pool on each spawn. */
+  readonly perWorker: Budget;
+  /** Independent completion check for direct driver work (`submit_result`). */
+  readonly deliverable?: DeliverableSpec<unknown>;
+  /** Hard cap on simultaneously-LIVE workers across both arms — `spawn_agent` fails closed once
+   *  this many are in flight (a concurrency fence on top of the conserved-pool fence; bounds live
+   *  boxes/sandboxes, not total work). Omit/`<= 0` = no cap. */
+  readonly maxLiveWorkers?: number;
+  /** Router substrate for a router-brained supervisor (`harness` omitted or `cli-base`). The
+   *  profile's model wins. */
+  readonly router?: RouterConfig;
+  /** Inject the brain directly (tests / advanced) instead of resolving `routerBrain` from the profile. */
+  readonly brain?: ToolLoopChat;
+  /** Required to run an external-harness supervisor: runs the harness as the driver. */
+  readonly driveHarness?: DriveHarness;
+  /** Trusted identity for this manager. Required with node-scoped tools or observation. */
+  readonly nodeContext?: SupervisorNodeContextSeed;
+  /** Resolve product-owned tools for this exact manager. Static `extraTools` remain a router-only
+   *  compatibility seam and deliberately receive no new recursive authority. */
+  readonly resolveSupervisorTools?: ResolveSupervisorTools;
+  /** Awaited product observation, enriched with this manager's actual live node context. */
+  readonly observeNodeEvent?: ObserveSupervisorNodeEvent;
+  /** Replay resume-time settlements through `observeNodeEvent` before the manager starts. */
+  readonly replaySettlements?: boolean;
+  /** WORK tools the supervisor may call DIRECTLY (router arm) — so it can do simple work ITSELF and
+   *  only delegate when it needs parallelism. Pair with `executeExtraTool`. */
+  readonly extraTools?: ReadonlyArray<{
+    readonly name: string;
+    readonly description?: string;
+    readonly parameters: Record<string, unknown>;
+  }>;
+  /** Runs an `extraTools` call; null/undefined falls through to the coordination dispatch. */
+  readonly executeExtraTool?: (name: string, args: Record<string, unknown>) => Promise<string | null | undefined>;
+  /** Analyst lenses available to the driver (both arms). Required for `analyzeOnSettle`. */
+  readonly analysts?: AnalystRegistry;
+  /** Analyst kinds run on each worker-settle → a `finding` the driver composes its next steer from
+   *  (the self-improving UP-leg). Unset/empty = status quo (no analyst feed). Requires `analysts`. */
+  readonly analyzeOnSettle?: ReadonlyArray<string | AnalyzeOnSettleRoute>;
+  /** Run the ONLINE detector panel over each worker's LIVE tool trace (both arms) so the driver
+   *  learns a worker is looping mid-run instead of at settle. Omit = no online watching. */
+  readonly watchWorkers?: WorkerWatchOptions;
+  /** Idle time after which `observe_agent` reports a worker as stalled. Omit = runtime default. */
+  readonly stallAfterMs?: number;
+  /** PROGRESS-derived stop rule (router arm). Ends a run that has stopped learning BEFORE it
+   *  exhausts a ceiling; it can never keep a run alive past one. Build it with `plateau` /
+   *  `noProgressFor` / `allWorkersStalled` from `supervise/stop-rules` — the thresholds are the
+   *  caller's judgment. Omit = ceilings only. */
+  readonly stopRule?: StopRule;
+  /** One-shot notification of WHY a `stopRule` ended the run. */
+  readonly onProgressStop?: (reason: string) => void;
+  readonly maxTurns?: number;
+  /** Give the supervisor brain a chapter-lifecycle on its OWN context window (router arm only) — it
+   *  distills its coordination transcript to a compact progress note once it exceeds the threshold,
+   *  instead of re-billing the whole thing every turn. See `DriverAgentOptions.compaction`. */
+  readonly compaction?: ToolLoopCompactionOptions;
+  /** Pass-through subscriber for every coordination bus event (both arms) — the seam a durable
+   *  caller hooks its coordination log onto. */
+  readonly onEvent?: (event: CoordinationEvent, record: BusRecord<CoordinationEvent>) => void | Promise<void>;
+  /** Questions, findings, and authorized continuation receipts loaded from a prior process.
+   *  Router arm: questions seed the ledger and all evidence enters the resume brief. External arm:
+   *  questions seed the ledger; receipts remain durable evidence and are never auto-delivered. */
+  readonly priorCoordination?: PriorCoordination;
+  /** Deferred owner-scoped replay for a recursive supervisor. Its stable owner is known while the
+   * parent authorizes the child, but loading remains asynchronous; Runtime calls this before the
+   * nested brain can publish or act on coordination state. */
+  readonly loadPriorCoordination?: () => Promise<PriorCoordination>;
+  /** How the settled ledger becomes the run's output (both arms). Default `bestDelivered` — the
+   *  exact keep-best every existing caller had. Always runs under the delivered-only invariant. */
+  readonly finalizer?: SupervisorFinalizer;
+  /** Where the coordination MCP binds (external arm). Omit = an ephemeral loopback port, which is
+   *  unreachable from an off-host harness. A non-loopback host fails closed — see
+   *  {@link assertCoordinationBinding}. */
+  readonly coordination?: CoordinationBinding;
+}
+/** Build a supervisor `Agent` from its profile: the brain resolves from `profile.harness` (backend-as-data), the same resolution rule as every worker. */
+declare function supervisorAgent(profile: SupervisorProfile, deps: SupervisorAgentDeps): Agent<unknown, unknown>;
 //#endregion
-//#region src/runtime/supervise/run-layout.d.ts
+//#region src/runtime/supervise/supervise.d.ts
 /**
- * The on-disk supervisor-run layout: `<root>/.agent/supervisor/<id>`.
- *
- * This is the durable, cross-process face of a supervisor run — the counterpart to the in-process
- * `Inbox` seam in `./inbox`. A run persists its state under one directory so that any OTHER process
- * can find it after the fact: `@tangle-network/traces` reads exactly this layout via
- * `traces analyze --supervisor-run-dir`, a restarted host can rehydrate a run it no longer holds
- * handles to, and a human can steer a live worker by appending one NDJSON line. Until now the
- * layout was defined only in the unpublished `loops` repo (`src/supervisor-control.ts`) — a
- * published reader depending on an unpublished writer's convention — so the contract is promoted
- * here, names preserved.
- *
- * `.agent` is the one dot-dir for ALL agent-owned state (skills already write
- * `.agent/hypotheses/`, `.agent/skill-runs.jsonl`); supervisor runs live beside them rather than
- * under a product-branded dir. Runs written by older writers used `.loops/supervisor/<id>` —
- * readers that must see those keep a legacy fallback; this writer never creates `.loops` again.
- *
- * Layout, relative to `supervisorRunDir(root, id)`:
- *
- *   workers/<label>.inbox.ndjson   down-leg steer/answer requests for one worker (durable inbox);
- *                                  each line is a {@link WorkerSteerRequest}
- *   workers/<label>.ndjson         best-effort per-worker control-event log (delivery bookkeeping)
- *
- * Reads are tolerant by contract: a partial trailing line (a writer mid-append) or a corrupt line
- * never poisons the rest of the file — later valid lines still matter.
- *
- * Promoted from `loops/src/supervisor-control.ts`. The one deliberate difference: the loops version
- * resolved a worker id to its label through the run journal before writing a steer; that resolution
- * stays with the caller (it is journal-format-specific), so `writeWorkerSteer` here takes the worker
- * LABEL directly.
+ * Build the worker seam from a backend (WHERE workers run) + an optional completion oracle (the
+ * deliverable check that makes "settled ⟺ delivered" true — the guard against "ran but didn't
+ * deliver"). The ONE place a backend becomes a spawnable worker.
  *
- * @experimental
+ * `seams` exists because this path builds the leaf executor EAGERLY and hands it back as a BYO
+ * `executorSpec.executor`. The registry resolves a BYO executor without ever consulting the
+ * per-child `ExecutorContext` the `Scope` seeds, so anything the scope would have supplied is
+ * invisible here and has to be passed in. It is a FUNCTION because it is resolved once per worker
+ * construction, so a caller may hand back something the run only learns later — which is exactly how
+ * `supervise()` gives a traced run's workers their trace context without ordering the span recorder
+ * ahead of the worker seam.
  */
-/** One durable down-leg request appended to a worker's inbox file. */
-interface WorkerSteerRequest {
-  readonly id: string;
-  /** ISO timestamp of the append. */
-  readonly at: string;
-  /** Who asked — 'human', a brain label, a tool name. Provenance, not authorization. */
-  readonly source: string;
-  /** The worker LABEL the request targets (already resolved by the caller). */
-  readonly worker: string;
-  readonly message: string;
+declare function workerFromBackend(backend: ExecutorConfig, deliverable?: DeliverableSpec<unknown>, seams?: () => Readonly<Record<string, unknown>>): MakeWorkerAgent;
+/** Manager-authored profiles are untrusted until product policy says otherwise. Remote MCP and
+ * ambient connection grants therefore fail closed by default, in addition to local MCP and hooks. */
+declare const DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY: AgentProfileSecurityPolicy;
+/** A name→value table, in this package's resolver-port shape (the same one `WaitProbeRegistry`
+ *  uses): construction stays the caller's, lookup stays lazy, and a table backed by a file, a
+ *  plugin loader, or a plain object all satisfy one interface. */
+interface SuperviseRegistryTable<T> {
+  resolve(name: string): T | undefined;
 }
-/** The root every supervisor run of one workspace lives under. */
-declare function supervisorRunsRoot(rootDir: string): string;
-/** The run directory every artifact of one supervisor run lives under. */
-declare function supervisorRunDir(rootDir: string, id: string): string;
 /**
- * Where a pre-rename writer put the same run (`<root>/.loops/supervisor/<id>`). Readers that must
- * see historical runs check {@link supervisorRunDir} first and fall back to this; nothing writes
- * here anymore.
- */
-declare function legacySupervisorRunDir(rootDir: string, id: string): string;
-/**
- * The pre-rename runs root (`<root>/.loops/supervisor`). Only readers that ENUMERATE historical
- * runs need this — the per-id form is {@link legacySupervisorRunDir}. Nothing writes here.
- */
-declare function legacySupervisorRunsRoot(rootDir: string): string;
-/** A worker label reduced to a safe filename stem. Empty labels get a stable fallback. */
-declare function safeWorkerFile(label: string): string;
-/** The directory holding every per-worker file of one run (inboxes and control-event logs). */
-declare function supervisorWorkersDir(eventDir: string): string;
-/** The durable inbox file for one worker of one run. */
-declare function workerInboxFile(rootDir: string, supervisorId: string, worker: string): string;
-/** Same, addressed from an already-known run directory (the reader's usual entry point). */
-declare function workerInboxFileFromEventDir(eventDir: string, worker: string): string;
-/**
- * The best-effort control-event log for one worker (`workers/<label>.ndjson`) — delivery
- * bookkeeping for steers, plus whatever lifecycle events a writer chooses to append. Distinct from
- * the inbox: the inbox is the durable down-leg queue, this is the record of what happened to it.
- */
-declare function workerControlLogFile(eventDir: string, worker: string): string;
-/**
- * Durably append one steer request to a worker's inbox and log the delivery attempt.
+ * The name→value tables that make the four CODE-valued options expressible as run DATA.
  *
- * The inbox append is the durable act; the control-event log is best-effort bookkeeping and may
- * silently fail without voiding the steer.
+ * `deliverable` / `finalizer` / `analysts` / `probes` are functions and registries, so a recorded
+ * run configuration (a JSON row, a campaign spec, a resumed run's options) cannot carry them — and
+ * a run with no `deliverable` cannot return a `winner` at all outside the sandbox backend, because
+ * the finalizer keeps only children whose oracle passed and nothing else writes that verdict. A
+ * caller that owns the code registers it here once and names it from data thereafter.
  */
-declare function writeWorkerSteer(rootDir: string, supervisorId: string, worker: string, message: string, source?: string): {
-  worker: string;
-  file: string;
-  request: WorkerSteerRequest;
-};
-/** Read every valid steer request in a worker's inbox. Corrupt or partial lines are skipped. */
-declare function readWorkerSteerRequests(eventDir: string, worker: string): WorkerSteerRequest[];
-//#endregion
-//#region src/runtime/supervise/scope.d.ts
-/** Construction args for `createScope`. The supervisor threads the shared pool, journal,
- *  blob store, and executor registry through; `depth`/`maxDepth` pair the runtime
- *  recursion ceiling with the conserved pool (R3). */
-interface ScopeArgs {
-  /** This scope's owning node id — children get `${parentId}:s${seq}` ids. */
-  readonly parentId: NodeId;
-  /** Journal/blob root key the supervisor `beginTree`'d. */
-  readonly root: NodeId;
-  /** The reservation pool for this scope: the root total or one nested allocated partition. */
-  readonly pool: BudgetPool;
-  /** Append-only spawn journal; this scope writes `spawned` + `settled` records. */
-  readonly journal: SpawnJournal;
-  /** Content-addressed result store backing `outRef` rehydration. */
-  readonly blobs: ResultBlobStore;
-  /** The open executor resolver (BYO → router/inline → registered harness factory). */
-  readonly executors: ExecutorRegistry;
-  /** Predicate resolver for `poll` wait-states. Absent ⇒ `wait` refuses a `poll` with
-   *  `unknown-probe`; `timer` waits never touch it. */
-  readonly probes?: WaitProbeRegistry;
-  /** Injected sleeper for wait-states — a test drives a week-long timer in microseconds. */
-  readonly waitSleep?: (ms: number, signal: AbortSignal) => Promise<void>;
-  /** Per-spawn executor-construction seams (sandbox client, router config, cli bin). */
-  readonly seams: Readonly<Record<string, unknown>>;
-  /** This scope's recursion depth (root = 0). */
-  readonly depth: number;
-  /** Runtime recursion-depth ceiling — a spawn past it fails closed `depth-exceeded`. */
+interface SuperviseRegistry {
+  readonly deliverables?: SuperviseRegistryTable<DeliverableSpec<unknown>>;
+  readonly finalizers?: SuperviseRegistryTable<SupervisorFinalizer>;
+  readonly analysts?: SuperviseRegistryTable<AnalystRegistry>;
+  readonly probes?: SuperviseRegistryTable<WaitProbeRegistry>;
+}
+interface SuperviseOptions {
+  /** The conserved compute pool for the whole run. */
+  readonly budget: Budget;
+  /** Caller-created live handle for observing, steering, or cancelling this root manager. Runtime
+   * attaches it before execution and detaches it after the join barrier. */
+  readonly rootHandle?: RootHandle<unknown>;
+  /** Caller-owned cancellation for the complete recursive run. Aborting it cascades through the
+   * root scope and every live child, including acquisition and backend execution. */
+  readonly signal?: AbortSignal;
+  /** Trusted candidate and pursuit attribution for the root. The runtime derives profile/task
+   * digests itself from the exact detached values it executes. */
+  readonly execution?: AgentExecutionRef;
+  /** WHERE workers run — derives the worker seam. Provide this OR an explicit `makeWorkerAgent`. */
+  readonly backend?: ExecutorConfig;
+  /** The independent completion check for backend-derived workers and direct supervisor
+   *  submissions. Strongly recommended: without it the supervisor cannot submit its own work and
+   *  backend-derived workers fall back to their own validity signal. A `string` names an entry in
+   *  `registry.deliverables`. */
+  readonly deliverable?: DeliverableSpec<unknown> | string;
+  /** Resolve the completion check for one exact authorized backend-derived leaf. The callback runs
+   * after spawn authorization and driver classification, receives a detached immutable context,
+   * and may return `undefined` to use the run-wide `deliverable`. Driver profiles never call it. */
+  readonly resolveDeliverable?: (input: DeliverableResolutionInput) => DeliverableSpec<unknown> | undefined;
+  /** Name→value tables for the four code-valued options, so a recorded run configuration can name
+   *  them instead of carrying closures. See {@link SuperviseRegistry}. */
+  readonly registry?: SuperviseRegistry;
+  /** Where the coordination MCP binds when the supervisor is harness-driven. Omit = an ephemeral
+   *  port on `127.0.0.1`, which an off-host root cannot reach. A non-loopback host is refused
+   *  unless `allowUnauthenticatedRemote` acknowledges that the verbs are unauthenticated. */
+  readonly coordination?: CoordinationBinding;
+  /** Override the worker seam directly (tests / advanced) instead of deriving it from `backend`.
+   *  This is caller-owned execution: profile security, spawn authorization, and recursive-driver
+   *  selection below apply only to the backend-derived worker path. `authorizeMessage` still
+   *  governs continuations sent through Runtime's coordination tools. */
+  readonly makeWorkerAgent?: MakeWorkerAgent;
+  /** Run harness-brained supervisors here. Automatic execution supports a local `bridge`; a remote
+   *  sandbox requires an explicit `driveHarness` with a reachable coordination relay or tunnel.
+   *  Defaults to `backend`; separate it when managers and workers use different services. */
+  readonly driverBackend?: ExecutorConfig;
+  /** Security policy applied to every manager-authored child profile before budget reservation.
+   *  The default blocks local and remote MCP, hooks, and connection grants. Pass an explicit
+   *  allowlist to grant remote MCP hosts or other author-controlled capabilities. */
+  readonly profileSecurity?: AgentProfileSecurityPolicy;
+  /** Product authority over one complete manager-authored spawn. The callback sees the detached,
+   *  immutable profile, task, budget, label, and key together, so approving a profile cannot
+   *  authorize a different task. Return the exact allowed profile (which may be narrowed) plus
+   *  trusted candidate/pursuit attribution, or throw to refuse the whole spawn before reservation. */
+  readonly authorizeSpawn?: (input: {
+    readonly profile: AgentProfile$1;
+    readonly parent: AgentProfile$1;
+    /** Trusted identity of the manager authorizing this exact child. */
+    readonly parentIdentity: NodeExecutionIdentity;
+    /** Concrete manager node; never accepted from model-authored tool arguments. */
+    readonly parentNodeId: string;
+    /** Stable manager-scoped assignment, including deterministic unkeyed siblings. */
+    readonly assignmentId: string;
+    readonly task: unknown;
+    readonly budget: Budget;
+    readonly label: string;
+    readonly key?: string;
+    readonly depth: number;
+  }) => AuthorizedSpawn;
+  /** Product authority over every continuation sent to a live child. When spawn authorization is
+   * enabled, omitting this refuses steer/answer instructions instead of silently extending the
+   * authorized task. The exact worker identity and detached bytes are recorded before delivery. */
+  readonly authorizeMessage?: (input: DownMessageAuthorizationInput & {
+    readonly parent: AgentProfile$1;
+    readonly depth: number;
+  }) => AuthorizedDownMessage;
+  /** Decide whether an authorized child becomes another supervisor. By default only
+   *  `metadata.role === 'driver'` does. Products receive the same frozen post-authorization
+   *  context as `resolveDeliverable`, so trusted execution/assignment authority can override
+   *  model-authored metadata without a side channel. */
+  readonly isDriverProfile?: (input: AuthorizedSpawnContext) => boolean;
+  /** The supervisor's router substrate (`profile.harness` omitted or `cli-base`). The profile's
+   *  model wins. */
+  readonly router?: RouterConfig;
+  /** Inject the supervisor brain directly (tests / advanced). */
+  readonly brain?: ToolLoopChat;
+  /** Run an external-harness supervisor explicitly. Required for a remote sandbox; optional as a
+   *  caller-owned override for a local bridge. */
+  readonly driveHarness?: DriveHarness;
+  /** Resolve one custom external-harness session per trusted manager identity. Use this instead of
+   * `driveHarness` when recursive managers must be independently steerable. */
+  readonly resolveDriveHarness?: ResolveDriveHarness;
+  /** Required with a custom `driveHarness` or `resolveDriveHarness`: declares which complete
+   * AgentProfile axes that path really applies. Built-in bridge driving supplies its own
+   * full-profile contract. */
+  readonly driveHarnessMaterialization?: ProfileMaterializationContract;
+  /** Resolve product-owned tools from the exact trusted manager context. The same descriptors and
+   * handlers are bound to router and external-harness managers; resolution happens once per node.
+   * Each handler receives that manager scope's live cancellation signal in its trusted invocation
+   * context, including recursive parent and root cascades. */
+  readonly resolveSupervisorTools?: ResolveSupervisorTools;
+  /** Awaited product transaction hook for every coordination record. `eventId` is stable across a
+   * lost acknowledgement and durable restart; the record is not pull-visible until this commits. */
+  readonly onCoordinationEvent?: (context: SupervisorNodeContext, eventId: Sha256Digest, record: BusRecord<CoordinationEvent>) => void | Promise<void>;
+  /** WORK tools the supervisor may call DIRECTLY — so a recursive atom can ACT (do simple work
+   *  itself) OR SPAWN (delegate when it needs parallelism), not be a pure manager. Pair with
+   *  `executeExtraTool`. Router arm only (`profile.harness` omitted or `cli-base`). */
+  readonly extraTools?: ReadonlyArray<{
+    readonly name: string;
+    readonly description?: string;
+    readonly parameters: Record<string, unknown>;
+  }>;
+  /** Runs an `extraTools` call; null/undefined falls through to the coordination dispatch. */
+  readonly executeExtraTool?: (name: string, args: Record<string, unknown>) => Promise<string | null | undefined>;
+  /** Per-child budget reserved on each spawn. Defaults to a quarter of the pool's tokens. */
+  readonly perWorker?: Budget;
+  /** Hard cap on simultaneously executing spawned workers across the WHOLE recursive tree. The
+   *  root is excluded; nested drivers and leaves share one allocation, so recursion cannot multiply
+   *  the cap. Omit/`<= 0` = no cap (the conserved pool stays the only bound). */
+  readonly maxLiveWorkers?: number;
+  /** Analyst lenses available to the driver. Required for `analyzeOnSettle`. Unset → status quo
+   *  (the driver receives settled worker outputs, no analyst findings). A `string` names an entry in
+   *  `registry.analysts`. */
+  readonly analysts?: AnalystRegistry | string;
+  /** Analyst kind ids run AUTOMATICALLY when a worker settles `done` — each re-enters as a `finding`
+   *  the driver pulls (`await_event`) and composes its next steer from. The self-improving UP-leg,
+   *  threaded to the driver at this level (propagate to sub-drivers via a recursive `makeWorkerAgent`).
+   *  Omit/empty = status quo (no analyst feed). Requires `analysts`. */
+  readonly analyzeOnSettle?: ReadonlyArray<string | AnalyzeOnSettleRoute>;
+  /**
+   * Watch every worker's LIVE tool trace with the online detector panel and raise a `finding` the
+   * moment one loops or error-storms — so the supervisor learns it mid-run (via `await_event`)
+   * instead of at settle. Pairs with a steerable worker: the finding is the evidence, `steer_agent`
+   * is the correction. Requires a backend whose executor exposes a trace source (the steerable
+   * sandbox worker and the pi wrapper do); other runtimes are simply not watched.
+   *
+   * Omit = off (status quo — no online watching, no extra events).
+   */
+  readonly watchWorkers?: WorkerWatchOptions;
+  /** Idle time after which `observe_agent` reports a running worker as `stalled`. A derived read
+   *  at observation time — nothing is killed or retried. Omit = the runtime default. */
+  readonly stallAfterMs?: number;
+  /** Worker output store. Defaults to in-memory. */
+  readonly blobs?: ResultBlobStore;
+  /**
+   * Make the run DURABLE: journal + result blobs + the coordination side-log are file-backed under
+   * this directory (`createFileRunContext`), fsynced per write, and the supervisor reads the prior
+   * tree first. Re-running with the same `runDir` AND the same `runId` resumes only when the exact
+   * root profile/task identity and declared budget match. The original absolute deadline and prior
+   * measured spend are restored before new admission. The built-in driver is resume-aware: children
+   * that already settled, including their exact execution identities, are replayed onto
+   * `Scope.resume` (and into the driver's settled ledger + its first context), keyed assignments
+   * (`spawn_agent`'s `key`) resolve to their committed results instead of re-running, pending
+   * waits re-arm on their original deadlines, and the coordination log loads prior questions,
+   * findings, and instruction receipts. The router arm receives all three in its resume brief; the
+   * external arm seeds prior questions while findings and receipts remain in the durable log.
+   * Instruction receipts are evidence and are never delivered automatically to a replacement
+   * worker. The final result spans both processes' work. Unset = in-memory, fresh every call.
+   *
+   * The boundary that remains: work that was IN FLIGHT when the process died is not recovered —
+   * the built-in executors cannot re-attach to a dead process's executions. Each such assignment
+   * resumes as explicitly lost/in-doubt, its full declared reservation is charged conservatively,
+   * and its token/dollar telemetry remains unknown. A retry is admitted only from safely remaining
+   * capacity, so restart cannot mint a fresh budget or slide the original absolute deadline.
+   *
+   * `runId` matters here: it defaults to the constant `'supervise'`, which is fine for a single
+   * resumable run per directory but collides across concurrent runs sharing one `runDir`.
+   */
+  readonly runDir?: string;
+  /** Override the spawn journal directly (advanced; `runDir` is the ordinary durable path). Pair
+   *  with `blobs` — a journal whose result payloads live in a different store cannot replay. */
+  readonly journal?: SpawnJournal;
+  /** Predicate registry for `poll` wait-states (`Scope.wait`). A `poll` names its predicate so the
+   *  wait survives a restart; this is what the name resolves against. Unset ⇒ `poll` waits are
+   *  refused `unknown-probe` and `timer` waits still work. A `string` names an entry in
+   *  `registry.probes`. */
+  readonly probes?: WaitProbeRegistry | string;
+  /**
+   * PROGRESS-derived stop rule (router-brained supervisor). Ends a run that has stopped LEARNING
+   * before it exhausts a ceiling — the answer to "a run should end because it is done or stuck,
+   * not because it ran out". It composes with the budget guards and can never override one.
+   *
+   * Build it from `supervise/stop-rules`: `plateau({window, minDelta})`,
+   * `noProgressFor({ms, settles})`, `allWorkersStalled({...})`, combined with `anyOf`/`allOf`. The
+   * thresholds are policy and stay with you; the enforcement lives in the runtime. Omit = ceilings
+   * only (unchanged behavior).
+   */
+  readonly stopRule?: StopRule;
+  /** One-shot notification of WHY a `stopRule` ended the run — so a caller records the reason
+   *  instead of inferring an early stop from an unexhausted budget. */
+  readonly onProgressStop?: (reason: string) => void;
   readonly maxDepth?: number;
-  /** Root-owned limit on live spawned workers across this scope and every nested scope. */
-  readonly maxLiveWorkers?: number;
-  /** @internal Shared counter inherited by nested scopes. Callers set `maxLiveWorkers`; the root
-   *  scope creates this state once and passes the same object through its recursion seam. */
-  readonly liveWorkerCapacity?: LiveWorkerCapacityState;
-  /** Abort signal for this scope; an abort cascades into every live child's executor. */
-  readonly signal: AbortSignal;
-  /** Injected clock — keeps the journal `at` timestamp deterministic in tests. */
+  readonly maxTurns?: number;
+  /** Give the supervisor brain a chapter-lifecycle on its OWN context window (router arm only): once
+   *  its coordination transcript exceeds `thresholdTokens` it distills to a compact progress note and
+   *  continues, instead of re-billing the whole transcript every turn (the cost that makes the LLM-brain
+   *  front door lose to a dumb-Ralph respawn). The live `Scope` roster is the durable state across
+   *  chapters. Default off. `distill` defaults to a brain self-summary + the settled-worker roster. */
+  readonly compaction?: ToolLoopCompactionOptions;
+  readonly runId?: string;
   readonly now?: () => number;
-  /** Lifecycle stream sink. `spawn` emits `agent.spawn`, `next` emits `agent.child` — the
-   *  SAME stream `runAgentRounds`/`tool-loop` feed, so the recursive tree is ONE observable stream
-   *  (the topology viewer reads it). Undefined ⇒ the journal stays the only record. */
+  /** Restrict the run to this subset of models. When set, every configured model — the
+   *  supervisor router model, the profile's model, and the backend's model — must be a member,
+   *  or `supervise()` throws a `ConfigError` before any compute is spent. Unset = unrestricted. */
+  readonly allowedModels?: readonly string[];
+  /** How the settled-worker ledger becomes the run's output. Default `bestDelivered` — the single
+   *  highest-scoring DELIVERED child (the exact behavior every existing caller had). Alternatives:
+   *  `collectDelivered` (every verified distinct output with provenance — a Pareto set / recorded
+   *  disagreement) or a custom `SupervisorFinalizer`. Whatever the finalizer, it operates on
+   *  structurally DELIVERED outputs only — an undelivered or invalid child stays ineligible. A
+   *  `string` names an entry in `registry.finalizers`. */
+  readonly finalizer?: SupervisorFinalizer | string;
+  /** Lifecycle observers for the whole recursive tree (`Scope` re-seeds them into every nested
+   *  scope). Composed with the `otel` recorder below when both are set. Omit = no observers, which
+   *  is the behavior every existing caller has. */
   readonly hooks?: RuntimeHooks;
   /**
-   * Trace context to hand down to each spawned worker (`SupervisorOpts.workerTrace`). Called with
-   * THIS scope's own `parentId` — the node doing the spawning — and the resolved context is seeded
-   * onto each child's `ExecutorContext` under `workerTraceSeamKey`. Absent (the untraced default)
-   * ⇒ no seam is seeded and no worker environment is touched.
-   */
-  readonly workerTrace?: WorkerTraceResolver;
-  /** @internal Trusted root-adapter publication channel. It is never exposed as a Scope method. */
-  readonly ownerMaterialization?: {
-    readonly runtime: NodeSnapshot['runtime'];
-    readonly authoredProfile?: unknown;
-    readonly attemptId: string;
-    readonly prior?: ProfileMaterializationReceipt;
-    readonly journalRoot?: NodeId;
-    readonly nodeId?: NodeId;
-    readonly requiredKnown?: boolean;
-    readonly onReceipt?: (materialization: ProfileMaterializationReceipt, binding: ExecutionBindingReceipt) => void;
-  };
-  /**
-   * Resume seam — set ONLY by the supervisor when `SupervisorOpts.resume` is on AND a non-empty
-   * journal tree exists for this root. It carries the replayed committed work (so `scope.resume`
-   * exposes it to a resume-aware `act`) and the recorded ordinal/cursor maxima the new counters
-   * continue past, so a freshly-spawned child never reuses a journaled `seq`. Absent ⇒ fresh run.
+   * OPT-IN OTLP tracing: emit one span per supervised node (opened at spawn, closed at settle,
+   * parented to its parent node's span) plus an `LLM` child span per metered driver turn, so the
+   * tree is readable by any trace viewer instead of only by a journal parser. See `otel-spans.ts`.
+   *
+   * Omit and the run emits nothing, allocates no recorder, and installs no hook — telemetry is
+   * never a default. Present with no reachable endpoint (no `exportConfig.endpoint` and no
+   * `OTEL_EXPORTER_OTLP_ENDPOINT`) is also a no-op. The spawn journal is untouched either way:
+   * spans are telemetry, never the replay/resume record.
    */
-  readonly resumeFrom?: {
-    readonly settled: ReadonlyArray<Settled<unknown>>;
-    readonly view: TreeView;
-    /** Highest `spawned` ordinal already journaled; new spawns start at `+1`. */
-    readonly maxSpawnOrdinal: number;
-    /** Highest cursor `seq` already journaled; new settlements start at `+1`. */
-    readonly maxCursorSeq: number;
-    /** Highest `waiting` ordinal already journaled; new waits start at `+1`. */
-    readonly maxWaitOrdinal: number;
-    /** Waits journaled as armed but never woken — re-armed (same node id, same absolute deadline)
-     *  when `wait` is called again with the SAME label. */
-    readonly waits: ReadonlyArray<PendingWait>;
-    /** Keyed assignments from the prior journal — what a keyed re-spawn resolves against. */
-    readonly keys: ReadonlyMap<string, ResumedKeyState<unknown>>;
-    /** Prior committed spend summed off the journal (settled child work + metered inference). */
-    readonly priorSpend: {
-      readonly childWork: Spend;
-      readonly driverInference: Spend;
-    };
-  };
-}
-/** Mutable only inside Scope admission/release. Every nested scope receives this exact object. */
-interface LiveWorkerCapacityState {
-  readonly max: number | undefined;
-  live: number;
-}
-/** Create the reactive `Scope` a driver's `Agent.act` runs inside: spawn children on an atomically reserved conserved budget, settle via the `next()` cursor, journal for replay. */
-declare function createScope<Out>(args: ScopeArgs): Scope<Out>;
-/**
- * The step-8 merge-boundary adapter (M4): rehydrate a `Settled.done` into the kernel's
- * `Iteration` shape so `defaultSelectWinner` stays single-sourced — the supervisor selects
- * across settled children with the SAME argmax the loop kernel uses, not a forked copy.
- *
- * `index` is the cursor `seq` (the recorded, replay-stable order); `output`/`verdict`/
- * `tokenUsage`/`costUsd` are read straight off the settlement (already rehydrated from the
- * `outRef` blob by `next()`). Events are empty — a settled child is an opaque leaf result,
- * not a sandbox event stream — and the timing/cost fields project its conserved `Spend`.
- * Fail loud on a `down` settlement: only a `done` child is an iteration.
- */
-declare function settledToIteration<Out>(settled: Settled<Out>): Iteration<unknown, Out>;
-//#endregion
-//#region src/runtime/supervise/supervisor-agent.d.ts
-/**
- * The supervisor's profile — the subset of an `AgentProfile` that selects + shapes its brain.
- * `harness` is the backend-as-data discriminant; `systemPrompt` is the standing instruction.
- *
- * A canonical `AgentProfile` from `@tangle-network/agent-interface` satisfies this interface
- * structurally: its `model` is a hints OBJECT and its system prompt lives at `prompt.systemPrompt`,
- * so both spellings are accepted here and reduced by {@link resolveSupervisorProfile}. Before that,
- * a canonical profile's model object reached `RouterConfig.model` (a string) as an object and its
- * `prompt.systemPrompt` was dropped — a request the provider rejects, and a supervisor running the
- * default strategy while its profile named another.
- *
- * WHAT EACH ARM HONORS — the two brains read different amounts of a profile, so state it rather
- * than let a caller infer that a field took effect:
- *
- *  - ROUTER arm (`harness` null): only `name`, the resolved model id (`model`, or
- *    `model.default`), and the resolved system prompt (`prompt.systemPrompt`/`systemPrompt` plus
- *    `prompt.instructions` and `resources.instructions`) reach the brain. A full `AgentProfile`'s
- *    `tools`, `mcp`, `permissions`, `resources.skills`/`files`, `hooks`, `modes`, `subagents`,
- *    `model.provider`, `model.small` and `model.reasoningEffort` are NOT honored here: the router
- *    brain is one `ToolLoopChat` over the coordination verbs, and neither of its two tool-calling
- *    transports (`routerChatWithTools` buffered, `streamRouterChatWithTools` when
- *    `RouterConfig.stream` is set) has a parameter for any of them.
- *  - HARNESS arm (`harness` set): the WHOLE profile object is handed to `deps.driveHarness`
- *    untouched, plus the resolved system prompt as a separate argument. Everything the profile
- *    declares is the harness's to materialize; this module changes none of it.
- */
-interface SupervisorProfile {
-  readonly name?: string;
-  /** null/undefined/`cli-base` → router brain (in-process tool-loop); a coding-CLI harness → an
-   *  external harness brain. */
-  readonly harness?: string | null;
-  /** The router model when the brain is router-driven: a model id, or a canonical profile's model
-   *  hints whose `default` IS the id. Absent (including a hints object with no `default`) → the
-   *  deps router config's model applies. Other hints (`small`, `provider`, `reasoningEffort`) are
-   *  harness-arm material only. */
-  readonly model?: string | AgentProfileModelHints;
-  /** Canonical `AgentProfile` prompt shaping. `prompt.systemPrompt` and the top-level `systemPrompt`
-   *  are the same standing instruction in two spellings; disagreeing values are a fault, not a pick.
-   *  `prompt.instructions` lines are appended to the resolved prompt, one per line. */
-  readonly prompt?: AgentProfilePrompt;
-  /** Canonical `AgentProfile` resources. Only `instructions` shapes the brain here (appended to the
-   *  resolved system prompt); every other resource is the harness's to materialize. */
-  readonly resources?: AgentProfileResources;
-  /** The standing instructions ("you delegate, you do not solve"). */
-  readonly systemPrompt?: string;
-}
-/** A `SupervisorProfile` reduced to the scalars the two brain arms consume. `modelId`/`systemPrompt`
- *  stay `undefined` when the profile named none — the caller's fallback (`deps.router.model`,
- *  the built-in default supervisor prompt) then applies, and this type cannot hide which happened.
- *
- *  There is deliberately no `reasoningEffort` here: the router brain runs on `chatWithTools` (the
- *  buffered/streamed switch in the router client), and neither transport has a `reasoning_effort`
- *  parameter — only the chat-only `routerChatWithUsage` does — so a field carrying it would be a
- *  public promise nothing keeps. `model.reasoningEffort` still reaches the harness arm inside the
- *  profile. */
-interface ResolvedSupervisorProfile {
-  readonly name: string;
-  readonly harness: string | null;
-  readonly modelId?: string;
-  readonly systemPrompt?: string;
-}
-/**
- * Reduce either profile spelling — a hand-written `SupervisorProfile` or a canonical `AgentProfile`
- * — to the scalars the brain arms consume:
- *
- *  - `modelId`: a string `model` verbatim, else `model.default`. Absent or unresolvable → the
- *    router config's own model applies unchanged.
- *  - `systemPrompt`: the system prompt plus the `prompt.instructions` and `resources.instructions`
- *    lines, one per line.
- *
- * `supervisorAgent` resolves each piece only where it is consumed (the model id on the router arm
- * only); this whole-profile reduction is the caller-facing view of the same rules.
- */
-declare function resolveSupervisorProfile(profile: SupervisorProfile): ResolvedSupervisorProfile;
-/** Where the coordination MCP binds. Omit = an ephemeral port on `127.0.0.1` (the local-harness
- *  default); set `host` when the root or the harness runs off-host. */
-interface CoordinationBinding {
-  readonly host?: string;
-  readonly port?: number;
-  /** Explicit acknowledgment required to bind a NON-loopback host — see
-   *  {@link assertCoordinationBinding} for what is being accepted. */
-  readonly allowUnauthenticatedRemote?: boolean;
+  readonly otel?: Omit<SupervisorSpanOptions, 'runId' | 'now'>;
 }
-/**
- * Fail closed on a non-loopback coordination bind. `serveCoordinationMcp` mounts spawn_agent /
- * steer_agent / stop with NO authentication of any kind (it is a bare JSON-RPC-over-HTTP handler),
- * so a non-loopback bind lets anyone who can reach the port spawn agents and spend the run's
- * conserved budget. There is no token to require yet, so the only honest options are loopback or an
- * explicit, recorded acknowledgment — never a silent bind.
- */
-declare function assertCoordinationBinding(binding: CoordinationBinding | undefined): void;
-/** Trusted run/node identity Runtime binds to one manager. Model-authored tool arguments cannot
- *  provide or replace any of these fields. */
-interface SupervisorNodeContext {
-  readonly runId: string;
-  /** Stable across a durable restart; unique per in-memory invocation. */
-  readonly runNamespace: string;
-  /** Concrete Scope node that owns this manager's coordination stream. */
-  readonly nodeId: string;
-  /** Stable identity of this manager's coordination stream. */
-  readonly ownerId: string;
-  readonly depth: number;
-  readonly identity: NodeExecutionIdentity;
-  /** Assignment identity within the parent manager; absent only for the root. */
-  readonly assignmentId?: string;
-  readonly profile: SupervisorProfile;
-  readonly task: unknown;
+/** The product-authorized result for one complete spawn request. Attribution is never accepted
+ * from the manager itself; it enters only through this trusted callback. */
+interface AuthorizedSpawn {
+  readonly profile: AgentProfile$1;
+  readonly execution?: AgentExecutionRef;
 }
-/** Context known before `Agent.act`; Runtime adds the concrete node, profile, and task. */
-type SupervisorNodeContextSeed = Omit<SupervisorNodeContext, 'nodeId' | 'profile' | 'task'>;
-/** Trusted context for one product-tool invocation. The node identity remains the same detached,
- * immutable snapshot supplied to the resolver; `signal` is the one live control reference Runtime
- * adds. It aborts when this manager's scope is cancelled by the caller, RootHandle, deadline,
- * breaker, or a recursive parent. */
-interface SupervisorToolInvocationContext extends SupervisorNodeContext {
-  readonly signal: AbortSignal;
+/** Exact trusted context after a manager-authored spawn has passed product authorization. */
+interface AuthorizedSpawnContext {
+  readonly profile: AgentProfile$1;
+  readonly parent: AgentProfile$1;
+  readonly parentIdentity: NodeExecutionIdentity;
+  readonly execution: NodeExecutionIdentity;
+  readonly parentNodeId: string;
+  readonly assignmentId: string;
+  readonly task: unknown;
+  readonly budget: Budget;
+  readonly label: string;
+  readonly key?: string;
+  readonly depth: number;
 }
-/** One product-owned tool. It reuses the canonical MCP descriptor fields while Runtime supplies
- *  the trusted invocation context as a separate argument and binds the result for either
- *  transport. Existing handlers remain compatible: the second argument only gains `signal`. */
-interface SupervisorToolDescriptor extends Omit<McpToolDescriptor$1, 'handler'> {
-  readonly handler: (raw: unknown, context: SupervisorToolInvocationContext) => Promise<unknown>;
+/** Exact trusted context for selecting one backend-derived leaf's completion check. */
+type DeliverableResolutionInput = AuthorizedSpawnContext;
+/** One-call supervisor: build + run a supervisor from its profile with sensible defaults; the raw `supervisorAgent` + `createSupervisor().run` seams stay available for power use. */
+declare function supervise(profile: SupervisorProfile, task: unknown, opts: SuperviseOptions): Promise<SupervisedResult<unknown>>;
+//#endregion
+//#region src/runtime/supervise/graph.d.ts
+/** A graph node: an id and a canonical `AgentProfile`. The profile is the ONLY way a node is
+ *  described — its `prompt.systemPrompt` is the standing role (the 0.117 canonical resolution;
+ *  never a legacy top-level-only reduction), its tools/mcp/resources are its capabilities. */
+interface GraphNode {
+  readonly id: NodeId;
+  readonly profile: AgentProfile$1;
 }
-/** Product policy for the tools one exact supervisor node may call. Resolved once per node. */
-type ResolveSupervisorTools = (context: SupervisorNodeContext) => ReadonlyArray<SupervisorToolDescriptor> | Promise<ReadonlyArray<SupervisorToolDescriptor>>;
-/** Context-aware observer used internally to bind product transactions to the actual live node. */
-type ObserveSupervisorNodeEvent = (context: SupervisorNodeContext, event: CoordinationEvent, record: BusRecord<CoordinationEvent>) => void | Promise<void>;
-/** How to run an external harness as the DRIVER, with the coordination verbs mounted — the substrate
- *  seam the caller supplies (mirrors `makeWorkerAgent` for spawned children). It runs `profile` on
- *  `task` in its backend (remote sandbox or local CLI bridge) with `coordinationMcpUrl` mounted as an MCP server,
- *  so the harness calls spawn_agent / await_event / stop as native tools over the live scope. */
-interface DriveHarness {
-  (args: {
-    /** The caller's profile, EXACTLY as passed to `supervisorAgent` — never rewritten. A canonical
-     *  `AgentProfile` stays schema-valid here (the canonical schema rejects unknown top-level keys,
-     *  so hoisting a resolved prompt onto it would make a profile its own validator refuses). */
-    readonly profile: SupervisorProfile;
-    /** The standing instruction assembled from the profile: its system prompt in either spelling,
-     *  plus the `prompt.instructions` and `resources.instructions` lines. Absent when the profile
-     *  names none — the harness's own default then applies. This, not `profile.systemPrompt`, is
-     *  what the harness should run under. */
-    readonly systemPrompt?: string;
-    readonly task: unknown;
-    readonly scope: Scope<unknown>;
-    readonly coordinationMcpUrl: string;
-    /** Data-only product tool surface mounted on the coordination MCP. Runtime-owned drivers include
-     *  this in their materialization evidence without persisting executable handlers. */
-    readonly coordinationTools: ReadonlyArray<Omit<McpToolDescriptor$1, 'handler'>>;
-  }): Promise<void>;
-  /** Optional live inbox for the manager session this adapter currently drives. Return `false`
-   * when no executor inbox is active instead of claiming a message was delivered. */
-  deliver?(message: unknown): boolean;
+type GraphEdge =
+/** Work flows down. The delegation directive is DATA → versionable, sweepable, optimizable.
+ *  Each spawn of `to` by `from` — and each mid-run steer from `from` to a live `to` worker —
+ *  is one traversal. */
+{
+  readonly kind: 'delegates';
+  readonly from: NodeId;
+  readonly to: NodeId;
+  readonly directive: PromptHandle;
+  /** Cyclic-graph backstop: traversals beyond this REFUSE (fail loud). Default
+   *  {@link defaultEdgeTraversalCap}. */
+  readonly maxTraversals?: number;
+} |
+/** Findings flow anywhere: an analyst LENS (environment, never a node) over N nodes' settled
+ *  traces, delivered to ONE node wrapped in a directive telling the recipient what to do with
+ *  the analysis. */
+{
+  readonly kind: 'analyzes';
+  /** The analyst lens id, resolved against `RunGraphOptions.analysts`. NOT a node id. */
+  readonly analyst: string;
+  readonly over: ReadonlyArray<NodeId>;
+  readonly to: NodeId;
+  readonly directive: PromptHandle;
+  /** Observability cap: traversals beyond this are LEDGERED as exhausted (`unpropagated`).
+   *  Only delegates caps refuse traversal — they are what close the spawn cycle. */
+  readonly maxTraversals?: number;
+};
+interface AgentGraph {
+  readonly nodes: ReadonlyArray<GraphNode>;
+  readonly edges: ReadonlyArray<GraphEdge>;
+  /** Termination is mandatory, not optional: the independent completion oracle. */
+  readonly deliverable: DeliverableSpec<unknown>;
+  /** One conserved pool across the whole graph — cycles without conservation never terminate. */
+  readonly budget: Budget;
 }
-/** Trusted manager identity available before its external harness starts. A product uses this to
- * return one independently steerable harness session per recursive manager. */
-type DriveHarnessOwnerContext = Omit<SupervisorNodeContext, 'nodeId'>;
-/** Resolve an external harness for one exact Runtime-owned manager identity. */
-type ResolveDriveHarness = (context: DriveHarnessOwnerContext) => DriveHarness;
-interface SupervisorAgentDeps {
-  readonly blobs: ResultBlobStore;
-  /** Resolve a spawned worker `profile` to a leaf agent — the recursion seam (same for both arms). */
-  readonly makeWorkerAgent: MakeWorkerAgent;
-  /** Product authorization for every down-leg continuation to a child. */
-  readonly authorizeDownMessage?: AuthorizeDownMessage;
-  /** Per-child budget reserved from the conserved pool on each spawn. */
-  readonly perWorker: Budget;
-  /** Independent completion check for direct driver work (`submit_result`). */
-  readonly deliverable?: DeliverableSpec<unknown>;
-  /** Hard cap on simultaneously-LIVE workers across both arms — `spawn_agent` fails closed once
-   *  this many are in flight (a concurrency fence on top of the conserved-pool fence; bounds live
-   *  boxes/sandboxes, not total work). Omit/`<= 0` = no cap. */
-  readonly maxLiveWorkers?: number;
-  /** Router substrate for a router-brained supervisor (`harness` omitted or `cli-base`). The
-   *  profile's model wins. */
+type EdgeDeliveryOutcome = 'delivered' | 'stripped' | 'empty' | 'unpropagated';
+/** One recorded edge traversal — the in-memory row; the journal twin is the `edge` SpawnEvent. */
+interface EdgeTraversal {
+  /** Stable edge id: `delegates:<from>-><to>` or `analyzes:<analyst>:<over…>-><to>`. */
+  readonly edge: string;
+  readonly kind: 'delegates' | 'analyzes';
+  readonly from: string;
+  readonly to: string;
+  /** The resolved directive reference (`<surface>/v<n>`). */
+  readonly directive: string;
+  /** 1-based per-edge ordinal. */
+  readonly traversal: number;
+  readonly outcome: EdgeDeliveryOutcome;
+  /** Bytes of directive + payload that actually crossed the edge. */
+  readonly bytes: number;
+  readonly reason?: string;
+  /** The concrete worker node id, once known. */
+  readonly workerId?: string;
+}
+/** Default per-edge traversal cap — the cyclic-graph backstop when an edge names none. */
+declare const defaultEdgeTraversalCap = 32;
+/** A delegates edge exhausted its traversal cap and the run produced no winner: the cap, not the
+ *  task, ended it. Carries the full evidence so failing loud loses nothing. */
+declare class GraphEdgeCapError extends Error {
+  readonly exhaustedEdges: ReadonlyArray<string>;
+  readonly ledger: ReadonlyArray<EdgeTraversal>;
+  readonly result: SupervisedResult<unknown>;
+  constructor(exhaustedEdges: ReadonlyArray<string>, ledger: ReadonlyArray<EdgeTraversal>, result: SupervisedResult<unknown>);
+}
+interface RunGraphOptions {
+  /** WHERE worker nodes run — the executor backend. Provide this OR `makeWorkerAgent`. */
+  readonly backend?: ExecutorConfig;
+  /** Leaf-execution override (offline tests / advanced). `runGraph` still owns node pinning,
+   *  directive delivery, and the edge ledger AROUND this seam — only the leaf `act` is yours. */
+  readonly makeWorkerAgent?: MakeWorkerAgent;
+  /** The driver brain's router substrate (`profile.harness` omitted or `cli-base`). */
   readonly router?: RouterConfig;
-  /** Inject the brain directly (tests / advanced) instead of resolving `routerBrain` from the profile. */
+  /** Caller-side runtime hooks (telemetry, policy, product extensions). Composed AFTER the
+   *  graph's own spawn-binding hook on the SAME event stream — the graph never swallows the
+   *  seam supervise() exposes. */
+  readonly hooks?: RuntimeHooks;
+  /** Inject the driver brain directly (offline tests / advanced). */
   readonly brain?: ToolLoopChat;
-  /** Required to run an external-harness supervisor: runs the harness as the driver. */
-  readonly driveHarness?: DriveHarness;
-  /** Trusted identity for this manager. Required with node-scoped tools or observation. */
-  readonly nodeContext?: SupervisorNodeContextSeed;
-  /** Resolve product-owned tools for this exact manager. Static `extraTools` remain a router-only
-   *  compatibility seam and deliberately receive no new recursive authority. */
-  readonly resolveSupervisorTools?: ResolveSupervisorTools;
-  /** Awaited product observation, enriched with this manager's actual live node context. */
-  readonly observeNodeEvent?: ObserveSupervisorNodeEvent;
-  /** Replay resume-time settlements through `observeNodeEvent` before the manager starts. */
-  readonly replaySettlements?: boolean;
-  /** WORK tools the supervisor may call DIRECTLY (router arm) — so it can do simple work ITSELF and
-   *  only delegate when it needs parallelism. Pair with `executeExtraTool`. */
-  readonly extraTools?: ReadonlyArray<{
-    readonly name: string;
-    readonly description?: string;
-    readonly parameters: Record<string, unknown>;
-  }>;
-  /** Runs an `extraTools` call; null/undefined falls through to the coordination dispatch. */
-  readonly executeExtraTool?: (name: string, args: Record<string, unknown>) => Promise<string | null | undefined>;
-  /** Analyst lenses available to the driver (both arms). Required for `analyzeOnSettle`. */
+  /** The analyst lens registry `analyzes` edges resolve against. ENVIRONMENT, not nodes. */
   readonly analysts?: AnalystRegistry;
-  /** Analyst kinds run on each worker-settle → a `finding` the driver composes its next steer from
-   *  (the self-improving UP-leg). Unset/empty = status quo (no analyst feed). Requires `analysts`. */
-  readonly analyzeOnSettle?: ReadonlyArray<string>;
-  /** Run the ONLINE detector panel over each worker's LIVE tool trace (both arms) so the driver
-   *  learns a worker is looping mid-run instead of at settle. Omit = no online watching. */
-  readonly watchWorkers?: WorkerWatchOptions;
-  /** Idle time after which `observe_agent` reports a worker as stalled. Omit = runtime default. */
-  readonly stallAfterMs?: number;
-  /** PROGRESS-derived stop rule (router arm). Ends a run that has stopped learning BEFORE it
-   *  exhausts a ceiling; it can never keep a run alive past one. Build it with `plateau` /
-   *  `noProgressFor` / `allWorkersStalled` from `supervise/stop-rules` — the thresholds are the
-   *  caller's judgment. Omit = ceilings only. */
-  readonly stopRule?: StopRule;
-  /** One-shot notification of WHY a `stopRule` ended the run. */
-  readonly onProgressStop?: (reason: string) => void;
+  /** Directive registry. Default: the seeded kernel registry (`kernelPromptRegistry()`). */
+  readonly registry?: PromptRegistry;
+  /** The run journal the edge ledger and every spawn/settle ride. Default: in-memory. */
+  readonly journal?: SpawnJournal;
+  readonly blobs?: ResultBlobStore;
+  readonly runId?: string;
+  /** Per-child budget reserved from the conserved pool on each spawn. */
+  readonly perWorker?: Budget;
   readonly maxTurns?: number;
-  /** Give the supervisor brain a chapter-lifecycle on its OWN context window (router arm only) — it
-   *  distills its coordination transcript to a compact progress note once it exceeds the threshold,
-   *  instead of re-billing the whole thing every turn. See `DriverAgentOptions.compaction`. */
-  readonly compaction?: ToolLoopCompactionOptions;
-  /** Pass-through subscriber for every coordination bus event (both arms) — the seam a durable
-   *  caller hooks its coordination log onto. */
-  readonly onEvent?: (event: CoordinationEvent, record: BusRecord<CoordinationEvent>) => void | Promise<void>;
-  /** Questions, findings, and authorized continuation receipts loaded from a prior process.
-   *  Router arm: questions seed the ledger and all evidence enters the resume brief. External arm:
-   *  questions seed the ledger; receipts remain durable evidence and are never auto-delivered. */
-  readonly priorCoordination?: PriorCoordination;
-  /** Deferred owner-scoped replay for a recursive supervisor. Its stable owner is known while the
-   * parent authorizes the child, but loading remains asynchronous; Runtime calls this before the
-   * nested brain can publish or act on coordination state. */
-  readonly loadPriorCoordination?: () => Promise<PriorCoordination>;
-  /** How the settled ledger becomes the run's output (both arms). Default `bestDelivered` — the
-   *  exact keep-best every existing caller had. Always runs under the delivered-only invariant. */
-  readonly finalizer?: SupervisorFinalizer;
-  /** Where the coordination MCP binds (external arm). Omit = an ephemeral loopback port, which is
-   *  unreachable from an off-host harness. A non-loopback host fails closed — see
-   *  {@link assertCoordinationBinding}. */
-  readonly coordination?: CoordinationBinding;
+  readonly maxLiveWorkers?: number;
+  /** Product authority over every steer/answer instruction (the filter seam). `runGraph` observes
+   *  what it CHANGES: a narrowed instruction ledgers its steer traversal as `stripped`. */
+  readonly authorizeMessage?: SuperviseOptions['authorizeMessage'];
+  readonly signal?: AbortSignal;
+  readonly now?: () => number;
+  readonly otel?: SuperviseOptions['otel'];
+  readonly stallAfterMs?: number;
+  readonly allowedModels?: readonly string[];
 }
-/** Build a supervisor `Agent` from its profile: the brain resolves from `profile.harness` (backend-as-data), the same resolution rule as every worker. */
-declare function supervisorAgent(profile: SupervisorProfile, deps: SupervisorAgentDeps): Agent<unknown, unknown>;
+interface GraphResult<Out = unknown> {
+  readonly result: SupervisedResult<Out>;
+  /** Every edge traversal, in occurrence order — the observable-edge contract. */
+  readonly ledger: ReadonlyArray<EdgeTraversal>;
+  /** Edge ids whose traversal cap was hit — analyzes exhaustion included (observable here, never
+   *  a refusal). A DELEGATES cap paired with a `no-winner` result THROWS
+   *  ({@link GraphEdgeCapError}) instead of returning: only delegates caps refuse spawns, so only
+   *  they can have ended the run. A LIFECYCLE no-winner (`aborted` / `budget-exhausted`) returns
+   *  normally even with an exhausted delegates cap — the abort or the pool, not the cap, ended
+   *  that run, and the exhaustion stays observable here. */
+  readonly exhaustedEdges: ReadonlyArray<string>;
+  readonly runId: string;
+}
+/**
+ * Execute an {@link AgentGraph}. The root node becomes the supervisor (`supervise()` — the
+ * execution core), each worker node is spawnable BY NODE ID (`spawn_agent` with
+ * `profile: { name: '<node id>' }`; the node's canonical profile is pinned by the graph), each
+ * delegates directive is appended to the worker profile's `prompt.instructions` per traversal,
+ * and each analyzes edge becomes an analyst-on-settle route with a real DESTINATION. Every
+ * traversal is ledgered and journaled.
+ */
+declare function runGraph(graph: AgentGraph, opts: RunGraphOptions): Promise<GraphResult>;
 //#endregion
-//#region src/runtime/supervise/supervise.d.ts
+//#region src/runtime/supervise/model-policy.d.ts
+/**
+ * Throw a `ConfigError` when `allowed` is set, `model` is defined, and `model` is not a
+ * member of `allowed`. No-op when `allowed` is unset (the unrestricted default) or when
+ * `model` is undefined (nothing was configured to check).
+ */
+declare function assertModelAllowed(model: string | undefined, allowed: readonly string[] | undefined): void;
+/** Check every canonical model-bearing field in a complete profile, including the models a
+ * backend may select for cheap work, named subagents, or modes. */
+declare function assertProfileModelsAllowed(profile: AgentProfile$1, allowed: readonly string[] | undefined): void;
+//#endregion
+//#region src/runtime/supervise/patch-checks.d.ts
+/** @experimental The per-task constraints the mechanical gate enforces. */
+interface CoderCheckConstraints {
+  /** Default 400. Hard cap; gate fails when exceeded. */
+  maxDiffLines?: number;
+  /** Literal path prefixes the patch must not touch. */
+  forbiddenPaths?: string[];
+}
+//#endregion
+//#region src/runtime/supervise/worktree-cli-executor.d.ts
+/** Terminal artifact of one worktree-CLI run — the canonical worktree-harness result (the captured
+ *  diff + the harness's run record + the derived checks). */
+type WorktreePatchArtifact = WorktreeHarnessResult;
+/** @experimental */
+interface WorktreeCliExecutorOptions {
+  /** Absolute path to the git checkout the worktree is cut from. */
+  repoRoot: string;
+  /**
+   * The supervisor-authored prompt/model plus materializable structural resources.
+   * `model.default` selects the one-shot model. Routing-only model hints, placement concerns,
+   * provider extensions, and `resources.failOnError` fail before execution because this path
+   * cannot honor them. Harness-specific values the materializer cannot preserve also fail closed.
+   */
+  profile: AgentProfile$1;
+  /** Local CLI for this leaf. This explicit choice overrides `profile.harness`. */
+  harness: LocalHarness;
+  /** Default instruction for direct `execute(undefined, signal)` calls. An execution-time task
+   *  is authoritative. Omit when the caller always supplies the task to `execute`. */
+  taskPrompt?: string;
+  /** Unique id for the worktree path + branch. Defaults to a fresh UUID. */
+  runId?: string;
+  /** Override the base ref the worktree is cut from (default `HEAD`). */
+  baseRef?: string;
+  /** Wall-clock cap per harness subprocess (ms). Default 5 min (the `runLocalHarness` default). */
+  harnessTimeoutMs?: number;
+  /** Run Codex with an ephemeral session, isolated config/instructions, network disabled, and
+   *  JSONL usage capture. Requires `harness: 'codex'`; metered by default. */
+  codexReproducible?: boolean;
+  /** Absolute host paths denied to reproducible Codex (for benchmark answer copies, credentials,
+   *  or other task-specific ambient state). */
+  codexReadDeniedPaths?: ReadonlyArray<string>;
+  /**
+   * Shell command run in the live worktree to derive the tests-PASS signal (e.g. `pnpm test`).
+   * Its exit code becomes `artifact.checks.tests.passed`. Omit to skip (no signal derived).
+   */
+  testCmd?: string;
+  /** Shell command run in the live worktree to derive the typecheck-PASS signal (e.g. `pnpm typecheck`). */
+  typecheckCmd?: string;
+  /** Wall-clock cap per verification command (ms). Default = `harnessTimeoutMs` or 5 min. */
+  checkTimeoutMs?: number;
+  /** Cap on each check's captured output. Default 16k. */
+  checkOutputCap?: number;
+  /** Test seam — inject a git runner so unit tests drive the worktree helpers without git. */
+  runGit?: GitRunner;
+  /** Test seam — inject the harness runner so unit tests script a `LocalHarnessResult`. */
+  runHarness?: typeof runLocalHarness;
+  /** Test seam — inject the verification-command runner so unit tests script test/typecheck
+   *  outcomes without spawning a real shell. Defaults to a `/bin/sh -c` spawn in the worktree. */
+  runCommand?: WorktreeCheckRunner;
+  /**
+   * Exclude this leaf's spend from accounting. Defaults to `true` for ordinary CLI runs and
+   * `false` for `codexReproducible`, which captures real token usage. A metered custom runner must
+   * likewise return `LocalHarnessResult.usage`.
+   */
+  budgetExempt?: boolean;
+  /** @internal Kernel-minted attempt identity threaded by the built-in registry. */
+  executionAttemptId?: string;
+}
+/**
+ * Build a worktree-CLI leaf `Executor`. Per-spawn (a fresh worktree + abort + teardown each), so a
+ * fanout of N profiles = N parallel worktrees that never clobber each other.
+ *
+ * Fail-loud: an empty `repoRoot`/`harness` or an explicitly empty `taskPrompt` throws at
+ * construction. Calling `execute(undefined, signal)` without a configured prompt throws before a
+ * worktree is created. `resultArtifact()` before `execute()` resolves throws.
+ *
+ * @experimental
+ */
+declare function createWorktreeCliExecutor(options: WorktreeCliExecutorOptions): Executor<WorktreePatchArtifact>;
+//#endregion
+//#region src/runtime/supervise/patch-deliverable.d.ts
+/** @experimental */
+interface PatchDeliverableOptions extends CoderCheckConstraints {
+  /**
+   * Which verification signals the gate REQUIRES to be present-and-passing. A required signal
+   * that the artifact never derived (the command was not configured on the executor) fails the
+   * gate closed. Unlisted signals default to passed-when-absent (the executor simply didn't run
+   * that command). Default `[]` — gate on no-op / secret / forbidden / diff-size only.
+   */
+  require?: ReadonlyArray<'tests' | 'typecheck'>;
+}
 /**
- * Build the worker seam from a backend (WHERE workers run) + an optional completion oracle (the
- * deliverable check that makes "settled ⟺ delivered" true — the guard against "ran but didn't
- * deliver"). The ONE place a backend becomes a spawnable worker.
+ * Build the `DeliverableSpec<WorktreePatchArtifact>`: `check(artifact)` runs the shared mechanical
+ * gate (`runCoderChecks`) over the captured patch + the worktree-derived pass signals and returns
+ * whether the patch is DELIVERED (the `valid` conjunction).
  *
- * `seams` exists because this path builds the leaf executor EAGERLY and hands it back as a BYO
- * `executorSpec.executor`. The registry resolves a BYO executor without ever consulting the
- * per-child `ExecutorContext` the `Scope` seeds, so anything the scope would have supplied is
- * invisible here and has to be passed in. It is a FUNCTION because it is resolved once per worker
- * construction, so a caller may hand back something the run only learns later — which is exactly how
- * `supervise()` gives a traced run's workers their trace context without ordering the span recorder
- * ahead of the worker seam.
+ * @experimental
  */
-declare function workerFromBackend(backend: ExecutorConfig, deliverable?: DeliverableSpec<unknown>, seams?: () => Readonly<Record<string, unknown>>): MakeWorkerAgent;
-/** Manager-authored profiles are untrusted until product policy says otherwise. Remote MCP and
- * ambient connection grants therefore fail closed by default, in addition to local MCP and hooks. */
-declare const DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY: AgentProfileSecurityPolicy;
-/** A name→value table, in this package's resolver-port shape (the same one `WaitProbeRegistry`
- *  uses): construction stays the caller's, lookup stays lazy, and a table backed by a file, a
- *  plugin loader, or a plain object all satisfy one interface. */
-interface SuperviseRegistryTable<T> {
-  resolve(name: string): T | undefined;
+declare function patchDelivered(options?: PatchDeliverableOptions): DeliverableSpec<WorktreePatchArtifact>;
+//#endregion
+//#region src/runtime/supervise/run-context.d.ts
+/** Options for a supervised run context. */
+interface InMemoryRunContextOptions {
+  /**
+   * Wrap the executor registry with `withDriverExecutor` so a spawned child marked
+   * `role: 'driver'` resolves to the recursive driver-executor (agents driving agents
+   * over a nested `Scope` on the same conserved pool). Leave `false` for a flat tree of
+   * leaf workers. Default `false`.
+   */
+  readonly withDriver?: boolean;
 }
 /**
- * The name→value tables that make the four CODE-valued options expressible as run DATA.
+ * The bundle of stores a supervised run needs, shaped to spread into `SupervisorOpts`.
+ * The fields are exactly `SupervisorOpts`' `journal` / `blobs` / `executors`.
+ */
+interface InMemoryRunContext {
+  readonly journal: SpawnJournal;
+  readonly blobs: ResultBlobStore;
+  readonly executors: ExecutorRegistry;
+  /**
+   * Present (and `true`) only on a DURABLE context (`createFileRunContext`), so spreading the
+   * context into `SupervisorOpts` also opts the run into resume-first. An in-memory context
+   * leaves it undefined: there is never a prior tree to resume, and the default stays fresh-run.
+   */
+  readonly resume?: boolean;
+  /**
+   * Present only on a DURABLE context: the coordination side-log stores questions, analyst
+   * findings, answer decisions, and authorized continuation receipts that the spawn journal does
+   * not own. `supervise({ runDir })` appends them as they publish and loads them on resume.
+   * Continuation receipts are evidence and are never auto-delivered to a replacement worker.
+   * In-memory contexts have none: nothing outlives the process.
+   */
+  readonly coordinationLog?: CoordinationLog;
+}
+/** The stores a supervised run needs, in-memory or file-backed. `InMemoryRunContext` is the
+ *  historical name for the same shape. */
+type RunContext = InMemoryRunContext;
+/**
+ * Build a fresh in-memory run context. Every call returns NEW stores (no shared global
+ * state between runs), so two runs never cross-contaminate their journals/blobs.
+ */
+declare function createInMemoryRunContext(opts?: InMemoryRunContextOptions): InMemoryRunContext;
+/**
+ * Build a DURABLE run context: the spawn journal and the result blobs are file-backed (fsynced
+ * per append/write) under `dir`, and the context carries `resume: true` so spreading it into
+ * `SupervisorOpts` makes the supervisor `loadTree`-first. A run that dies mid-flight therefore
+ * resumes when it is re-run with the SAME `runId` and the SAME `dir`: the committed children come
+ * back on `Scope.resume` (rehydrated by `replaySpawnTree`) instead of being re-executed.
  *
- * `deliverable` / `finalizer` / `analysts` / `probes` are functions and registries, so a recorded
- * run configuration (a JSON row, a campaign spec, a resumed run's options) cannot carry them — and
- * a run with no `deliverable` cannot return a `winner` at all outside the sandbox backend, because
- * the finalizer keeps only children whose oracle passed and nothing else writes that verdict. A
- * caller that owns the code registers it here once and names it from data thereafter.
+ * Layout: `${dir}/spawn-journal.jsonl` (one JSONL record per event), `${dir}/blobs/` (one
+ * content-addressed JSON file per settled result), and `${dir}/coordination-log.jsonl`
+ * (questions, findings, answer decisions, and authorized continuation receipts retained as
+ * evidence). The directory is created on first write.
+ *
+ * Opt-in by construction — `createInMemoryRunContext()` is unchanged and stays the default, so no
+ * existing consumer writes to disk or resumes unless it asks for this.
  */
-interface SuperviseRegistry {
-  readonly deliverables?: SuperviseRegistryTable<DeliverableSpec<unknown>>;
-  readonly finalizers?: SuperviseRegistryTable<SupervisorFinalizer>;
-  readonly analysts?: SuperviseRegistryTable<AnalystRegistry>;
-  readonly probes?: SuperviseRegistryTable<WaitProbeRegistry>;
+declare function createFileRunContext(dir: string, opts?: InMemoryRunContextOptions): RunContext;
+//#endregion
+//#region src/runtime/supervise/run-layout.d.ts
+/**
+ * The on-disk supervisor-run layout: `<root>/.agent/supervisor/<id>`.
+ *
+ * This is the durable, cross-process face of a supervisor run — the counterpart to the in-process
+ * `Inbox` seam in `./inbox`. A run persists its state under one directory so that any OTHER process
+ * can find it after the fact: `@tangle-network/traces` reads exactly this layout via
+ * `traces analyze --supervisor-run-dir`, a restarted host can rehydrate a run it no longer holds
+ * handles to, and a human can steer a live worker by appending one NDJSON line. Until now the
+ * layout was defined only in the unpublished `loops` repo (`src/supervisor-control.ts`) — a
+ * published reader depending on an unpublished writer's convention — so the contract is promoted
+ * here, names preserved.
+ *
+ * `.agent` is the one dot-dir for ALL agent-owned state (skills already write
+ * `.agent/hypotheses/`, `.agent/skill-runs.jsonl`); supervisor runs live beside them rather than
+ * under a product-branded dir. Runs written by older writers used `.loops/supervisor/<id>` —
+ * readers that must see those keep a legacy fallback; this writer never creates `.loops` again.
+ *
+ * Layout, relative to `supervisorRunDir(root, id)`:
+ *
+ *   workers/<label>.inbox.ndjson   down-leg steer/answer requests for one worker (durable inbox);
+ *                                  each line is a {@link WorkerSteerRequest}
+ *   workers/<label>.ndjson         best-effort per-worker control-event log (delivery bookkeeping)
+ *
+ * Reads are tolerant by contract: a partial trailing line (a writer mid-append) or a corrupt line
+ * never poisons the rest of the file — later valid lines still matter.
+ *
+ * Promoted from `loops/src/supervisor-control.ts`. The one deliberate difference: the loops version
+ * resolved a worker id to its label through the run journal before writing a steer; that resolution
+ * stays with the caller (it is journal-format-specific), so `writeWorkerSteer` here takes the worker
+ * LABEL directly.
+ *
+ * @experimental
+ */
+/** One durable down-leg request appended to a worker's inbox file. */
+interface WorkerSteerRequest {
+  readonly id: string;
+  /** ISO timestamp of the append. */
+  readonly at: string;
+  /** Who asked — 'human', a brain label, a tool name. Provenance, not authorization. */
+  readonly source: string;
+  /** The worker LABEL the request targets (already resolved by the caller). */
+  readonly worker: string;
+  readonly message: string;
 }
-interface SuperviseOptions {
-  /** The conserved compute pool for the whole run. */
-  readonly budget: Budget;
-  /** Caller-created live handle for observing, steering, or cancelling this root manager. Runtime
-   * attaches it before execution and detaches it after the join barrier. */
-  readonly rootHandle?: RootHandle<unknown>;
-  /** Caller-owned cancellation for the complete recursive run. Aborting it cascades through the
-   * root scope and every live child, including acquisition and backend execution. */
-  readonly signal?: AbortSignal;
-  /** Trusted candidate and pursuit attribution for the root. The runtime derives profile/task
-   * digests itself from the exact detached values it executes. */
-  readonly execution?: AgentExecutionRef;
-  /** WHERE workers run — derives the worker seam. Provide this OR an explicit `makeWorkerAgent`. */
-  readonly backend?: ExecutorConfig;
-  /** The independent completion check for backend-derived workers and direct supervisor
-   *  submissions. Strongly recommended: without it the supervisor cannot submit its own work and
-   *  backend-derived workers fall back to their own validity signal. A `string` names an entry in
-   *  `registry.deliverables`. */
-  readonly deliverable?: DeliverableSpec<unknown> | string;
-  /** Resolve the completion check for one exact authorized backend-derived leaf. The callback runs
-   * after spawn authorization and driver classification, receives a detached immutable context,
-   * and may return `undefined` to use the run-wide `deliverable`. Driver profiles never call it. */
-  readonly resolveDeliverable?: (input: DeliverableResolutionInput) => DeliverableSpec<unknown> | undefined;
-  /** Name→value tables for the four code-valued options, so a recorded run configuration can name
-   *  them instead of carrying closures. See {@link SuperviseRegistry}. */
-  readonly registry?: SuperviseRegistry;
-  /** Where the coordination MCP binds when the supervisor is harness-driven. Omit = an ephemeral
-   *  port on `127.0.0.1`, which an off-host root cannot reach. A non-loopback host is refused
-   *  unless `allowUnauthenticatedRemote` acknowledges that the verbs are unauthenticated. */
-  readonly coordination?: CoordinationBinding;
-  /** Override the worker seam directly (tests / advanced) instead of deriving it from `backend`.
-   *  This is caller-owned execution: profile security, spawn authorization, and recursive-driver
-   *  selection below apply only to the backend-derived worker path. `authorizeMessage` still
-   *  governs continuations sent through Runtime's coordination tools. */
-  readonly makeWorkerAgent?: MakeWorkerAgent;
-  /** Run harness-brained supervisors here. Automatic execution supports a local `bridge`; a remote
-   *  sandbox requires an explicit `driveHarness` with a reachable coordination relay or tunnel.
-   *  Defaults to `backend`; separate it when managers and workers use different services. */
-  readonly driverBackend?: ExecutorConfig;
-  /** Security policy applied to every manager-authored child profile before budget reservation.
-   *  The default blocks local and remote MCP, hooks, and connection grants. Pass an explicit
-   *  allowlist to grant remote MCP hosts or other author-controlled capabilities. */
-  readonly profileSecurity?: AgentProfileSecurityPolicy;
-  /** Product authority over one complete manager-authored spawn. The callback sees the detached,
-   *  immutable profile, task, budget, label, and key together, so approving a profile cannot
-   *  authorize a different task. Return the exact allowed profile (which may be narrowed) plus
-   *  trusted candidate/pursuit attribution, or throw to refuse the whole spawn before reservation. */
-  readonly authorizeSpawn?: (input: {
-    readonly profile: AgentProfile$1;
-    readonly parent: AgentProfile$1;
-    /** Trusted identity of the manager authorizing this exact child. */
-    readonly parentIdentity: NodeExecutionIdentity;
-    /** Concrete manager node; never accepted from model-authored tool arguments. */
-    readonly parentNodeId: string;
-    /** Stable manager-scoped assignment, including deterministic unkeyed siblings. */
-    readonly assignmentId: string;
-    readonly task: unknown;
-    readonly budget: Budget;
-    readonly label: string;
-    readonly key?: string;
-    readonly depth: number;
-  }) => AuthorizedSpawn;
-  /** Product authority over every continuation sent to a live child. When spawn authorization is
-   * enabled, omitting this refuses steer/answer instructions instead of silently extending the
-   * authorized task. The exact worker identity and detached bytes are recorded before delivery. */
-  readonly authorizeMessage?: (input: DownMessageAuthorizationInput & {
-    readonly parent: AgentProfile$1;
-    readonly depth: number;
-  }) => AuthorizedDownMessage;
-  /** Decide whether an authorized child becomes another supervisor. By default only
-   *  `metadata.role === 'driver'` does. Products receive the same frozen post-authorization
-   *  context as `resolveDeliverable`, so trusted execution/assignment authority can override
-   *  model-authored metadata without a side channel. */
-  readonly isDriverProfile?: (input: AuthorizedSpawnContext) => boolean;
-  /** The supervisor's router substrate (`profile.harness` omitted or `cli-base`). The profile's
-   *  model wins. */
-  readonly router?: RouterConfig;
-  /** Inject the supervisor brain directly (tests / advanced). */
-  readonly brain?: ToolLoopChat;
-  /** Run an external-harness supervisor explicitly. Required for a remote sandbox; optional as a
-   *  caller-owned override for a local bridge. */
-  readonly driveHarness?: DriveHarness;
-  /** Resolve one custom external-harness session per trusted manager identity. Use this instead of
-   * `driveHarness` when recursive managers must be independently steerable. */
-  readonly resolveDriveHarness?: ResolveDriveHarness;
-  /** Required with a custom `driveHarness` or `resolveDriveHarness`: declares which complete
-   * AgentProfile axes that path really applies. Built-in bridge driving supplies its own
-   * full-profile contract. */
-  readonly driveHarnessMaterialization?: ProfileMaterializationContract;
-  /** Resolve product-owned tools from the exact trusted manager context. The same descriptors and
-   * handlers are bound to router and external-harness managers; resolution happens once per node.
-   * Each handler receives that manager scope's live cancellation signal in its trusted invocation
-   * context, including recursive parent and root cascades. */
-  readonly resolveSupervisorTools?: ResolveSupervisorTools;
-  /** Awaited product transaction hook for every coordination record. `eventId` is stable across a
-   * lost acknowledgement and durable restart; the record is not pull-visible until this commits. */
-  readonly onCoordinationEvent?: (context: SupervisorNodeContext, eventId: Sha256Digest, record: BusRecord<CoordinationEvent>) => void | Promise<void>;
-  /** WORK tools the supervisor may call DIRECTLY — so a recursive atom can ACT (do simple work
-   *  itself) OR SPAWN (delegate when it needs parallelism), not be a pure manager. Pair with
-   *  `executeExtraTool`. Router arm only (`profile.harness` omitted or `cli-base`). */
-  readonly extraTools?: ReadonlyArray<{
-    readonly name: string;
-    readonly description?: string;
-    readonly parameters: Record<string, unknown>;
-  }>;
-  /** Runs an `extraTools` call; null/undefined falls through to the coordination dispatch. */
-  readonly executeExtraTool?: (name: string, args: Record<string, unknown>) => Promise<string | null | undefined>;
-  /** Per-child budget reserved on each spawn. Defaults to a quarter of the pool's tokens. */
-  readonly perWorker?: Budget;
-  /** Hard cap on simultaneously executing spawned workers across the WHOLE recursive tree. The
-   *  root is excluded; nested drivers and leaves share one allocation, so recursion cannot multiply
-   *  the cap. Omit/`<= 0` = no cap (the conserved pool stays the only bound). */
+/** The root every supervisor run of one workspace lives under. */
+declare function supervisorRunsRoot(rootDir: string): string;
+/** The run directory every artifact of one supervisor run lives under. */
+declare function supervisorRunDir(rootDir: string, id: string): string;
+/**
+ * Where a pre-rename writer put the same run (`<root>/.loops/supervisor/<id>`). Readers that must
+ * see historical runs check {@link supervisorRunDir} first and fall back to this; nothing writes
+ * here anymore.
+ */
+declare function legacySupervisorRunDir(rootDir: string, id: string): string;
+/**
+ * The pre-rename runs root (`<root>/.loops/supervisor`). Only readers that ENUMERATE historical
+ * runs need this — the per-id form is {@link legacySupervisorRunDir}. Nothing writes here.
+ */
+declare function legacySupervisorRunsRoot(rootDir: string): string;
+/** A worker label reduced to a safe filename stem. Empty labels get a stable fallback. */
+declare function safeWorkerFile(label: string): string;
+/** The directory holding every per-worker file of one run (inboxes and control-event logs). */
+declare function supervisorWorkersDir(eventDir: string): string;
+/** The durable inbox file for one worker of one run. */
+declare function workerInboxFile(rootDir: string, supervisorId: string, worker: string): string;
+/** Same, addressed from an already-known run directory (the reader's usual entry point). */
+declare function workerInboxFileFromEventDir(eventDir: string, worker: string): string;
+/**
+ * The best-effort control-event log for one worker (`workers/<label>.ndjson`) — delivery
+ * bookkeeping for steers, plus whatever lifecycle events a writer chooses to append. Distinct from
+ * the inbox: the inbox is the durable down-leg queue, this is the record of what happened to it.
+ */
+declare function workerControlLogFile(eventDir: string, worker: string): string;
+/**
+ * Durably append one steer request to a worker's inbox and log the delivery attempt.
+ *
+ * The inbox append is the durable act; the control-event log is best-effort bookkeeping and may
+ * silently fail without voiding the steer.
+ */
+declare function writeWorkerSteer(rootDir: string, supervisorId: string, worker: string, message: string, source?: string): {
+  worker: string;
+  file: string;
+  request: WorkerSteerRequest;
+};
+/** Read every valid steer request in a worker's inbox. Corrupt or partial lines are skipped. */
+declare function readWorkerSteerRequests(eventDir: string, worker: string): WorkerSteerRequest[];
+//#endregion
+//#region src/runtime/supervise/scope.d.ts
+/** Construction args for `createScope`. The supervisor threads the shared pool, journal,
+ *  blob store, and executor registry through; `depth`/`maxDepth` pair the runtime
+ *  recursion ceiling with the conserved pool (R3). */
+interface ScopeArgs {
+  /** This scope's owning node id — children get `${parentId}:s${seq}` ids. */
+  readonly parentId: NodeId;
+  /** Journal/blob root key the supervisor `beginTree`'d. */
+  readonly root: NodeId;
+  /** The reservation pool for this scope: the root total or one nested allocated partition. */
+  readonly pool: BudgetPool;
+  /** Append-only spawn journal; this scope writes `spawned` + `settled` records. */
+  readonly journal: SpawnJournal;
+  /** Content-addressed result store backing `outRef` rehydration. */
+  readonly blobs: ResultBlobStore;
+  /** The open executor resolver (BYO → router/inline → registered harness factory). */
+  readonly executors: ExecutorRegistry;
+  /** Predicate resolver for `poll` wait-states. Absent ⇒ `wait` refuses a `poll` with
+   *  `unknown-probe`; `timer` waits never touch it. */
+  readonly probes?: WaitProbeRegistry;
+  /** Injected sleeper for wait-states — a test drives a week-long timer in microseconds. */
+  readonly waitSleep?: (ms: number, signal: AbortSignal) => Promise<void>;
+  /** Per-spawn executor-construction seams (sandbox client, router config, cli bin). */
+  readonly seams: Readonly<Record<string, unknown>>;
+  /** This scope's recursion depth (root = 0). */
+  readonly depth: number;
+  /** Runtime recursion-depth ceiling — a spawn past it fails closed `depth-exceeded`. */
+  readonly maxDepth?: number;
+  /** Root-owned limit on live spawned workers across this scope and every nested scope. */
   readonly maxLiveWorkers?: number;
-  /** Analyst lenses available to the driver. Required for `analyzeOnSettle`. Unset → status quo
-   *  (the driver receives settled worker outputs, no analyst findings). A `string` names an entry in
-   *  `registry.analysts`. */
-  readonly analysts?: AnalystRegistry | string;
-  /** Analyst kind ids run AUTOMATICALLY when a worker settles `done` — each re-enters as a `finding`
-   *  the driver pulls (`await_event`) and composes its next steer from. The self-improving UP-leg,
-   *  threaded to the driver at this level (propagate to sub-drivers via a recursive `makeWorkerAgent`).
-   *  Omit/empty = status quo (no analyst feed). Requires `analysts`. */
-  readonly analyzeOnSettle?: ReadonlyArray<string>;
-  /**
-   * Watch every worker's LIVE tool trace with the online detector panel and raise a `finding` the
-   * moment one loops or error-storms — so the supervisor learns it mid-run (via `await_event`)
-   * instead of at settle. Pairs with a steerable worker: the finding is the evidence, `steer_agent`
-   * is the correction. Requires a backend whose executor exposes a trace source (the steerable
-   * sandbox worker and the pi wrapper do); other runtimes are simply not watched.
-   *
-   * Omit = off (status quo — no online watching, no extra events).
-   */
-  readonly watchWorkers?: WorkerWatchOptions;
-  /** Idle time after which `observe_agent` reports a running worker as `stalled`. A derived read
-   *  at observation time — nothing is killed or retried. Omit = the runtime default. */
-  readonly stallAfterMs?: number;
-  /** Worker output store. Defaults to in-memory. */
-  readonly blobs?: ResultBlobStore;
+  /** @internal Shared counter inherited by nested scopes. Callers set `maxLiveWorkers`; the root
+   *  scope creates this state once and passes the same object through its recursion seam. */
+  readonly liveWorkerCapacity?: LiveWorkerCapacityState;
+  /** Abort signal for this scope; an abort cascades into every live child's executor. */
+  readonly signal: AbortSignal;
+  /** Injected clock — keeps the journal `at` timestamp deterministic in tests. */
+  readonly now?: () => number;
+  /** Lifecycle stream sink. `spawn` emits `agent.spawn`, `next` emits `agent.child` — the
+   *  SAME stream `runAgentRounds`/`tool-loop` feed, so the recursive tree is ONE observable stream
+   *  (the topology viewer reads it). Undefined ⇒ the journal stays the only record. */
+  readonly hooks?: RuntimeHooks;
   /**
-   * Make the run DURABLE: journal + result blobs + the coordination side-log are file-backed under
-   * this directory (`createFileRunContext`), fsynced per write, and the supervisor reads the prior
-   * tree first. Re-running with the same `runDir` AND the same `runId` resumes only when the exact
-   * root profile/task identity and declared budget match. The original absolute deadline and prior
-   * measured spend are restored before new admission. The built-in driver is resume-aware: children
-   * that already settled, including their exact execution identities, are replayed onto
-   * `Scope.resume` (and into the driver's settled ledger + its first context), keyed assignments
-   * (`spawn_agent`'s `key`) resolve to their committed results instead of re-running, pending
-   * waits re-arm on their original deadlines, and the coordination log loads prior questions,
-   * findings, and instruction receipts. The router arm receives all three in its resume brief; the
-   * external arm seeds prior questions while findings and receipts remain in the durable log.
-   * Instruction receipts are evidence and are never delivered automatically to a replacement
-   * worker. The final result spans both processes' work. Unset = in-memory, fresh every call.
-   *
-   * The boundary that remains: work that was IN FLIGHT when the process died is not recovered —
-   * the built-in executors cannot re-attach to a dead process's executions. Each such assignment
-   * resumes as explicitly lost/in-doubt, its full declared reservation is charged conservatively,
-   * and its token/dollar telemetry remains unknown. A retry is admitted only from safely remaining
-   * capacity, so restart cannot mint a fresh budget or slide the original absolute deadline.
-   *
-   * `runId` matters here: it defaults to the constant `'supervise'`, which is fine for a single
-   * resumable run per directory but collides across concurrent runs sharing one `runDir`.
+   * Trace context to hand down to each spawned worker (`SupervisorOpts.workerTrace`). Called with
+   * THIS scope's own `parentId` — the node doing the spawning — and the resolved context is seeded
+   * onto each child's `ExecutorContext` under `workerTraceSeamKey`. Absent (the untraced default)
+   * ⇒ no seam is seeded and no worker environment is touched.
    */
-  readonly runDir?: string;
-  /** Override the spawn journal directly (advanced; `runDir` is the ordinary durable path). Pair
-   *  with `blobs` — a journal whose result payloads live in a different store cannot replay. */
-  readonly journal?: SpawnJournal;
-  /** Predicate registry for `poll` wait-states (`Scope.wait`). A `poll` names its predicate so the
-   *  wait survives a restart; this is what the name resolves against. Unset ⇒ `poll` waits are
-   *  refused `unknown-probe` and `timer` waits still work. A `string` names an entry in
-   *  `registry.probes`. */
-  readonly probes?: WaitProbeRegistry | string;
+  readonly workerTrace?: WorkerTraceResolver;
   /**
-   * PROGRESS-derived stop rule (router-brained supervisor). Ends a run that has stopped LEARNING
-   * before it exhausts a ceiling — the answer to "a run should end because it is done or stuck,
-   * not because it ran out". It composes with the budget guards and can never override one.
-   *
-   * Build it from `supervise/stop-rules`: `plateau({window, minDelta})`,
-   * `noProgressFor({ms, settles})`, `allWorkersStalled({...})`, combined with `anyOf`/`allOf`. The
-   * thresholds are policy and stay with you; the enforcement lives in the runtime. Omit = ceilings
-   * only (unchanged behavior).
+   * Present when this run RECORDS spans but the worker backend has NO channel to carry the trace
+   * context (`WORKER_TRACE_PROPAGATION[backend] === false` — bridge / cli-worktree have no env
+   * channel; router / router-tools / provider have no worker process). Each spawn then journals a
+   * `trace-unpropagated` event naming the severed hop, so a child whose trace shows up as a
+   * disconnected root is a recorded fact rather than a silent stranger. Absent ⇒ either the run
+   * is untraced or the backend propagates; nothing is journaled.
    */
-  readonly stopRule?: StopRule;
-  /** One-shot notification of WHY a `stopRule` ended the run — so a caller records the reason
-   *  instead of inferring an early stop from an unexhausted budget. */
-  readonly onProgressStop?: (reason: string) => void;
-  readonly maxDepth?: number;
-  readonly maxTurns?: number;
-  /** Give the supervisor brain a chapter-lifecycle on its OWN context window (router arm only): once
-   *  its coordination transcript exceeds `thresholdTokens` it distills to a compact progress note and
-   *  continues, instead of re-billing the whole transcript every turn (the cost that makes the LLM-brain
-   *  front door lose to a dumb-Ralph respawn). The live `Scope` roster is the durable state across
-   *  chapters. Default off. `distill` defaults to a brain self-summary + the settled-worker roster. */
-  readonly compaction?: ToolLoopCompactionOptions;
-  readonly runId?: string;
-  readonly now?: () => number;
-  /** Restrict the run to this subset of models. When set, every configured model — the
-   *  supervisor router model, the profile's model, and the backend's model — must be a member,
-   *  or `supervise()` throws a `ConfigError` before any compute is spent. Unset = unrestricted. */
-  readonly allowedModels?: readonly string[];
-  /** How the settled-worker ledger becomes the run's output. Default `bestDelivered` — the single
-   *  highest-scoring DELIVERED child (the exact behavior every existing caller had). Alternatives:
-   *  `collectDelivered` (every verified distinct output with provenance — a Pareto set / recorded
-   *  disagreement) or a custom `SupervisorFinalizer`. Whatever the finalizer, it operates on
-   *  structurally DELIVERED outputs only — an undelivered or invalid child stays ineligible. A
-   *  `string` names an entry in `registry.finalizers`. */
-  readonly finalizer?: SupervisorFinalizer | string;
-  /** Lifecycle observers for the whole recursive tree (`Scope` re-seeds them into every nested
-   *  scope). Composed with the `otel` recorder below when both are set. Omit = no observers, which
-   *  is the behavior every existing caller has. */
-  readonly hooks?: RuntimeHooks;
+  readonly workerTraceUnpropagated?: {
+    readonly backend: string;
+    readonly reason: 'no-env-channel' | 'no-worker-process' | 'caller-omitted';
+  };
+  /** @internal Trusted root-adapter publication channel. It is never exposed as a Scope method. */
+  readonly ownerMaterialization?: {
+    readonly runtime: NodeSnapshot['runtime'];
+    readonly authoredProfile?: unknown;
+    readonly attemptId: string;
+    readonly prior?: ProfileMaterializationReceipt;
+    readonly journalRoot?: NodeId;
+    readonly nodeId?: NodeId;
+    readonly requiredKnown?: boolean;
+    readonly onReceipt?: (materialization: ProfileMaterializationReceipt, binding: ExecutionBindingReceipt) => void;
+  };
   /**
-   * OPT-IN OTLP tracing: emit one span per supervised node (opened at spawn, closed at settle,
-   * parented to its parent node's span) plus an `LLM` child span per metered driver turn, so the
-   * tree is readable by any trace viewer instead of only by a journal parser. See `otel-spans.ts`.
-   *
-   * Omit and the run emits nothing, allocates no recorder, and installs no hook — telemetry is
-   * never a default. Present with no reachable endpoint (no `exportConfig.endpoint` and no
-   * `OTEL_EXPORTER_OTLP_ENDPOINT`) is also a no-op. The spawn journal is untouched either way:
-   * spans are telemetry, never the replay/resume record.
+   * Resume seam — set ONLY by the supervisor when `SupervisorOpts.resume` is on AND a non-empty
+   * journal tree exists for this root. It carries the replayed committed work (so `scope.resume`
+   * exposes it to a resume-aware `act`) and the recorded ordinal/cursor maxima the new counters
+   * continue past, so a freshly-spawned child never reuses a journaled `seq`. Absent ⇒ fresh run.
    */
-  readonly otel?: Omit<SupervisorSpanOptions, 'runId' | 'now'>;
-}
-/** The product-authorized result for one complete spawn request. Attribution is never accepted
- * from the manager itself; it enters only through this trusted callback. */
-interface AuthorizedSpawn {
-  readonly profile: AgentProfile$1;
-  readonly execution?: AgentExecutionRef;
+  readonly resumeFrom?: {
+    readonly settled: ReadonlyArray<Settled<unknown>>;
+    readonly view: TreeView;
+    /** Highest `spawned` ordinal already journaled; new spawns start at `+1`. */
+    readonly maxSpawnOrdinal: number;
+    /** Highest cursor `seq` already journaled; new settlements start at `+1`. */
+    readonly maxCursorSeq: number;
+    /** Highest `waiting` ordinal already journaled; new waits start at `+1`. */
+    readonly maxWaitOrdinal: number;
+    /** Waits journaled as armed but never woken — re-armed (same node id, same absolute deadline)
+     *  when `wait` is called again with the SAME label. */
+    readonly waits: ReadonlyArray<PendingWait>;
+    /** Keyed assignments from the prior journal — what a keyed re-spawn resolves against. */
+    readonly keys: ReadonlyMap<string, ResumedKeyState<unknown>>;
+    /** Prior committed spend summed off the journal (settled child work + metered inference). */
+    readonly priorSpend: {
+      readonly childWork: Spend;
+      readonly driverInference: Spend;
+    };
+  };
 }
-/** Exact trusted context after a manager-authored spawn has passed product authorization. */
-interface AuthorizedSpawnContext {
-  readonly profile: AgentProfile$1;
-  readonly parent: AgentProfile$1;
-  readonly parentIdentity: NodeExecutionIdentity;
-  readonly execution: NodeExecutionIdentity;
-  readonly parentNodeId: string;
-  readonly assignmentId: string;
-  readonly task: unknown;
-  readonly budget: Budget;
-  readonly label: string;
-  readonly key?: string;
-  readonly depth: number;
+/** Mutable only inside Scope admission/release. Every nested scope receives this exact object. */
+interface LiveWorkerCapacityState {
+  readonly max: number | undefined;
+  live: number;
 }
-/** Exact trusted context for selecting one backend-derived leaf's completion check. */
-type DeliverableResolutionInput = AuthorizedSpawnContext;
-/** One-call supervisor: build + run a supervisor from its profile with sensible defaults; the raw `supervisorAgent` + `createSupervisor().run` seams stay available for power use. */
-declare function supervise(profile: SupervisorProfile, task: unknown, opts: SuperviseOptions): Promise<SupervisedResult<unknown>>;
+/** Create the reactive `Scope` a driver's `Agent.act` runs inside: spawn children on an atomically reserved conserved budget, settle via the `next()` cursor, journal for replay. */
+declare function createScope<Out>(args: ScopeArgs): Scope<Out>;
+/**
+ * The step-8 merge-boundary adapter (M4): rehydrate a `Settled.done` into the kernel's
+ * `Iteration` shape so `defaultSelectWinner` stays single-sourced — the supervisor selects
+ * across settled children with the SAME argmax the loop kernel uses, not a forked copy.
+ *
+ * `index` is the cursor `seq` (the recorded, replay-stable order); `output`/`verdict`/
+ * `tokenUsage`/`costUsd` are read straight off the settlement (already rehydrated from the
+ * `outRef` blob by `next()`). Events are empty — a settled child is an opaque leaf result,
+ * not a sandbox event stream — and the timing/cost fields project its conserved `Spend`.
+ * Fail loud on a `down` settlement: only a `done` child is an iteration.
+ */
+declare function settledToIteration<Out>(settled: Settled<Out>): Iteration<unknown, Out>;
 //#endregion
 //#region src/runtime/supervise/supervisor.d.ts
 /** Create a supervisor that owns one recursive agent execution tree. */
@@ -8193,5 +8557,5 @@ interface VerifierEnvironmentOptions {
 /** Any checkable task as an `Environment`, no tool surface required: the artifact is the worker's answer and the domain is one deployable `check` over it. */
 declare function createVerifierEnvironment(opts: VerifierEnvironmentOptions): Environment;
 //#endregion
-export { SuperviseRegistry as $, sample as $a, WorkerSpawnContext as $c, FileResultBlobStore as $d, runPersonified as $i, FeedbackStore as $l, ProfileRichnessThresholds as $n, PanelJudge as $o, AuthoredStrategy as $r, GroupOf as $s, DispatchStopReason as $t, DelegationError as $u, GitWorkspaceOptions as A, AgenticOptions as Aa, createWaterfallCollector as Ac, FileDelegationStoreOptions as Ad, promptOnlyProfileMaterialization as Af, createSandboxLineage as Ai, SteerableSandboxSession as Al, DeliveredOutput as An, ObserveInput as Ao, structuralRollout as Ar, ShapeBudget as As, workerControlLogFile as At, DelegationArgs as Au, analyzeTrace as B, Strategy as Ba, DownMessageAuthorizationInput as Bc, ValidationError as Bd, AcquireOptions as Bi, DiffOptions as Bl, CoordinationLog as Bn, EqualKArm as Bo, EvolutionArchiveNode as Br, LeaderboardScenario as Bs, patchDelivered as Bt, hashIdempotencyInput as Bu, closingWorkerNote as C, BenchmarkLift as Ca, areaUnderCurve as Cc, capDelegationTrace as Cd, assertProfileMaterialization as Cf, TurnResult as Ci, SandboxSeam as Cl, allOf as Cn, InProcessSandboxClientOptions as Co, defaultStructuralRolloutPolicy as Cr, LoopShape as Cs, legacySupervisorRunDir as Ct, DriveTurnTick as Cu, UntrackedCopyStats as D, Environment as Da, WaterfallCollector as Dc, DelegationStateCorruptError as Dd, profileMaterializationAxes as Df, SandboxLineage as Di, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Dl, noProgressFor as Dn, HarvestReport as Do, resolveEntrySymbol as Dr, PersonaExecutors as Ds, supervisorRunDir as Dt, formatDetachedSessionRef as Du, CopyOptions as E, BenchmarkTaskRow as Ea, renderAnytimeTable as Ec, DelegationPersistenceError as Ed, fullProfileMaterialization as Ef, ForkCapableBox as Ei, createExecutorRegistry as El, createProgressTracker as En, HarvestFailure as Eo, officialChecksFromMeta as Er, PersonaContext as Es, safeWorkerFile as Et, detachedTurnEvents as Eu, gitWorkspace as F, ArtifactHandle as Fa, ContinuationInstruction as Fc, ConfigError as Fd, worktreeCliProfileMaterialization as Ff, mapSandboxToolEvent as Fi, WorktreeCheckRunner as Fl, collectDelivered as Fn, AssertTraceDerivedFindings as Fo, StreamAgentTurnOptions as Fr, LeaderboardBenchTask as Fs, InMemoryRunContextOptions as Ft, DelegationRunContext as Fu, workerTraceAnalysisStore as G, StrategyShotResult as Ga, Question as Gc, EventBus as Gd, PromotionVerdict as Gi, captureWorktreeDiff as Gl, BudgetPoolRestore as Gn, FanoutOptions as Go, EvolutionReport as Gr, CompletionEvidence as Gs, SupervisorSpanOptions as Gt, DelegateFeedbackResult as Gu, WorkerToolTraceArtifact as H, StrategyCtx as Ha, DownMessageDeliveryOutcome as Hc, BusEvent as Hd, ResolveSandboxClientOptions as Hi, GitRunner as Hl, FileCoordinationLog as Hn, EqualKOnCostOptions as Ho, EvolutionBandInfo as Hr, LeaderboardSpec as Hs, WorktreePatchArtifact as Ht, DelegateCodeConfig as Hu, jjWorkspace as I, CorpusReadbackOptions as Ia, CoordinationEvent as Ic, JudgeError as Id, sumSandboxUsage as Ii, WorktreeCommandResult as Il, pickBestDelivered as In, CombinatorShape as Io, collectAgentTurn as Ir, LeaderboardBenchmarkAdapter as Is, RunContext as It, DelegationTaskQueue as Iu, AuthorizedSpawn as J, breadthStrategy as Ja, QuestionOption as Jc, WatchTraceOptions as Jd, trajectoryReport as Ji, JsonRpcMessage as Jl, ReservationTicket as Jn, FlatWidenGate as Jo, discriminatingMeans as Jr, completionAuthorizes as Js, createSupervisorSpanRecorder as Jt, DelegateResearchResult as Ju, createRootHandle as K, SurfaceScore as Ka, QuestionDecision as Kc, PublishOptions as Kd, promotionGate as Ki, createWorktree as Kl, BudgetReadout as Kn, FanoutSynthesis as Ko, ReproductionCheck as Kr, CompletionPolicy as Ks, SupervisorSpanOutcome as Kt, DelegateResearchArgs as Ku, localShell as L, RunAgenticOptions as La, CoordinationTools as Lc, NotFoundError as Ld, CriuCapableClient as Li, WorktreeHarnessResult as Ll, runFinalizer as Ln, Corpus as Lo, streamAgentTurn as Lr, LeaderboardFlagSpec as Ls, createFileRunContext as Lt, DelegationTaskQueueOptions as Lu, Workspace as M, AgenticSurface as Ma, AnalystRegistry as Mc, AgentEvalError$1 as Md, renderProfileMaterializationIssues as Mf, createSandboxToolPartState as Mi, Inbox as Ml, FinalizerSettled as Mn, defaultAnalystInstruction as Mo, AgentTurnBackend as Mr, ShapeRegistry as Ms, workerInboxFileFromEventDir as Mt, DelegationResumeContext as Mu, WorkspaceCommit as N, AgenticTask as Na, AuthorizeDownMessage as Nc, AgentEvalErrorCode as Nd, sandboxActProfileMaterialization as Nf, extractLlmCallEvent as Ni, InboxMessage as Nl, SupervisorFinalizer as Nn, observe as No, AgentTurnUsage as Nr, DefinedLeaderboard as Ns, writeWorkerSteer as Nt, DelegationResumeDriver as Nu, copyUntrackedIntoClone as O, printBenchmarkReport as Oa, WaterfallReport as Oc, DelegationStore as Od, promptControlProfileMaterialization as Of, SandboxLineageHandle as Oi, SandboxSteeringOptions as Ol, plateau as On, harvestCorpus as Oo, sandboxCheckRunner as Or, RunPersonified as Os, supervisorRunsRoot as Ot, parseDetachedSessionRef as Ou, WorkspaceRun as P, AgenticTool as Pa, AuthorizedDownMessage as Pc, BackendTransportError as Pd, validateProfileMaterialization as Pf, mapSandboxEvent as Pi, createInbox as Pl, bestDelivered as Pn, renderReport as Po, CollectedAgentTurn as Pr, LeaderboardBenchScore as Ps, InMemoryRunContext as Pt, DelegationResumeTick as Pu, SuperviseOptions as Q, runAgentic as Qa, SettledWorker as Qc, gateOnDeliverable as Qd, definePersona as Qi, FeedbackEvent as Ql, ProfileRichness as Qn, Panel as Qo, AuthorStrategyOptions as Qr, AxisScoresOf as Qs, DispatchReport as Qt, DelegateUiAuditRoute as Qu, runInWorkspace as R, ShotPersona as Ra, CoordinationToolsOptions as Rc, PlannerError as Rd, SandboxCapabilities as Ri, WorktreeProfileMaterializationReceipt as Rl, runTree as Rn, CorpusFilter as Ro, ChampionPick as Rr, LeaderboardIterationInfo as Rs, createInMemoryRunContext as Rt, SubmitInput as Ru, WorkerEvidenceInput as S, BenchmarkConfig as Sa, anytimeReport as Sc, buildDelegationTraceSpans as Sd, ValidateProfileMaterializationOptions as Sf, SandboxRunAbortError as Si, RouterToolsSeam as Sl, StopRule as Sn, InProcessPromptCtx as So, defaultExtractCandidate as Sr, DefinePersonaInput as Ss, WorkerSteerRequest as St, DriveTurnCapableBox as Su, settledWorkerOut as T, BenchmarkStrategySummary as Ta, plateauLength as Tc, createDelegationTraceCollector as Td, defineProfileMaterializationContract as Tf, CheckpointCapableBox as Ti, createExecutor as Tl, anyOf as Tn, HarvestCorpusOptions as To, modelAuthoredChecks as Tr, Persona as Ts, readWorkerSteerRequests as Tt, createDetachedTurnResumeDriver as Tu, captureWorkerTraceEvidence as U, StrategyMessage as Ua, DownMessageEvent as Uc, BusRecord as Ud, resolveSandboxClient as Ui, RemoveWorktreeOptions as Ul, PriorCoordination as Un, EqualKVerdict as Uo, EvolutionCandidate as Ur, defineLeaderboard as Us, createWorktreeCliExecutor as Ut, DelegateCodeResult as Uu, WORKER_TOOL_TRACE_SCHEMA_VERSION as V, StrategyArtifacts as Va, DownMessageDeliveryAttempt as Vc, CoderOutput as Vd, acquireSandbox as Vi, DiffResult as Vl, CoordinationOwnerId as Vn, EqualKOnCost as Vo, EvolutionAuthor as Vr, LeaderboardScore as Vs, WorktreeCliExecutorOptions as Vt, DelegateCodeArgs as Vu, parseWorkerToolTraceArtifact as W, StrategyResult as Wa, MakeWorkerAgent as Wc, BusStats as Wd, PromotionGateOptions as Wi, WorktreeHandle as Wl, BudgetPool as Wn, Fanout as Wo, EvolutionGeneration as Wr, CompletionAnalyst as Ws, SupervisorSpanAttributes as Wt, DelegateFeedbackArgs as Wu, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as X, depthStrategy as Xa, QuestionRecord as Xc, watchTrace as Xd, createShapeRegistry as Xi, McpToolDescriptor$1 as Xl, spendFromUsageEvents as Xn, LoopUntilSpec as Xo, runStrategyEvolution as Xr, sentinelCompletion as Xs, assertProfileModelsAllowed as Xt, DelegateUiAuditConfig as Xu, AuthorizedSpawnContext as Y, defineStrategy as Ya, QuestionPolicy as Yc, defaultToolDetectors as Yd, builtinShapes as Yi, JsonRpcResponse as Yl, createBudgetPool as Yn, LoopUntil as Yo, pickChampion as Yr, deterministicCompletion as Ys, assertModelAllowed as Yt, DelegateUiAuditArgs as Yu, DeliverableResolutionInput as Z, refine as Za, QuestionUrgency as Zc, DeliverableSpec as Zd, registerShape as Zi, McpTransport as Zl, AuthoredProfile as Zn, LoopUntilState as Zo, selectChampion as Zr, stopSentinel as Zs, ConcurrencyCaps as Zt, DelegateUiAuditResult as Zu, WorktreeFanoutOptions as _, McpEndpoint as _a, auditIntent as _c, DELEGATION_TRACE_MAX_BYTES as _d, CanonicalAgentProfileMaterializationAxis as _f, Deliverable as _i, CliWorktreeBridgeSeam as _l, ProgressSample as _n, resolveMcpServerLaunch as _o, StructuralRolloutResult as _r, WidenDecision as _s, resolveSupervisorProfile as _t, createFleetWorkspaceExecutor as _u, SandboxInstance$1 as a, loopUntil as aa, PairwiseVerdict as ac, DelegationProgress as ad, SpawnForestInDoubtNode as af, NaiveDriverOptions as ai, createMcpServer as al, rollingDispatch as an, loopDispatch as ao, profileRichnessFinding as ar, RenderCorpusToInstructionsOptions as as, DriveHarnessOwnerContext as at, DelegateRunCtx as au, NOTE_MAX_CHARS as b, sanitizeMcpToolSchema as ba, AnytimeStrategySummary as bc, DelegationTraceCollector as bd, ProfileMaterializationContract as bf, OpenSandboxRunPromptOptions as bi, ProviderSeam as bl, ProgressView as bn, inlineSandboxClient as bo, compareCheckOutcomes as br, WinnerStrategy as bs, createScope as bt, DetachedTurn as bu, VerifierEnvironmentOptions as c, selectValidWinner as ca, leaderboard as cc, DelegationStatusArgs as cd, SpawnForestTree as cf, naiveDriver as ci, DELEGATE_TOOL_NAME as cl, delegate as cn, defaultSelectWinner as co, CheckOutcome as cr, ScopeWidenGate as cs, ResolveSupervisorTools as ct, SettleDetachedCoderTurnOptions as cu, SuperviseSurfaceResult as d, CreateScopeAnalystOptions as da, renderLeaderboardMarkdown as dc, FeedbackRefersTo as dd, pendingWaits as df, McpSpawnFault as di, DelegateHandlerOptions as dl, DriverAgentOptions as dn, LocalSandboxClientOptions as do, CheckSource as dr, TrajectoryReport as ds, SupervisorNodeContext as dt, detachedSessionDelegate as du, FileCorpus as ea, Interval as ec, DelegationFeedbackSnapshot as ed, FileSpawnJournal as ef, assertStrategyContract as ei, WorkerWatchOptions as el, DispatchUnit as en, sampleThenRefine as eo, asAuthoredProfile as er, PanelSpec as es, SuperviseRegistryTable as et, InMemoryFeedbackStore as eu, SurfaceWorkerConfig as f, RegistryAnalyzeProjection as fa, renderLeaderboardSvg as fc, ResearchOutputShape as fd, replaySpawnTree as ff, McpToolDescriptor as fi, DelegateResult as fl, driverAgent as fn, localSandboxClient as fo, CheckSourceCtx as fr, TrajectoryReportFn as fs, SupervisorNodeContextSeed as ft, settleDetachedCoderTurn as fu, AuthoredHarness as g, registryScopeAnalyst as ga, IntentAudit as gc, CappedDelegationTrace as gd, AssertProfileMaterializationOptions as gf, materializeLocalMcp as gi, CliSeam as gl, PlateauOptions as gn, mcpSecretEnvMetadataKey as go, StructuralRolloutPolicy as gr, Widen as gs, assertCoordinationBinding as gt, SiblingSandboxExecutorOptions as gu, superviseSurface as h, createScopeAnalyst as ha, AuditIntentOptions as hc, UiAuditorDelegationOutput as hd, AgentProfileMaterializationAxis as hf, connectStdioMcp as hi, BridgeSeam as hl, NoProgressForOptions as hn, envKeyProvider as ho, StructuralRolloutMessage as hr, VerifySpec as hs, SupervisorToolInvocationContext as ht, FleetWorkspaceExecutorOptions as hu, SandboxEvent$1 as i, flatWidenGate as ia, PairwiseOptions as ic, DelegationProfile as id, SpawnForestEvent as if, DumbDriverOptions as ii, createInProcessTransport as il, queueOf as in, loopCampaignDispatch as io, defaultProfileRichnessThresholds as ir, RenderCorpusToInstructions as is, DriveHarness as it, CoderReviewer as iu, Shell as j, AgenticRunResult as ja, AnalystFindingEvent as jc, InMemoryDelegationStore as jd, promptResourceProfileMaterialization as jf, SandboxToolPartState as ji, createSteerableSandboxSession as jl, FinalizeContext as jn, ObserveOptions as jo, visibleCheckScore as jr, ShapeContext as js, workerInboxFile as jt, DelegationRecord as ju, withUntrackedArtifacts as k, runBenchmark as ka, WaterfallSpan as kc, FileDelegationStore as kd, promptModelProfileMaterialization as kf, SessionCapableBox as ki, SteerableSandboxArgs as kl, sampleFromSettled as kn, Observation as ko, selectBestIndex as kr, RunPersonifiedOptions as ks, supervisorWorkersDir as kt, runDetachedTurn as ku, createVerifierEnvironment as l, verify as la, pairwiseSignificance as lc, DelegationStatusResult as ld, loadSpawnForest as lf, LocalMcpMaterialization as li, DelegateArgs as ll, CoordinationMcpHandle as ln, runAgentRounds as lo, CheckRunContext as lr, SteerContext as ls, ResolvedSupervisorProfile as lt, UiAuditorDelegate as lu, failuresAnalyst as m, buildSteerContext as ma, AuditIntentInput as mc, UiAuditLensFilter as md, AGENT_PROFILE_MATERIALIZATION_AXES as mf, StdioMcpServerSpec as mi, validateDelegateArgs as ml, AllWorkersStalledOptions as mn, ResolvedMcpServerLaunch as mo, StructuralRolloutConfig as mr, Verify as ms, SupervisorToolDescriptor as mt, FleetHandle as mu, AnalystFinding$1 as n, renderCorpusToInstructions as na, LeaderboardOptions as nc, DelegationHistoryEntry as nd, InMemorySpawnJournal as nf, strategyAuthorContract as ni, McpServer as nl, effectiveConcurrency as nn, LoopDispatchOptions as no, authoredWorker as nr, Pipeline as ns, workerFromBackend as nt, CoderDelegate as nu, computeFindingId$1 as o, panel as oa, ProfileKeyOf as oc, DelegationResultPayload as od, SpawnForestMissingTree as of, SteeringDecision as oi, DELEGATE_DESCRIPTION as ol, DelegateOptions as on, RunAgentRoundsOptions as oo, supervisorInstructions as or, ScopeAnalyst as os, ObserveSupervisorNodeEvent as ot, DetachedSessionDelegateOptions as ou, SurfaceWorkerOut as p, assertTraceDerivedFindings as pa, renderPairwiseMarkdown as pc, ResearchSource as pd, contentAddress as pf, StdioMcpConnection as pi, createDelegateHandler as pl, finalizeBestDelivered as pn, KeyProvider as po, RepairStop as pr, TrajectoryReportOptions as ps, SupervisorProfile as pt, DelegationExecutor as pu, createSupervisor as q, adaptiveRefine as qa, QuestionLevel as qc, createEventBus as qd, equalKOnCost as qi, removeWorktree as ql, ReservationRejection as qn, FanoutWinnerSelector as qo, StrategyEvolutionConfig as qr, CompletionVerdict as qs, SupervisorSpanRecorder as qt, DelegateResearchConfig as qu, CreateSandboxOptions$1 as r, fanout as ra, LeaderboardRow as rc, DelegationHistoryResult as rd, SpawnForest as rf, ApplyContinuation as ri, McpServerOptions as rl, freeSlots as rn, LoopOptionsForDispatch as ro, canonicalizeAuthoredProfile as rr, PipelineStage as rs, CoordinationBinding as rt, CoderReview as ru, makeFinding$1 as s, pipeline as sa, ScoreOf as sc, DelegationStatus as sd, SpawnForestNode as sf, dumbDriver as si, DELEGATE_INPUT_SCHEMA as sl, defaultDelegateBudget as sn, RunLoopOptions as so, CheckExecChannel as sr, ScopeAnalyzeInput as ss, ResolveDriveHarness as st, DetachedWinnerSelection as su, AgentProfile$2 as t, InMemoryCorpus as ta, Leaderboard as tc, DelegationHistoryArgs as td, InMemoryResultBlobStore as tf, authorStrategy as ti, createCoordinationTools as tl, RollingDispatchOptions as tn, LoopCampaignDispatchOptions as to, assessAuthoredProfile as tr, PanelVerdict as ts, supervise as tt, eventToSnapshot as tu, SuperviseSurfaceOptions as u, widen as ua, renderLeaderboardHtml as uc, FeedbackRating as ud, materializeTreeView as uf, MaterializeLocalMcpOptions as ui, DelegateError as ul, serveCoordinationMcp as un, runLoop as uo, CheckRunner as ur, TrajectoryNode as us, SupervisorAgentDeps as ut, coderTaskFromArgs as uu, worktreeFanout as v, McpEnvironmentOptions as va, defaultAuditorInstruction as vc, DELEGATION_TRACE_MAX_SPANS as vd, DefineProfileMaterializationContractOptions as vf, OpenSandboxRunBeforeStartContext as vi, CliWorktreeSeam as vl, ProgressTracker as vn, resolveSecretEnv as vo, VisibleCheck as vr, WidenLineage as vs, supervisorAgent as vt, createSiblingSandboxExecutor as vu, composeWorkerEvidence as w, BenchmarkReport as wa, bestSoFar as wc, composeLoopTraceEmitters as wd, controlProfileMaterialization as wf, openSandboxRun as wi, cliWorktreeExecutor as wl, allWorkersStalled as wn, inProcessSandboxClient as wo, filterAuthoredAsserts as wr, Outcome as ws, legacySupervisorRunsRoot as wt, RunDetachedTurnOptions as wu, VERIFY_TAIL_CHARS as x, BenchmarkCell as xa, AnytimeTaskCurve as xc, DelegationTraceSpan as xd, ProfileMaterializationIssue as xf, SandboxRun as xi, RouterSeam as xl, StopDecision as xn, InProcessOnPrompt as xo, composeCheckSources as xr, DefinePersona as xs, settledToIteration as xt, DetachedTurnResumeDriverOptions as xu, EVIDENCE_MAX_CHARS as y, createMcpEnvironment as ya, AnytimeReport as yc, DelegationTraceCaps as yd, KnownAgentProfileMaterializationAxis as yf, OpenSandboxRunOptions as yi, ExecutorConfig as yl, ProgressTrackerOptions as yn, secretEnvOfMcpServer as yo, canDisplace as yr, WidenSpec as ys, ScopeArgs as yt, DetachedSessionRefParts as yu, TrajectoryAnalysis as z, ShotSpec as za, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as zc, RuntimeRunStateError as zd, probeSandboxCapabilities as zi, CreateWorktreeOptions as zl, CoordinationDeliveryEvidence as zn, CorpusRecord as zo, ChampionPolicy as zr, LeaderboardRunContext as zs, PatchDeliverableOptions as zt, SubmitOutput as zu };
-//# sourceMappingURL=index-CGADWaa_.d.ts.map
+export { legacySupervisorRunsRoot as $, printBenchmarkReport as $a, WaterfallReport as $c, createDelegationTraceCollector as $d, defineProfileMaterializationContract as $f, SandboxLineageHandle as $i, createExecutor as $l, DeliveredOutput as $n, harvestCorpus as $o, structuralRollout as $r, RunPersonified as $s, assertCoordinationBinding as $t, createDetachedTurnResumeDriver as $u, GitWorkspaceOptions as A, loopUntil as Aa, PairwiseVerdict as Ac, DelegationHistoryEntry as Ad, InMemorySpawnJournal as Af, SteeringDirectiveData as Ai, McpServer as Al, defaultDelegateBudget as An, loopDispatch as Ao, CheckExecChannel as Ar, RenderCorpusToInstructionsOptions as As, runGraph as At, CoderDelegate as Au, analyzeTrace as B, createScopeAnalyst as Ba, AuditIntentOptions as Bc, ResearchOutputShape as Bd, replaySpawnTree as Bf, connectStdioMcp as Bi, DelegateResult as Bl, ProgressSample as Bn, envKeyProvider as Bo, StructuralRolloutResult as Br, VerifySpec as Bs, CoordinationBinding as Bt, settleDetachedCoderTurn as Bu, closingWorkerNote as C, definePersona as Ca, AxisScoresOf as Cc, DelegateUiAuditArgs as Cd, defaultToolDetectors as Cf, assertStrategyContract as Ci, QuestionUrgency as Cl, DispatchUnit as Cn, runAgentic as Co, asAuthoredProfile as Cr, Panel as Cs, EdgeTraversal as Ct, JsonRpcResponse as Cu, UntrackedCopyStats as D, renderCorpusToInstructions as Da, LeaderboardOptions as Dc, DelegationError as Dd, FileResultBlobStore as Df, DumbDriverOptions as Di, canonicalFindingEvent as Dl, queueOf as Dn, LoopDispatchOptions as Do, defaultProfileRichnessThresholds as Dr, Pipeline as Ds, GraphResult as Dt, FeedbackStore as Du, CopyOptions as E, InMemoryCorpus as Ea, Leaderboard as Ec, DelegateUiAuditRoute as Ed, gateOnDeliverable as Ef, ApplyContinuation as Ei, WorkerWatchOptions as El, freeSlots as En, LoopCampaignDispatchOptions as Eo, canonicalizeAuthoredProfile as Er, PanelVerdict as Es, GraphNode as Et, FeedbackEvent as Eu, gitWorkspace as F, widen as Fa, renderLeaderboardHtml as Fc, DelegationStatus as Fd, SpawnForestNode as Ff, MaterializeLocalMcpOptions as Fi, DELEGATE_INPUT_SCHEMA as Fl, driverAgent as Fn, runLoop as Fo, CheckSourceCtx as Fr, TrajectoryNode as Fs, SuperviseOptions as Ft, DetachedWinnerSelection as Fu, workerTraceAnalysisStore as G, sanitizeMcpToolSchema as Ga, AnytimeStrategySummary as Gc, DELEGATION_TRACE_MAX_BYTES as Gd, CanonicalAgentProfileMaterializationAxis as Gf, OpenSandboxRunPromptOptions as Gi, CliWorktreeBridgeSeam as Gl, StopRule as Gn, inlineSandboxClient as Go, defaultExtractCandidate as Gr, WinnerStrategy as Gs, ResolveSupervisorTools as Gt, createFleetWorkspaceExecutor as Gu, WorkerToolTraceArtifact as H, McpEndpoint as Ha, auditIntent as Hc, UiAuditLensFilter as Hd, AGENT_PROFILE_MATERIALIZATION_AXES as Hf, Deliverable as Hi, validateDelegateArgs as Hl, ProgressTrackerOptions as Hn, resolveMcpServerLaunch as Ho, canDisplace as Hr, WidenDecision as Hs, DriveHarnessOwnerContext as Ht, FleetHandle as Hu, jjWorkspace as I, CreateScopeAnalystOptions as Ia, renderLeaderboardMarkdown as Ic, DelegationStatusArgs as Id, SpawnForestTree as If, McpSpawnFault as Ii, DELEGATE_TOOL_NAME as Il, finalizeBestDelivered as In, LocalSandboxClientOptions as Io, RepairStop as Ir, TrajectoryReport as Is, SuperviseRegistry as It, SettleDetachedCoderTurnOptions as Iu, ScopeArgs as J, BenchmarkLift as Ja, areaUnderCurve as Jc, DelegationTraceCollector as Jd, ProfileMaterializationContract as Jf, TurnResult as Ji, ProviderSeam as Jl, anyOf as Jn, InProcessSandboxClientOptions as Jo, modelAuthoredChecks as Jr, LoopShape as Js, SupervisorNodeContext as Jt, DetachedTurn as Ju, createRootHandle as K, BenchmarkCell as Ka, AnytimeTaskCurve as Kc, DELEGATION_TRACE_MAX_SPANS as Kd, DefineProfileMaterializationContractOptions as Kf, SandboxRun as Ki, CliWorktreeSeam as Kl, allOf as Kn, InProcessOnPrompt as Ko, defaultStructuralRolloutPolicy as Kr, DefinePersona as Ks, ResolvedSupervisorProfile as Kt, createSiblingSandboxExecutor as Ku, localShell as L, RegistryAnalyzeProjection as La, renderLeaderboardSvg as Lc, DelegationStatusResult as Ld, loadSpawnForest as Lf, McpToolDescriptor as Li, DelegateArgs as Ll, AllWorkersStalledOptions as Ln, localSandboxClient as Lo, StructuralRolloutConfig as Lr, TrajectoryReportFn as Ls, SuperviseRegistryTable as Lt, UiAuditorDelegate as Lu, Workspace as M, pipeline as Ma, ScoreOf as Mc, DelegationProfile as Md, SpawnForestEvent as Mf, naiveDriver as Mi, createInProcessTransport as Ml, CoordinationMcpHandle as Mn, RunLoopOptions as Mo, CheckRunContext as Mr, ScopeAnalyzeInput as Ms, AuthorizedSpawnContext as Mt, CoderReviewer as Mu, WorkspaceCommit as N, selectValidWinner as Na, leaderboard as Nc, DelegationProgress as Nd, SpawnForestInDoubtNode as Nf, steeringDriver as Ni, createMcpServer as Nl, serveCoordinationMcp as Nn, defaultSelectWinner as No, CheckRunner as Nr, ScopeWidenGate as Ns, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as Nt, DelegateRunCtx as Nu, copyUntrackedIntoClone as O, fanout as Oa, LeaderboardRow as Oc, DelegationFeedbackSnapshot as Od, FileSpawnJournal as Of, NaiveDriverOptions as Oi, createCoordinationTools as Ol, rollingDispatch as On, LoopOptionsForDispatch as Oo, profileRichnessFinding as Or, PipelineStage as Os, RunGraphOptions as Ot, InMemoryFeedbackStore as Ou, WorkspaceRun as P, verify as Pa, pairwiseSignificance as Pc, DelegationResultPayload as Pd, SpawnForestMissingTree as Pf, LocalMcpMaterialization as Pi, DELEGATE_DESCRIPTION as Pl, DriverAgentOptions as Pn, runAgentRounds as Po, CheckSource as Pr, SteerContext as Ps, DeliverableResolutionInput as Pt, DetachedSessionDelegateOptions as Pu, legacySupervisorRunDir as Q, Environment as Qa, WaterfallCollector as Qc, composeLoopTraceEmitters as Qd, controlProfileMaterialization as Qf, SandboxLineage as Qi, cliWorktreeExecutor as Ql, sampleFromSettled as Qn, HarvestReport as Qo, selectBestIndex as Qr, PersonaExecutors as Qs, SupervisorToolInvocationContext as Qt, RunDetachedTurnOptions as Qu, runInWorkspace as R, assertTraceDerivedFindings as Ra, renderPairwiseMarkdown as Rc, FeedbackRating as Rd, materializeTreeView as Rf, StdioMcpConnection as Ri, DelegateError as Rl, NoProgressForOptions as Rn, KeyProvider as Ro, StructuralRolloutMessage as Rr, TrajectoryReportOptions as Rs, supervise as Rt, coderTaskFromArgs as Ru, WorkerEvidenceInput as S, registerShape as Sa, stopSentinel as Sc, DelegateResearchResult as Sd, WatchTraceOptions as Sf, AuthoredStrategy as Si, QuestionRecord as Sl, DispatchStopReason as Sn, refine as So, ProfileRichnessThresholds as Sr, LoopUntilState as Ss, EdgeDeliveryOutcome as St, JsonRpcMessage as Su, settledWorkerOut as T, FileCorpus as Ta, Interval as Tc, DelegateUiAuditResult as Td, DeliverableSpec as Tf, strategyAuthorContract as Ti, WorkerSpawnContext as Tl, effectiveConcurrency as Tn, sampleThenRefine as To, authoredWorker as Tr, PanelSpec as Ts, GraphEdgeCapError as Tt, McpTransport as Tu, captureWorkerTraceEvidence as U, McpEnvironmentOptions as Ua, defaultAuditorInstruction as Uc, UiAuditorDelegationOutput as Ud, AgentProfileMaterializationAxis as Uf, OpenSandboxRunBeforeStartContext as Ui, BridgeSeam as Ul, ProgressView as Un, resolveSecretEnv as Uo, compareCheckOutcomes as Ur, WidenLineage as Us, ObserveSupervisorNodeEvent as Ut, FleetWorkspaceExecutorOptions as Uu, WORKER_TOOL_TRACE_SCHEMA_VERSION as V, registryScopeAnalyst as Va, IntentAudit as Vc, ResearchSource as Vd, contentAddress as Vf, materializeLocalMcp as Vi, createDelegateHandler as Vl, ProgressTracker as Vn, mcpSecretEnvMetadataKey as Vo, VisibleCheck as Vr, Widen as Vs, DriveHarness as Vt, DelegationExecutor as Vu, parseWorkerToolTraceArtifact as W, createMcpEnvironment as Wa, AnytimeReport as Wc, CappedDelegationTrace as Wd, AssertProfileMaterializationOptions as Wf, OpenSandboxRunOptions as Wi, CliSeam as Wl, StopDecision as Wn, secretEnvOfMcpServer as Wo, composeCheckSources as Wr, WidenSpec as Ws, ResolveDriveHarness as Wt, SiblingSandboxExecutorOptions as Wu, settledToIteration as X, BenchmarkStrategySummary as Xa, plateauLength as Xc, buildDelegationTraceSpans as Xd, ValidateProfileMaterializationOptions as Xf, CheckpointCapableBox as Xi, RouterToolsSeam as Xl, noProgressFor as Xn, HarvestCorpusOptions as Xo, resolveEntrySymbol as Xr, Persona as Xs, SupervisorProfile as Xt, DriveTurnCapableBox as Xu, createScope as Y, BenchmarkReport as Ya, bestSoFar as Yc, DelegationTraceSpan as Yd, ProfileMaterializationIssue as Yf, openSandboxRun as Yi, RouterSeam as Yl, createProgressTracker as Yn, inProcessSandboxClient as Yo, officialChecksFromMeta as Yr, Outcome as Ys, SupervisorNodeContextSeed as Yt, DetachedTurnResumeDriverOptions as Yu, WorkerSteerRequest as Z, BenchmarkTaskRow as Za, renderAnytimeTable as Zc, capDelegationTrace as Zd, assertProfileMaterialization as Zf, ForkCapableBox as Zi, SandboxSeam as Zl, plateau as Zn, HarvestFailure as Zo, sandboxCheckRunner as Zr, PersonaContext as Zs, SupervisorToolDescriptor as Zt, DriveTurnTick as Zu, WorktreeFanoutOptions as _, promotionGate as _a, CompletionPolicy as _c, DelegateCodeResult as _d, BusRecord as _f, discriminatingMeans as _i, Question as _l, naiveContinuationPrompt as _n, SurfaceScore as _o, ReservationTicket as _r, FanoutSynthesis as _s, WorktreePatchArtifact as _t, RemoveWorktreeOptions as _u, SandboxInstance$1 as a, mapSandboxEvent as aa, LeaderboardBenchScore as ac, DelegationRecord as ad, InMemoryDelegationStore as af, collectAgentTurn as ai, AuthorizeDownMessage as al, SupervisorSpanRecorder as an, AgenticTool as ao, promptResourceProfileMaterialization as ap, pickBestDelivered as ar, renderReport as as, workerControlLogFile as at, createSteerableSandboxSession as au, NOTE_MAX_CHARS as b, builtinShapes as ba, deterministicCompletion as bc, DelegateResearchArgs as bd, PublishOptions as bf, selectChampion as bi, QuestionOption as bl, ConcurrencyCaps as bn, defineStrategy as bo, AuthoredProfile as br, LoopUntil as bs, assertProfileModelsAllowed as bt, createWorktree as bu, VerifierEnvironmentOptions as c, CriuCapableClient as ca, LeaderboardFlagSpec as cc, DelegationResumeTick as cd, BackendTransportError as cf, ChampionPolicy as ci, CoordinationEvent as cl, PromptRegistry as cn, RunAgenticOptions as co, validateProfileMaterialization as cp, CoordinationDeliveryEvidence as cr, Corpus as cs, writeWorkerSteer as ct, createInbox as cu, SuperviseSurfaceResult as d, AcquireOptions as da, LeaderboardScenario as dc, DelegationTaskQueueOptions as dd, NotFoundError as df, EvolutionBandInfo as di, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as dl, createPromptRegistry as dn, Strategy as do, FileCoordinationLog as dr, EqualKArm as ds, RunContext as dt, WorktreeHarnessResult as du, SessionCapableBox as ea, RunPersonifiedOptions as ec, detachedTurnEvents as ed, DelegationPersistenceError as ef, visibleCheckScore as ei, WaterfallSpan as el, resolveSupervisorProfile as en, runBenchmark as eo, fullProfileMaterialization as ep, FinalizeContext as er, Observation as es, readWorkerSteerRequests as et, createExecutorRegistry as eu, SurfaceWorkerConfig as f, acquireSandbox as fa, LeaderboardScore as fc, SubmitInput as fd, PlannerError as ff, EvolutionCandidate as fi, DownMessageAuthorizationInput as fl, delegatesWorkerBriefPrompt as fn, StrategyArtifacts as fo, PriorCoordination as fr, EqualKOnCost as fs, createFileRunContext as ft, WorktreeProfileMaterializationReceipt as fu, AuthoredHarness as g, PromotionVerdict as ga, CompletionEvidence as gc, DelegateCodeConfig as gd, BusEvent as gf, StrategyEvolutionConfig as gi, MakeWorkerAgent as gl, kernelPromptRegistry as gn, StrategyShotResult as go, ReservationRejection as gr, FanoutOptions as gs, WorktreeCliExecutorOptions as gt, GitRunner as gu, superviseSurface as h, PromotionGateOptions as ha, CompletionAnalyst as hc, DelegateCodeArgs as hd, CoderOutput as hf, ReproductionCheck as hi, DownMessageEvent as hl, formatPromptHandle as hn, StrategyResult as ho, BudgetReadout as hr, Fanout as hs, patchDelivered as ht, DiffResult as hu, SandboxEvent$1 as i, extractLlmCallEvent as ia, DefinedLeaderboard as ic, DelegationArgs as id, FileDelegationStoreOptions as if, StreamAgentTurnOptions as ii, AnalyzeOnSettleRoute as il, SupervisorSpanOutcome as in, AgenticTask as io, promptOnlyProfileMaterialization as ip, collectDelivered as ir, observe as is, supervisorWorkersDir as it, SteerableSandboxSession as iu, Shell as j, panel as ja, ProfileKeyOf as jc, DelegationHistoryResult as jd, SpawnForest as jf, dumbDriver as ji, McpServerOptions as jl, delegate as jn, RunAgentRoundsOptions as jo, CheckOutcome as jr, ScopeAnalyst as js, AuthorizedSpawn as jt, CoderReview as ju, withUntrackedArtifacts as k, flatWidenGate as ka, PairwiseOptions as kc, DelegationHistoryArgs as kd, InMemoryResultBlobStore as kf, SteeringDecision as ki, normalizeAnalyzeOnSettle as kl, DelegateOptions as kn, loopCampaignDispatch as ko, supervisorInstructions as kr, RenderCorpusToInstructions as ks, defaultEdgeTraversalCap as kt, eventToSnapshot as ku, createVerifierEnvironment as l, SandboxCapabilities as la, LeaderboardIterationInfo as lc, DelegationRunContext as ld, ConfigError as lf, EvolutionArchiveNode as li, CoordinationTools as ll, RegisteredPrompt as ln, ShotPersona as lo, worktreeCliProfileMaterialization as lp, CoordinationLog as lr, CorpusFilter as ls, InMemoryRunContext as lt, WorktreeCheckRunner as lu, failuresAnalyst as m, resolveSandboxClient as ma, defineLeaderboard as mc, hashIdempotencyInput as md, ValidationError as mf, EvolutionReport as mi, DownMessageDeliveryOutcome as ml, dumbContinuationPassPrompt as mn, StrategyMessage as mo, BudgetPoolRestore as mr, EqualKVerdict as ms, PatchDeliverableOptions as mt, DiffOptions as mu, AnalystFinding$1 as n, SandboxToolPartState as na, ShapeContext as nc, parseDetachedSessionRef as nd, DelegationStore as nf, AgentTurnUsage as ni, AnalystFindingEvent as nl, SupervisorSpanAttributes as nn, AgenticRunResult as no, promptControlProfileMaterialization as np, SupervisorFinalizer as nr, ObserveOptions as ns, supervisorRunDir as nt, SandboxSteeringOptions as nu, computeFindingId$1 as o, mapSandboxToolEvent as oa, LeaderboardBenchTask as oc, DelegationResumeContext as od, AgentEvalError$1 as of, streamAgentTurn as oi, AuthorizedDownMessage as ol, createSupervisorSpanRecorder as on, ArtifactHandle as oo, renderProfileMaterializationIssues as op, runFinalizer as or, AssertTraceDerivedFindings as os, workerInboxFile as ot, Inbox as ou, SurfaceWorkerOut as p, ResolveSandboxClientOptions as pa, LeaderboardSpec as pc, SubmitOutput as pd, RuntimeRunStateError as pf, EvolutionGeneration as pi, DownMessageDeliveryAttempt as pl, dumbContinuationFailPrompt as pn, StrategyCtx as po, BudgetPool as pr, EqualKOnCostOptions as ps, createInMemoryRunContext as pt, CreateWorktreeOptions as pu, createSupervisor as q, BenchmarkConfig as qa, anytimeReport as qc, DelegationTraceCaps as qd, KnownAgentProfileMaterializationAxis as qf, SandboxRunAbortError as qi, ExecutorConfig as ql, allWorkersStalled as qn, InProcessPromptCtx as qo, filterAuthoredAsserts as qr, DefinePersonaInput as qs, SupervisorAgentDeps as qt, DetachedSessionRefParts as qu, CreateSandboxOptions$1 as r, createSandboxToolPartState as ra, ShapeRegistry as rc, runDetachedTurn as rd, FileDelegationStore as rf, CollectedAgentTurn as ri, AnalystRegistry as rl, SupervisorSpanOptions as rn, AgenticSurface as ro, promptModelProfileMaterialization as rp, bestDelivered as rr, defaultAnalystInstruction as rs, supervisorRunsRoot as rt, SteerableSandboxArgs as ru, makeFinding$1 as s, sumSandboxUsage as sa, LeaderboardBenchmarkAdapter as sc, DelegationResumeDriver as sd, AgentEvalErrorCode as sf, ChampionPick as si, ContinuationInstruction as sl, PromptHandle as sn, CorpusReadbackOptions as so, sandboxActProfileMaterialization as sp, runTree as sr, CombinatorShape as ss, workerInboxFileFromEventDir as st, InboxMessage as su, AgentProfile$2 as t, createSandboxLineage as ta, ShapeBudget as tc, formatDetachedSessionRef as td, DelegationStateCorruptError as tf, AgentTurnBackend as ti, createWaterfallCollector as tl, supervisorAgent as tn, AgenticOptions as to, profileMaterializationAxes as tp, FinalizerSettled as tr, ObserveInput as ts, safeWorkerFile as tt, DEFAULT_SANDBOX_STEERING_MAX_TURNS as tu, SuperviseSurfaceOptions as u, probeSandboxCapabilities as ua, LeaderboardRunContext as uc, DelegationTaskQueue as ud, JudgeError as uf, EvolutionAuthor as ui, CoordinationToolsOptions as ul, analyzesFindingsReportPrompt as un, ShotSpec as uo, CoordinationOwnerId as ur, CorpusRecord as us, InMemoryRunContextOptions as ut, WorktreeCommandResult as uu, worktreeFanout as v, equalKOnCost as va, CompletionVerdict as vc, DelegateFeedbackArgs as vd, BusStats as vf, pickChampion as vi, QuestionDecision as vl, promptHandle as vn, adaptiveRefine as vo, createBudgetPool as vr, FanoutWinnerSelector as vs, createWorktreeCliExecutor as vt, WorktreeHandle as vu, composeWorkerEvidence as w, runPersonified as wa, GroupOf as wc, DelegateUiAuditConfig as wd, watchTrace as wf, authorStrategy as wi, SettledWorker as wl, RollingDispatchOptions as wn, sample as wo, assessAuthoredProfile as wr, PanelJudge as ws, GraphEdge as wt, McpToolDescriptor$1 as wu, VERIFY_TAIL_CHARS as x, createShapeRegistry as xa, sentinelCompletion as xc, DelegateResearchConfig as xd, createEventBus as xf, AuthorStrategyOptions as xi, QuestionPolicy as xl, DispatchReport as xn, depthStrategy as xo, ProfileRichness as xr, LoopUntilSpec as xs, AgentGraph as xt, removeWorktree as xu, EVIDENCE_MAX_CHARS as y, trajectoryReport as ya, completionAuthorizes as yc, DelegateFeedbackResult as yd, EventBus as yf, runStrategyEvolution as yi, QuestionLevel as yl, supervisorPolicyPrompt as yn, breadthStrategy as yo, spendFromUsageEvents as yr, FlatWidenGate as ys, assertModelAllowed as yt, captureWorktreeDiff as yu, TrajectoryAnalysis as z, buildSteerContext as za, AuditIntentInput as zc, FeedbackRefersTo as zd, pendingWaits as zf, StdioMcpServerSpec as zi, DelegateHandlerOptions as zl, PlateauOptions as zn, ResolvedMcpServerLaunch as zo, StructuralRolloutPolicy as zr, Verify as zs, workerFromBackend as zt, detachedSessionDelegate as zu };
+//# sourceMappingURL=index-CyXinqJw.d.ts.map