@tangle-network/agent-runtime 0.116.0 → 0.119.0

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

@@ -2,16 +2,148 @@ 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 Executor, Ct as TraceContext, En as ExecutorProgress, Ft as OtelExporter, H as ExecutorFactory, I as Agent, L as AgentSpec, On as WorkerProgress, Pt as OtelExportConfig, Q as ResumedKeyState, R as Budget, U as ExecutorRegistry, Z as ResultBlobStore, at as SpawnEvent, dt as SupervisedResult, et as RootHandle, ft as Supervisor, ht as UsageEvent, i as AgentEnvironmentProvider, in as PendingWait, it as Settled, mt as TreeView, nt as Runtime, o as AgentEnvironmentProviderRegistry, ot as SpawnJournal, q as NodeId, rt as Scope, sn as WaitProbeRegistry, st as SpawnOpts, ut as Spend, vt as WorkerTraceResolver, w as ProviderExecutorOptions, yn as TraceSource, z as DefaultVerdict } from "./environment-provider-CWsRh6Uz.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 { o as UiLens, r as UiFinding, s as CoderTask } from "./substrate-BcnuSHXm.js";
-import { S as ToolLoopCompactionOptions, b as ToolLoopChat, c as runLocalHarness, d as RouterConfig, i as LocalHarness, m as ToolSpec, n as CodexExecutionPolicy, r as CodexTokenUsage } from "./local-harness-t6cDWDQ2.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, ValidationError, buildTrajectory, computeFindingId as computeFindingId$1, makeFinding as makeFinding$1 } from "@tangle-network/agent-eval";
+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";
 import { DispatchFn, JudgeConfig, ProfileDispatchFn, RunProfileMatrixOptions, RunProfileMatrixResult, Scenario } from "@tangle-network/agent-eval/campaign";
-import { AgentProfile as AgentProfile$1, AgentProfile as AgentProfile$2, AgentProfile as AgentProfile$3, AgentProfileMcpServer, AgentProfileModelHints, AgentProfilePrompt, AgentProfileResources, AgentProfileSecurityPolicy } from "@tangle-network/agent-interface";
+import { AGENT_PROFILE_MATERIALIZATION_AXES, AgentProfile as AgentProfile$1, AgentProfile as AgentProfile$2, AgentProfile as AgentProfile$3, AgentProfileMcpServer, AgentProfileModelHints, AgentProfilePrompt, AgentProfileResources, AgentProfileSecurityPolicy, CanonicalAgentProfileMaterializationAxis, Sha256Digest, profileMaterializationAxes } from "@tangle-network/agent-interface";
 import { WorkspacePlanReceipt } from "@tangle-network/agent-profile-materialize";
 import { BackendType, CreateSandboxOptions, CreateSandboxOptions as CreateSandboxOptions$1, PromptOptions, SandboxEvent, SandboxEvent as SandboxEvent$1, SandboxInstance, SandboxInstance as SandboxInstance$1 } from "@tangle-network/sandbox";
 import { stuckLoopView, toolWasteView } from "@tangle-network/agent-eval/pipelines";
+//#region src/agent/profile-materialization.d.ts
+type KnownAgentProfileMaterializationAxis = CanonicalAgentProfileMaterializationAxis;
+/** AgentProfile axis name, with `custom:<name>` reserved for caller-owned extensions. */
+type AgentProfileMaterializationAxis = KnownAgentProfileMaterializationAxis | `custom:${string}`;
+/** Declares which AgentProfile axes a concrete run path really carries. */
+interface ProfileMaterializationContract {
+  /** Human-readable run path, e.g. `createSandboxAct` or `prompt-only-message`. */
+  name: string;
+  /** Profile axes this run path actually carries into execution. */
+  axes: readonly AgentProfileMaterializationAxis[];
+}
+/** One changed AgentProfile axis that would be dropped by a run path. */
+interface ProfileMaterializationIssue {
+  contract: string;
+  axis: AgentProfileMaterializationAxis;
+  reason: 'unsupported-axis';
+  supportedAxes: readonly AgentProfileMaterializationAxis[];
+}
+/** Input for declaring a run path's profile-axis support. */
+interface DefineProfileMaterializationContractOptions {
+  name: string;
+  axes: readonly AgentProfileMaterializationAxis[];
+}
+/** Input for checking a candidate diff against a run path. */
+interface ValidateProfileMaterializationOptions {
+  contract: ProfileMaterializationContract;
+  changedAxes: readonly AgentProfileMaterializationAxis[];
+}
+/** Input for throwing on dropped profile axes. */
+interface AssertProfileMaterializationOptions extends ValidateProfileMaterializationOptions {
+  /** Extra label included in the thrown error, usually the caller or run id. */
+  context?: string;
+}
+/** Materialization contract for a run path that executes every canonical AgentProfile leaf. */
+declare const fullProfileMaterialization: ProfileMaterializationContract;
+/**
+ * Materialization contract for an intentionally limited prompt-and-model execution path.
+ * Identity, harness, and metadata are control fields consumed for naming, placement,
+ * authorization, and durable attribution; they are carried without adding worker behavior.
+ * Every behavioral axis other than prompt and model remains unsupported.
+ */
+declare const promptModelProfileMaterialization: ProfileMaterializationContract;
+/**
+ * Materialization contract for a local coding CLI in an isolated git worktree.
+ * The shared workspace materializer carries native tools, permissions, MCP, hooks, subagents,
+ * modes, and file-backed resources when the selected CLI supports their exact values.
+ * `resourceFailOnError` is carried: it is the fail-closed policy the pre-worktree resource
+ * RESOLUTION step (`resolveAgentProfileResources`) applies to remote profile resources. Runtime
+ * placement concerns (hub connections and confidential execution), provider-native extensions,
+ * and unused model hints are deliberately absent so they fail before a worktree or executor is
+ * created rather than being mistaken for an effective candidate change.
+ */
+declare const worktreeCliProfileMaterialization: ProfileMaterializationContract;
+/** Materialization contract for a raw process path that carries only control/identity fields. */
+declare const controlProfileMaterialization: ProfileMaterializationContract;
+/** Materialization contract for an injected inference function whose surrounding driver still
+ * applies the profile prompt, name, placement, and metadata, but not model selection. */
+declare const promptControlProfileMaterialization: ProfileMaterializationContract;
+/**
+ * Materialization contract for `createSandboxAct`.
+ *
+ * `createSandboxAct` hands the whole `AgentProfile` to the sandbox as `backend.profile`, so every
+ * profile leaf crosses the boundary. `buildBackendOptions` resolves the runner from an explicit
+ * `sandboxOverrides.backend.type`, then `profile.metadata.backendType`, then `profile.harness`,
+ * so a candidate that changes only `harness` runs on the harness it declares — and one declaring
+ * a harness the sandbox cannot run throws rather than running elsewhere and reporting success.
+ */
+declare const sandboxActProfileMaterialization: ProfileMaterializationContract;
+/** Materialization contract for a run path that only injects prompt text. */
+declare const promptOnlyProfileMaterialization: ProfileMaterializationContract;
+/**
+ * Materialization contract for a run path that injects prompt text plus inline resources.
+ *
+ * `resourceFailOnError` is absent: it is a resolution POLICY the attaching path would have to
+ * enforce, and inlining resource content does not carry it.
+ */
+declare const promptResourceProfileMaterialization: ProfileMaterializationContract;
+/** Define the profile axes a concrete run path actually carries into execution. */
+declare function defineProfileMaterializationContract(options: DefineProfileMaterializationContractOptions): ProfileMaterializationContract;
+/** Return every changed profile axis that the selected run path would drop. */
+declare function validateProfileMaterialization(options: ValidateProfileMaterializationOptions): readonly ProfileMaterializationIssue[];
+/** Throw when a candidate changes axes the selected run path cannot carry. */
+declare function assertProfileMaterialization(options: AssertProfileMaterializationOptions): void;
+/** Format profile-axis drop issues into a concise operator-facing error. */
+declare function renderProfileMaterializationIssues(issues: readonly ProfileMaterializationIssue[], context?: string): string;
+//#endregion
+//#region src/durable/content-address.d.ts
+/** Stable content address shared by result and trace artifacts. */
+declare function contentAddress(artifact: unknown): string;
+//#endregion
 //#region src/durable/spawn-journal.d.ts
+/** One journal tree in a recursively loaded supervision forest. */
+interface SpawnForestTree {
+  readonly root: NodeId;
+  /** Driver node that owns this tree; absent for the requested root tree. */
+  readonly ownerNodeId?: NodeId;
+  /** Journal tree containing `ownerNodeId`; absent for the requested root tree. */
+  readonly parentTreeRoot?: NodeId;
+  readonly events: ReadonlyArray<SpawnEvent>;
+  readonly view: TreeView;
+}
+/** One event with the journal tree that establishes its cursor namespace. */
+interface SpawnForestEvent {
+  readonly treeRoot: NodeId;
+  readonly event: SpawnEvent;
+}
+/** One flattened node with the journal tree that owns its records. */
+interface SpawnForestNode extends NodeSnapshot {
+  readonly treeRoot: NodeId;
+}
+/** A spawned worker with no terminal record in a cold snapshot. Resume treats the same state as
+ * in-doubt and conservatively retains its reservation. Root nodes and armed waits are excluded. */
+interface SpawnForestInDoubtNode {
+  readonly treeRoot: NodeId;
+  readonly nodeId: NodeId;
+  readonly label: string;
+  readonly runtime: Runtime;
+}
+/** A driver spawn whose owned journal tree was never begun before the process stopped. */
+interface SpawnForestMissingTree {
+  readonly parentTreeRoot: NodeId;
+  readonly ownerNodeId: NodeId;
+  readonly root: NodeId;
+}
+/** Complete cold-readable view of one recursive supervision run. */
+interface SpawnForest {
+  readonly root: NodeId;
+  readonly trees: ReadonlyArray<SpawnForestTree>;
+  readonly nodes: ReadonlyArray<SpawnForestNode>;
+  readonly events: ReadonlyArray<SpawnForestEvent>;
+  readonly inDoubt: ReadonlyArray<SpawnForestInDoubtNode>;
+  readonly missingTrees: ReadonlyArray<SpawnForestMissingTree>;
+}
 /**
  * Mint the content-addressed `outRef` for a result artifact: `sha256:<hex>` over a
  * stable JSON encoding. Producers call this to derive the `outRef` they journal and
@@ -21,7 +153,6 @@ import { stuckLoopView, toolWasteView } from "@tangle-network/agent-eval/pipelin
  * Stable encoding: object keys are sorted recursively so two structurally-equal
  * artifacts hash identically regardless of key insertion order.
  */
-declare function contentAddress(artifact: unknown): string;
 /**
  * In-memory `ResultBlobStore`. Content-addressed: `put` verifies the supplied
  * `outRef` matches the artifact's hash so a stale/forged ref fails loud rather than
@@ -66,13 +197,33 @@ declare class InMemorySpawnJournal implements SpawnJournal {
  */
 declare class FileSpawnJournal implements SpawnJournal {
   private readonly path;
+  private appendTail;
   constructor(path: string);
   loadTree(root: NodeId): Promise<SpawnEvent[] | undefined>;
   beginTree(root: NodeId, at: string): Promise<void>;
   appendEvent(root: NodeId, ev: SpawnEvent): Promise<void>;
   private loadTreeBegin;
   private appendRecord;
+  private writeRecord;
 }
+/**
+ * Load every journal tree owned by one recursive supervision run and flatten its nodes/events.
+ *
+ * Nested driver tree keys are a Runtime implementation detail; callers should use this reader
+ * instead of deriving or scanning keys themselves. The reader follows only the explicit
+ * `ownedTreeRoot` written after Runtime privately attested a recursive executor; the open runtime
+ * string `driver` is never treated as ownership. Legacy records without `ownedTreeRoot` are
+ * intentionally treated as leaves rather than guessing or scanning convention-derived keys.
+ * This preserves each tree's independent cursor namespace on flattened events.
+ * A driver whose subtree was never begun is reported in `missingTrees`; any spawned non-root node
+ * without a terminal record is reported in `inDoubt`, matching resume's conservative lost-work
+ * interpretation.
+ *
+ * This is a cold/quiescent reader, not a transaction across an actively mutating file. Every value
+ * returned is a detached immutable snapshot, so later journal writes or caller mutation cannot
+ * change the result already observed.
+ */
+declare function loadSpawnForest(journal: SpawnJournal, root: NodeId): Promise<SpawnForest>;
 /**
  * Re-feed a journaled spawn tree in strict `seq` order, rehydrating each settled
  * child's `out` from the blob store by `outRef`, and return the `Settled[]` exactly
@@ -155,8 +306,8 @@ declare function watchTrace(source: TraceSource, opts?: WatchTraceOptions): () =
  *     queued settles/findings so the driver sees it first; ties resolve FIFO by publish order.
  *
  * Observability is first-class (A++): every event is stamped with a monotonic `seq` and wall-clock
- * `at`, the full ordered `history()` is retained as an audit/replay trail, and `stats()` exposes
- * published/pulled counts by kind. Subscribers receive the stamped record, not a bare event.
+ * `at`, the full ordered `history()` is retained as current-process audit evidence, and `stats()`
+ * exposes published/pulled counts by kind. Subscribers receive the stamped record, not a bare event.
  *
  * The interface is transport-agnostic on purpose. Same box → this in-process queue. Cross box →
  * the SAME publish/pull/subscribe surface backed by a durable mailbox on the parent's box (children
@@ -193,8 +344,9 @@ interface BusStats {
   readonly byKind: Readonly<Record<string, number>>;
 }
 interface EventBus<E extends BusEvent> {
-  /** Stamp + queue the event, then deliver the stamped record to every subscriber in order.
-   *  Returns the stamped record. */
+  /** Stamp the event, await every subscriber in order, then make it pull-visible. A subscriber
+   *  failure leaves the event invisible and retrying the SAME event object reuses the exact stamp.
+   *  This lets an awaited product observer commit its record before a supervisor can consume it. */
   publish(event: E, opts?: PublishOptions): Promise<BusRecord<E>>;
   /** Remove and return the highest-priority QUEUED event whose type is in `kinds` (any if omitted),
    *  ties broken FIFO by `seq`; `undefined` when nothing matches. */
@@ -204,7 +356,7 @@ interface EventBus<E extends BusEvent> {
   subscribe(handler: (record: BusRecord<E>) => void | Promise<void>): () => void;
   /** Count of queued, not-yet-pulled events (filtered by `kinds` when given). */
   pending(kinds?: ReadonlyArray<E['type']>): number;
-  /** The full ordered log of every event ever published (the audit/replay trail). */
+  /** The full ordered log of every event published in this process (audit evidence, not replay). */
   history(): ReadonlyArray<BusRecord<E>>;
   /** Throughput counters for observability dashboards. */
   stats(): BusStats;
@@ -1734,164 +1886,6 @@ type WorktreeCheckRunner = (opts: {
   output: string;
 }>;
 //#endregion
-//#region src/runtime/supervise/pi-mcp.d.ts
-/** The pi extension that gives pi MCP at all. Everything here is gated on it being loadable. */
-declare const PI_MCP_ADAPTER = "pi-mcp-adapter";
-/** Overrides adapter detection for installs whose path does not carry the adapter's name. */
-declare const PI_MCP_ADAPTER_ENV = "AGENT_RUNTIME_PI_MCP_ADAPTER";
-/** The adapter-registered flag that names this run's config file (`pi-mcp-adapter` `index.ts:252`). */
-declare const PI_MCP_CONFIG_FLAG = "--mcp-config";
-/** What the caller must call once pi has exited, and where the config landed. */
-interface PiMcpMount {
-  /** Absolute path of the file passed to `--mcp-config`. Unique to this worker execution. */
-  configPath: string;
-  /** Server names actually written, post-filter — never the raw `profile.mcp` keys. */
-  serverNames: string[];
-  /** Remove the private config directory. Idempotent; safe to call on any exit path. */
-  cleanup(): void;
-}
-/**
- * What pi was actually given, as opposed to what the profile declared. This is the observable that
- * makes rule 2 above honest: `adapterInjected` is `true` exactly when this module added an extension
- * the caller did not ask for, because without it the MCP servers the caller DID ask for could not
- * have mounted.
- */
-interface PiMcpReceipt {
-  /** Server names written into `configPath`, in declaration order. */
-  servers: string[];
-  /** Absolute path of the mounted config. */
-  configPath: string;
-  /** `extensions.pi.load` entries as pi received them, resolved to absolute entry files. */
-  extensions: string[];
-  /** True when `pi-mcp-adapter` was absent from an explicit `load` array and was added here. */
-  adapterInjected: boolean;
-}
-/** Everything `piExecutor` needs between "profile in hand" and "pi spawned". */
-interface PiMcpPreparation {
-  /** Extra argv for `pi`, in flag order: extension flags first, then `--mcp-config <path>`. */
-  args: string[];
-  /** Present only when at least one usable MCP server was declared. */
-  mount: PiMcpMount | null;
-  /** Present only when a mount happened — the derived-versus-declared record. */
-  receipt: PiMcpReceipt | undefined;
-}
-/**
- * True when pi can actually consume MCP config — i.e. `pi-mcp-adapter` is installed. Ported from
- * cli-bridge `pi.ts:189`: an env override first (for vendored installs whose path does not carry the
- * adapter's name), then the npm install directory, then a scan of `settings.json` `packages` in
- * which a local-path entry is resolved by reading the target's `package.json` `name`. An
- * unreadable or absent `settings.json` reports "not detected"; it never throws and never assumes.
- */
-declare function piMcpAdapterAvailable(): boolean;
-/**
- * Build the canonical `{ mcpServers }` body the adapter reads, from `AgentProfile.mcp`.
- *
- * Every server is written with `directTools: true` (`pi-mcp-adapter` types.ts:351), which
- * registers its tools as NATIVE pi tools instead of hiding them behind the generic `mcp` tool.
- * Without it an agent must discover its own verbs before it can use them — connect to the server,
- * then describe each tool — and a measured run spent 58 turns and 639,632 input tokens doing that
- * before it could delegate once. A profile that declares an MCP server is asking for its tools,
- * not for a directory it has to browse.
- *
- * This is cli-bridge's `buildCanonicalMcpServers`
- * (`/home/drew/code/cli-bridge/src/backends/profile-support.ts:253`) reproduced field for field and
- * in the same key order — same drop of `enabled:false`, same stdio-versus-remote decision
- * (`isStdioMcpSpec`, `profile-support.ts:177`), same `{command, args, env}` and `{type, url,
- * headers}` bodies, same silent drop of an entry with nothing to connect to. For any server both
- * input types can express, the emitted JSON is byte-identical.
- *
- * The two input types are not the same type, so three differences remain and each is a field one
- * side cannot express:
- *
- * 1. **`cwd` (emitted here, absent there).** `AgentProfileLocalMcpServer` has `cwd`; cli-bridge's
- *    `McpServerSpec` (`src/backends/types.ts:53`) has no such field, so it can never emit one. The
- *    adapter honors it (`pi-mcp-adapter` `types.ts:325`, `ServerEntry.cwd`), so dropping it would
- *    silently discard a declared setting. It is emitted where cli-bridge emits `timeout`.
- * 2. **`timeout` (emitted there, absent here).** `AgentProfileMcpServer` has no timeout field, so
- *    there is nothing to emit. (The adapter's own knob is `requestTimeoutMs`, not `timeout`.)
- * 3. **A `url` with no declared transport.** cli-bridge DROPS it — its remote branch requires an
- *    explicit `spec.type` — even though its own `McpServerSpec` docstring says "http is implied if
- *    `url` is set" (`types.ts:53-56`). `transport` is optional on `AgentProfileRemoteMcpServer`, so
- *    dropping such a server here would be exactly the silent-drop bug this module exists to fix.
- *    We honor the documented convention and emit `type: 'http'`.
- *
- * `sse` is ACCEPTED and forwarded verbatim, as cli-bridge forwards it. The adapter connects a URL
- * server by probing StreamableHTTP and falling back to `SSEClientTransport` when the probe fails
- * (`pi-mcp-adapter` `server-manager.ts:765`), so an SSE-only endpoint does connect. Its
- * `ServerEntry` (`types.ts:319`) carries no transport discriminator at all, which means the `type`
- * key is inert to the adapter either way — but it is what cli-bridge writes, and a config file that
- * round-trips the caller's declared transport is the one that stays readable by both.
- */
-declare function buildPiMcpServers(mcp: Record<string, AgentProfileMcpServer> | undefined): Record<string, Record<string, unknown>>;
-/** Where one worker execution's private config directory is created, and what it is called. */
-interface PiMcpMountOptions {
-  /**
-   * The worker's own working directory (`PiSeam.cwd`). Omit when the seam names none: the config
-   * then lands in the OS temp directory. It is NEVER written into `process.cwd()` — the operator's
-   * own working directory is not a scratch space for a worker's config.
-   */
-  cwd?: string;
-  /**
-   * The executor's per-execution run id, folded into the directory name so a directory that somehow
-   * survives names the worker that left it. Uniqueness is NOT taken from this — `mkdtemp` provides
-   * it — because two workers built from one factory in the same millisecond share a run id stem.
-   */
-  runId: string;
-}
-/**
- * The one call `piExecutor` makes before spawning pi: decide what pi must be told, fail loud if it
- * cannot work, then mount.
- *
- * Order matters and is the point:
- *
- * 1. Canonicalize `profile.mcp` first, so the adapter gate keys off servers that would ACTUALLY be
- *    written — a block of `enabled:false` entries must not trip it.
- * 2. If any server survives and `pi-mcp-adapter` is not installed, throw. No file has been written
- *    and pi has not been spawned.
- * 3. Lower `extensions.pi.load` (which may itself throw on an unresolvable extension) — still before
- *    any file exists.
- * 4. Only then create this execution's private config directory and emit `--mcp-config`.
- *
- * A profile with no usable MCP server is a pure no-op: no adapter check, no directory, no flags, no
- * throw. `extensions.pi.load` on its own still produces flags, because reproducible ablation arms
- * need them whether or not MCP is involved.
- *
- * The caller MUST call `mount.cleanup()` on every exit path — settle, throw, abort, timeout, and
- * spawn failure — so the directory does not outlive the worker that owns it.
- */
-declare function preparePiMcp(profile: AgentProfile$1 | undefined, options: PiMcpMountOptions): PiMcpPreparation;
-//#endregion
-//#region src/runtime/supervise/pi-executor.d.ts
-/** The runtime name `piExecutor` registers under. */
-declare const PI_RUNTIME: Runtime;
-/** Seam key the registry threads a `PiSeam` through (`ExecutorContext.seams['pi']`). */
-declare const piSeamKey = "pi";
-/** How to launch pi in its out-of-process RPC mode, and how long to wait on it. */
-interface PiSeam {
-  /** The pi executable (default `'pi'`). Anything on PATH or an absolute path. */
-  bin?: string;
-  /** Extra args appended after `--mode rpc`. `--provider` / `--model` are added from `model`. */
-  args?: ReadonlyArray<string>;
-  /** `provider/model` or just `model` — split on the first `/` into pi's two flags. */
-  model?: string;
-  cwd?: string;
-  env?: Record<string, string>;
-  /** Wall-clock ceiling for one `prompt` (the wait for `agent_settled`). Omit = no timeout. */
-  turnTimeoutMs?: number;
-  /** Newest-last activity window `progress()` reports. Default 12. */
-  activityWindow?: number;
-}
-/** Build the `Executor` for one pi worker. Registered as runtime `'pi'`. */
-declare const piExecutor: ExecutorFactory<unknown>;
-/** What one pi run reports about the terminal assistant turn, plus any derived MCP mount. */
-interface PiExecutorOutput {
-  content: string;
-  turns: number;
-  /** Present only when `profile.mcp` declared at least one usable server. Records what pi was
-   *  actually given — including an extension this executor added that the profile did not list. */
-  mcp?: PiMcpReceipt;
-}
-//#endregion
 //#region src/runtime/supervise/inbox.d.ts
 /**
  *
@@ -1906,7 +1900,8 @@ interface PiExecutorOutput {
  *     in-flight turn immediately, then re-plan with the message folded in — breaking the worker out
  *     of a wrong path mid-task instead of waiting for it to finish the step.
  *
- * `deliver` never throws — a malformed message is ignored, per the `Executor.deliver` contract.
+ * `deliver` never throws — a malformed message is ignored and returns `false`, so no caller can
+ * report delivery for bytes this inbox discarded.
  *
  * @experimental
  */
@@ -1919,8 +1914,9 @@ interface InboxMessage {
   readonly questionId?: string;
 }
 interface Inbox {
-  /** The `Executor.deliver` implementation — accept a raw down-message from `Scope.send`. */
-  deliver(msg: unknown): void;
+  /** The `Executor.deliver` implementation. Returns false when the raw message is malformed and
+   * therefore was not queued; callers must not acknowledge a message this inbox discarded. */
+  deliver(msg: unknown): boolean;
   /** Remove and return all pending messages (the flush). */
   drain(): InboxMessage[];
   pending(): number;
@@ -2033,7 +2029,9 @@ interface CliSeam {
 /**
  * cli-worktree seam. A supervisor-authored `AgentProfile` driving a local coding-harness CLI
  * (claude / codex / opencode) on its own git worktree — the leaf `createWorktreeCliExecutor`
- * named as data. `harness` + `repoRoot` + `taskPrompt` are required; the authored
+ * named as data. `harness` + `repoRoot` are required; the task comes from `Executor.execute`.
+ * `taskPrompt` remains an optional direct-call fallback for callers that execute with `undefined`.
+ * The authored
  * `profile.prompt.systemPrompt` + `profile.model.default` reach the harness via the §1.5
  * `harnessInvocation` mapper. Everything else mirrors `WorktreeCliExecutorOptions`.
  */
@@ -2041,7 +2039,7 @@ interface CliWorktreeSeam {
   repoRoot: string;
   /** Local CLI harness transport. Omit when `bridge` is set. */
   harness?: LocalHarness;
-  taskPrompt: string;
+  taskPrompt?: string;
   runId?: string;
   baseRef?: string;
   harnessTimeoutMs?: number;
@@ -2067,7 +2065,8 @@ interface CliWorktreeBridgeSeam {
   bridgeBearer: string;
   /** Bridge model/harness id. Defaults to the profile's model hint when omitted. */
   model?: string;
-  agentProfile?: Record<string, unknown>;
+  /** Canonical profile overlay merged over the spawned profile. */
+  agentProfile?: AgentProfile$1;
   timeoutMs?: number;
   /** Stable cli-bridge session id. Defaults to `bridge-worktree-${runId}`. */
   sessionId?: string;
@@ -2081,19 +2080,20 @@ interface CliWorktreeBridgeSeam {
  * forwarded verbatim per request — how an arm disables native tools or injects
  * a provider search MCP.
  *
- * The executor opens a RESUMABLE cli-bridge session — structurally identical to the
- * sandbox executor's persistent box, just local. `sessionId` is the stable
- * caller-owned id cli-bridge maps to the harness's internal conversation id; a
- * follow-up steer/resume on the SAME id continues the SAME harness session (opencode
- * `-s`, claude `--resume`, …). Omit it and the executor mints a stable one per spawn.
+ * The executor opens a resumable cli-bridge session. `sessionId` identifies the
+ * 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.
  */
 interface BridgeSeam {
   bridgeUrl: string;
   bridgeBearer: string;
-  model: string;
+  /** Fallback bridge wire id. A spawned profile may select its own harness and model. */
+  model?: string;
   /** Optional working directory forwarded to cli-bridge and persisted with the session. */
   cwd?: string;
-  agentProfile?: Record<string, unknown>;
+  /** Canonical profile overlay merged over the spawned profile. */
+  agentProfile?: AgentProfile$1;
   timeoutMs?: number;
   /** Stable, caller-owned cli-bridge session id for harness-side resume. Defaults
    *  to a freshly minted per-spawn id so each worker is its own resumable session. */
@@ -2101,6 +2101,8 @@ interface BridgeSeam {
   /** Per-resume-turn inference cap before the worker settles on its last output.
    *  Mirrors `routerToolsInlineExecutor.maxTurns`; default 200 (runaway backstop). */
   maxTurns?: number;
+  /** Newest-last activity window `progress()` reports. Default 12 (matches `PiSeam`). */
+  activityWindow?: number;
 }
 /** Generic environment provider executor config. External packages implement
  *  `AgentEnvironmentProvider`; this built-in wrapper lets `createExecutor`
@@ -2108,6 +2110,13 @@ interface BridgeSeam {
 interface ProviderSeam extends ProviderExecutorOptions {
   provider: AgentEnvironmentProvider | string;
   registry?: AgentEnvironmentProviderRegistry;
+  /**
+   * Compose the provider through the existing steerable sandbox session.
+   * The exact profile must name its harness, and the provider must expose live
+   * continuation plus session controls. The provider still owns environment
+   * creation and session semantics.
+   */
+  steering?: SandboxSteeringOptions;
 }
 /**
  * Router seam WITH tool use — the tool-using router backend. Same direct
@@ -2166,8 +2175,6 @@ type ExecutorConfig = ({
 } & CliWorktreeSeam) | ({
   backend: 'provider';
 } & ProviderSeam) | ({
-  backend: 'pi';
-} & PiSeam) | ({
   backend: 'sandbox';
   harness?: BackendType;
 } & SandboxSeam);
@@ -2187,8 +2194,8 @@ declare function createExecutor(config: ExecutorConfig): ExecutorFactory<unknown
  * without touching the registry at all. NOT a closed switch; registration + BYO
  * ARE the extension points.
  *
- * `resolve` precedence (frozen in `ExecutorRegistry`): a BYO `spec.executor` →
- * `harness === null` → the `'router'` factory; else a registered factory for the
+ * `resolve` precedence (frozen in `ExecutorRegistry`): a BYO `spec.executorFactory` →
+ * `spec.executor` → `harness === null` → the `'router'` factory; else a registered factory for the
  * harness-derived runtime (`'sandbox'` for any `BackendType`); else fail loud.
  */
 declare function createExecutorRegistry(): ExecutorRegistry;
@@ -2236,8 +2243,16 @@ type DelegateResult = {
 } | {
   status: 'no-winner';
   reason: string;
+  error?: DelegateError;
   spentTotal: Spend;
 };
+/** What killed a delegation, projected for the calling agent: the rejection's name and message.
+ *  `reason` is a four-word code (`driver-failed`), and a code alone is not diagnosable — the
+ *  supervisor attaches the rejection to the result precisely so a caller can read it. */
+interface DelegateError {
+  name: string;
+  message: string;
+}
 /** @experimental */
 interface DelegateHandlerOptions {
   /** The supervisor brain's router substrate (REQUIRED — the default supervisor is router-brained). */
@@ -2336,13 +2351,26 @@ declare function createInProcessTransport(): {
 interface SettledWorker {
   readonly id: string;
   readonly status: 'done' | 'down';
+  /** Stable manager-scoped assignment, including deterministic unkeyed siblings. */
+  readonly assignmentId?: string;
+  /** Exact profile/task/candidate identity authorized for this node. */
+  readonly identity?: NodeExecutionIdentity;
+  /** Stable effective execution plan, or an explicit unknown receipt. */
+  readonly materialization?: ProfileMaterializationReceipt;
+  /** Backend bindings for each attempt, in durable oldest-first order. */
+  readonly executionBindings?: ReadonlyArray<ExecutionBindingReceipt>;
+  /** Conserved spend. Missing means unavailable; unknown accounting remains explicitly unknown. */
+  readonly spent?: Spend;
   readonly score?: number;
   readonly valid?: boolean;
   readonly outRef?: string;
   readonly reason?: string;
-  /** Epoch ms the ledger recorded this settlement — the resolution a progress-based stop rule
-   *  needs to answer "how long since anything landed?" without inventing a timestamp at read
-   *  time. Stamped when the cursor yields the settlement, not when a reader first looks. */
+  /** Structured tool-call evidence, never the worker's final prose. */
+  readonly trace: WorkerTraceEvidence;
+  /** True when projected from a prior process of the same durable run. */
+  readonly resumed?: boolean;
+  /** Epoch ms from the durable terminal record — the resolution a progress-based stop rule needs
+   *  to answer "how long since anything landed?" without inventing a timestamp at read time. */
   readonly settledAt?: number;
 }
 type QuestionLevel = 'worker' | 'driver' | 'loop';
@@ -2384,7 +2412,7 @@ interface AnalystRegistry {
     description: string;
     area: string;
   }>;
-  readonly run: (kindId: string, trace: unknown) => Promise<unknown>;
+  readonly run: (kindId: string, trace: TraceAnalysisStore) => Promise<unknown>;
 }
 /** A trace-analyst result re-entered as a message on the bus (the `finding` event kind). */
 interface AnalystFindingEvent {
@@ -2392,16 +2420,63 @@ interface AnalystFindingEvent {
   readonly analyst: string;
   readonly findings: unknown;
 }
-/** A parent→child message (the down-leg): recorded for observability, delivered via the child inbox,
- *  never pulled back by the parent. `delivered` mirrors whether the live child accepted it. */
+/** 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`.
+ * If a process dies with this marker but no matching outcome, delivery is unknown and is never
+ * replayed automatically. */
+interface DownMessageDeliveryAttempt {
+  readonly receiptId: string;
+  readonly kind: 'steer' | 'answer';
+  readonly toWorker: string;
+  readonly instructionDigest: string;
+  readonly interrupt: boolean;
+  readonly questionId?: string;
+}
+/** A parent→child delivery result (the down-leg): recorded for observability, never pulled back by
+ * the parent. `receiptId` and `instructionDigest` link it to the pre-delivery authorization receipt
+ * and attempt marker. */
 interface DownMessageEvent {
+  readonly receiptId: string;
   readonly toWorker: string;
   readonly instruction: string;
+  readonly instructionDigest: string;
   readonly delivered: boolean;
+  readonly outcome: DownMessageDeliveryOutcome;
+  readonly error?: string;
 }
+/** Durable authorization receipt written before a continuation reaches a worker. */
+interface ContinuationInstruction {
+  readonly receiptId: string;
+  readonly kind: 'steer' | 'answer';
+  readonly toWorker: string;
+  readonly instruction: string;
+  readonly instructionDigest: string;
+  readonly workerIdentity?: NodeExecutionIdentity;
+  readonly interrupt: boolean;
+  readonly questionId?: string;
+}
+/** Detached continuation bytes and exact worker identity presented to product authorization before
+ * Runtime records or delivers a steer/answer. */
+interface DownMessageAuthorizationInput {
+  readonly kind: 'steer' | 'answer';
+  readonly workerId: string;
+  readonly workerIdentity: NodeExecutionIdentity;
+  readonly instruction: string;
+  readonly interrupt: boolean;
+  readonly questionId?: string;
+}
+/** Product-authorized continuation bytes. Returning a narrowed instruction replaces the proposed
+ * bytes; throwing refuses delivery. */
+interface AuthorizedDownMessage {
+  readonly instruction: string;
+}
+/** Product decision over an exact continuation before it is durably recorded or delivered. */
+type AuthorizeDownMessage = (input: DownMessageAuthorizationInput) => AuthorizedDownMessage;
 /** Every message on the one typed pipe. UP (child→parent): question / settled / finding — queued for
- *  the driver to `pull`. DOWN (parent→child): steer / answer — record-only (history + subscribers),
- *  routed to the child inbox. New kinds are additive. */
+ *  the driver to `pull`. An `instruction` is the pre-delivery authorization receipt and is retained
+ *  as evidence. DOWN (parent→child): steer / answer — record-only (history + subscribers), routed
+ *  to the child inbox. Receipts are never auto-delivered on restart. New kinds are additive. */
 type CoordinationEvent = {
   readonly type: 'question';
   readonly question: QuestionRecord;
@@ -2418,8 +2493,34 @@ type CoordinationEvent = {
   readonly type: 'answer';
   readonly down: DownMessageEvent;
   readonly questionId: string;
+} | {
+  readonly type: 'instruction';
+  readonly instruction: ContinuationInstruction;
+} | {
+  readonly type: 'delivery-attempt';
+  readonly attempt: DownMessageDeliveryAttempt;
 };
-type MakeWorkerAgent = (profile: unknown) => Agent<unknown, unknown>;
+/** Immutable task, allocation, identity attribution, and semantic key supplied while a manager's
+ * complete worker profile is prepared for one spawn. */
+interface WorkerSpawnContext {
+  /** Stable assignment identity within this manager. A semantic key wins; otherwise Runtime mints
+   * the manager's deterministic pre-factory spawn ordinal so identical unkeyed siblings stay
+   * isolated and can recover by issuing the same assignments in the same order. */
+  readonly assignmentId: string;
+  /** Trusted concrete manager node authorizing this spawn. Never accepted from model arguments. */
+  readonly parentNodeId: string;
+  /** The exact allocation this node receives after the tool's optional override is merged. */
+  readonly budget: Budget;
+  /** Detached, deeply immutable task bytes from this spawn request. */
+  readonly task: unknown;
+  /** Exact trace label selected for this spawn. */
+  readonly label: string;
+  /** Semantic restart key, when the manager supplied one. */
+  readonly key?: string;
+  /** Trusted candidate/campaign attribution attached by product authorization. */
+  readonly execution?: AgentExecutionRef;
+}
+type MakeWorkerAgent = (profile: AgentProfile$1, context?: WorkerSpawnContext) => Agent<unknown, unknown>;
 interface CoordinationToolsOptions {
   readonly scope: Scope<unknown>;
   readonly blobs: ResultBlobStore;
@@ -2432,7 +2533,14 @@ interface CoordinationToolsOptions {
    */
   readonly deliverable?: DeliverableSpec<unknown>;
   readonly analysts?: AnalystRegistry;
-  readonly onEvent?: (event: CoordinationEvent) => void | Promise<void>;
+  /** Event-first for source compatibility; the second argument is its exact bus ordering stamp. */
+  readonly onEvent?: (event: CoordinationEvent, record: BusRecord<CoordinationEvent>) => void | Promise<void>;
+  /** Re-publish resumed settlements through the awaited observer before the driver starts. This is
+   *  the crash-window recovery path for product transactions; off preserves low-level legacy reads. */
+  readonly replaySettlements?: boolean;
+  /** Authorize each continuation against the exact worker identity. The returned instruction is
+   * 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
@@ -2443,7 +2551,8 @@ interface CoordinationToolsOptions {
    *  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
    *  conserved-budget fence (the pool bounds total work; this bounds simultaneous work, e.g. live
-   *  sandboxes/boxes). Omit or `<= 0` = no cap (the prior behavior; the pool stays the only fence). */
+   *  sandboxes/boxes). A tree-wide limit owned by `Scope` takes precedence when present; this field
+   *  is the local form for a caller-owned scope. Omit or `<= 0` = no local cap. */
   readonly maxLiveWorkers?: number;
   /** Max wall-clock ms a single `await_event` call may block waiting on a live worker to settle
    *  before it returns a non-error `{ pending: true, live }` snapshot and lets the caller re-poll.
@@ -2503,6 +2612,8 @@ declare const DEFAULT_AWAIT_EVENT_TIMEOUT_MS = 15000;
  */
 interface CoordinationTools {
   readonly tools: McpToolDescriptor$1[];
+  /** Commit any resume-time event replay before a supervisor can reason or an MCP can listen. */
+  ready(): Promise<void>;
   isStopped(): boolean;
   stopReason(): string | undefined;
   /** The first result whose injected independent check passed, if the driver submitted one. */
@@ -2511,9 +2622,9 @@ interface CoordinationTools {
   } | undefined;
   settled(): ReadonlyArray<SettledWorker>;
   questions(): ReadonlyArray<QuestionRecord>;
-  /** The full ordered log of every bus event — UP (settled / question / finding) and DOWN
-   *  (steer / answer) — the observability audit + replay trail. Each record carries seq,
-   *  timestamp, and priority. */
+  /** The full ordered log of every bus event — UP (settled / question / finding), authorized
+   *  instruction receipts, and DOWN delivery outcomes (steer / answer). Each record carries seq,
+   *  timestamp, and priority. A receipt is evidence and is never auto-delivered on restart. */
   history(): ReadonlyArray<BusRecord<CoordinationEvent>>;
   /** Bus throughput counters (published / pulled / by-kind) for live dashboards. */
   stats(): BusStats;
@@ -6011,24 +6122,40 @@ interface StructuralRolloutConfig {
 declare function structuralRollout(config?: StructuralRolloutConfig): Strategy<StructuralRolloutResult>;
 //#endregion
 //#region src/runtime/supervise/authoring.d.ts
-/** What the supervisor AUTHORS per sub-task — a worker recipe (a partial `AgentProfile`). */
-interface AuthoredProfile {
-  name: string;
-  /** The rich, task-specific instructions the supervisor wrote for THIS worker. */
-  systemPrompt: string;
-  /** The model the supervisor chose for this sub-task (falls back to the run default). */
-  model?: string;
-}
+/** What the supervisor AUTHORS per sub-task: one complete canonical profile whose name and
+ *  task-specific system prompt are present. Every other `AgentProfile` axis is preserved exactly. */
+type AuthoredProfile = AgentProfile$1 & {
+  readonly name: string;
+  readonly prompt: AgentProfilePrompt & {
+    readonly systemPrompt: string;
+  };
+};
 /** Narrow an untyped `spawn_agent` profile argument to an `AuthoredProfile`, or null if the
  *  supervisor failed to author one (empty/placeholder profile — a skill violation worth catching). */
 declare function asAuthoredProfile(raw: unknown): AuthoredProfile | null;
+/**
+ * Lift a profile the supervisor AUTHORED into the canonical shape every executor reads.
+ *
+ * The skill asks for `systemPrompt` and `model` as flat fields — the vocabulary a model writes
+ * well — while `AgentProfile` carries them as `prompt.systemPrompt` and `model.default`. Nothing
+ * downstream reads the flat form: the router and cli-bridge leaves read `profile.prompt
+ * .systemPrompt`, and the sandbox leaf hands the profile to a strict schema that REJECTS the flat
+ * key outright (`Unrecognized key: "systemPrompt"`), which fails the worker's every round. Lift
+ * both here, once, so what the supervisor writes is what the worker runs.
+ *
+ * Purely additive: a profile already canonical is returned untouched, and a flat field is dropped
+ * only after its canonical slot is filled. Both spellings of the same standing instruction, set to
+ * DIFFERENT text, is a contradiction with no safe reading — it fails loud, matching
+ * `resolveSupervisorProfile`'s rule for the supervisor's own profile.
+ */
+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. */
 declare function supervisorInstructions(opts?: {
   goal?: string;
 }): string;
-/** Build a worker AGENT from a profile the supervisor authored: the authored `systemPrompt` +
- *  `model` shape the worker's one model call; the deliverable gates settlement (valid ⟺ delivered). */
+/** Build a router-only worker from an authored profile. This helper executes the prompt/model axes;
+ *  use `workerFromBackend` for full materialization of tools, MCP, resources, hooks, and subagents. */
 declare function authoredWorker(profile: AuthoredProfile, opts: {
   cfg: RouterConfig;
   taskPrompt: string;
@@ -6102,6 +6229,7 @@ interface ReservationTicket {
 /** Post-reservation pool readout — the shape `Scope.budget` exposes. `tokensLeft`,
  *  `usdLeft`, and `reservedTokens` reflect committed-but-unsettled reservations;
  *  `deadlineMs` is the ABSOLUTE wall-clock deadline (0 when the root set none).
+ *  `iterationsLeft` is the remaining iteration capacity.
  *  `usdCapped` distinguishes a real `usdLeft <= 0` exhaustion from an uncapped pool (which always
  *  reads `usdLeft: 0`) — the in-loop guard needs it to bound a usd-capped driver. */
 type BudgetReadout = Readonly<{
@@ -6112,16 +6240,32 @@ type BudgetReadout = Readonly<{
    * consumption is at least the debited amount and possibly more. Reading `tokensLeft` without this
    * flag would present an under-count as an exact balance.
    */
-  tokensKnown?: boolean;
+  tokensKnown: boolean;
   usdLeft: number;
   usdCapped: boolean;
+  /** False once any recorded work reported an unknown dollar cost; the dollar totals are then a
+   *  lower bound on real spend, not a measurement. */
+  usdKnown: boolean;
+  iterationsLeft: number;
   deadlineMs: number;
   reservedTokens: number;
 }>;
 /** Why a reservation was refused. `budget-exhausted` means the pool ran out of a channel it
- *  budgets; `usd-unbudgeted` means the root declared no dollar ceiling, so a dollar request is
+ *  budgets; `below-runtime-floor` means the request is under the amount that harness needs before
+ *  it does any work at all, so it is unsatisfiable at that size and the fix is to RAISE it;
+ *  `usd-unbudgeted` means the root declared no dollar ceiling, so a dollar request is
  *  unsatisfiable at any amount and the fix is to budget the root, not to ask for less. */
-type ReservationRejection = 'budget-exhausted' | 'usd-unbudgeted';
+type ReservationRejection = 'budget-exhausted' | 'usd-unbudgeted' | 'below-runtime-floor';
+/** State recovered from a prior process before new work is admitted. `committed` is measured spend
+ * already present in the durable journal. Each `uncertainReservation` is a child that was recorded
+ * as started but never recorded as settled: its full declared ceiling is charged conservatively,
+ * while the public readout remains explicitly unknown. */
+interface BudgetPoolRestore {
+  readonly committed?: Spend;
+  readonly uncertainReservations?: ReadonlyArray<Budget>;
+  /** Original absolute deadline from the first process. It may never slide on restart. */
+  readonly absoluteDeadlineMs?: number;
+}
 interface BudgetPool {
   /**
    * Atomically reserve a child's full ceiling from the free balance. Fails closed
@@ -6170,31 +6314,52 @@ declare function spendFromUsageEvents(events: UsageEvent[]): Spend;
 /**
  * Create a conserved reservation pool from a root `Budget`. `now()` is injected so the
  * deadline readout is deterministic; defaults to `Date.now` for non-test callers. The
- * absolute deadline is fixed at construction (`now() + budget.deadlineMs`) so the
- * readout's `deadlineMs` is a stable wall-clock instant, not a shrinking remainder.
+ * absolute deadline for a fresh pool is fixed at construction (`now() + budget.deadlineMs`). A
+ * restored pool instead retains `restore.absoluteDeadlineMs`, so restart never slides the original
+ * wall-clock limit. The readout is an absolute instant, not a shrinking remainder.
  */
-declare function createBudgetPool(root: Budget, now?: () => number): BudgetPool;
+declare function createBudgetPool(root: Budget, now?: () => number, restore?: BudgetPoolRestore): BudgetPool;
 //#endregion
 //#region src/runtime/supervise/coordination-log.d.ts
-/** What a prior process's coordination log replays into a resumed driver. */
+/** Stable identity of the supervisor that owns one coordination stream. High-level supervision
+ * derives it from the exact root/child execution identity plus its parent assignment. */
+type CoordinationOwnerId = string;
+/** Durable delivery evidence retained in commit order. An attempt without a later event carrying
+ * the same `receiptId` has an unknown outcome after a crash and is never replayed. */
+type CoordinationDeliveryEvidence = Extract<CoordinationEvent, {
+  readonly type: 'delivery-attempt' | 'steer' | 'answer';
+}>;
+/** Coordination evidence loaded from prior processes of one durable supervised run. */
 interface PriorCoordination {
+  /** The owner filter used for this replay. Omitted only for the compatibility all-owner read. */
+  readonly ownerId?: CoordinationOwnerId;
   /** Every question the prior process raised, with answer-status folded in, raise order. */
   readonly questions: ReadonlyArray<QuestionRecord>;
   /** Every analyst finding the prior process published, publish order. */
   readonly findings: ReadonlyArray<AnalystFindingEvent>;
+  /** Every authorized continuation, in commit order. These are evidence, never replayed to a new
+   * worker automatically. */
+  readonly continuations: ReadonlyArray<ContinuationInstruction>;
+  /** Delivery intent and result records in commit order, linked to receipts by `receiptId`. */
+  readonly deliveryEvidence: ReadonlyArray<CoordinationDeliveryEvidence>;
+  /** Exact source-bus stamps in durable append order. Bus `seq` restarts with each process; append
+   * order remains the cross-process replay order. */
+  readonly records: ReadonlyArray<BusRecord<CoordinationEvent>>;
 }
 /** The durable coordination side-log seam. `append` records one bus event (kinds it does not
  *  persist are ignored); `load` replays a run's prior records folded into `PriorCoordination`. */
 interface CoordinationLog {
-  append(runId: string, event: CoordinationEvent, at: string): Promise<void>;
-  load(runId: string): Promise<PriorCoordination>;
+  append(runId: string, record: BusRecord<CoordinationEvent>, ownerId?: CoordinationOwnerId): Promise<void>;
+  load(runId: string, ownerId?: CoordinationOwnerId): Promise<PriorCoordination>;
 }
 /** FS-backed `CoordinationLog`: append-only JSONL, fsynced per record. */
 declare class FileCoordinationLog implements CoordinationLog {
   private readonly path;
+  private appendTail;
   constructor(path: string);
-  append(runId: string, event: CoordinationEvent, at: string): Promise<void>;
-  load(runId: string): Promise<PriorCoordination>;
+  append(runId: string, record: BusRecord<CoordinationEvent>, ownerId?: CoordinationOwnerId): Promise<void>;
+  private appendRecord;
+  load(runId: string, ownerId?: CoordinationOwnerId): Promise<PriorCoordination>;
 }
 //#endregion
 //#region src/runtime/supervise/finalizer.d.ts
@@ -6425,6 +6590,7 @@ interface DriverAgentOptions {
   readonly blobs: ResultBlobStore;
   /** Resolve a spawned `profile` to a worker LEAF or a driver child (the recursion seam). */
   readonly makeWorkerAgent: MakeWorkerAgent;
+  readonly authorizeDownMessage?: AuthorizeDownMessage;
   /** Per-child budget reserved from the conserved pool on each spawn. */
   readonly perWorker: Budget;
   /** Independent completion check for work the driver performs itself. When present, the driver
@@ -6450,6 +6616,9 @@ interface DriverAgentOptions {
   /** The driver's stance — a string, or built from the task (the worker-driver prompt /
    *  the generator). INJECTED so the prompt is a pluggable, optimizable role. */
   readonly systemPrompt: string | ((task: unknown) => string);
+  /** Product-selected tools already bound to this exact supervisor node. The same descriptors are
+   *  served over MCP for external supervisors; this arm projects them into router ToolSpecs. */
+  readonly nodeTools?: ReadonlyArray<McpToolDescriptor$1>;
   /** WORK tools the driver may call DIRECTLY (alongside the coordination verbs) — so the driver is
    *  not a pure manager but a full agent that can ACT (do simple work itself) OR SPAWN (delegate).
    *  Each is a router tool spec; their names must not collide with the coordination verbs. Pair with
@@ -6497,18 +6666,24 @@ interface DriverAgentOptions {
    *  off (no behavior change). `distill` defaults to a self-summary authored by the brain combined
    *  with the factual settled-worker roster; override to supply your own. */
   readonly compaction?: ToolLoopCompactionOptions;
-  /** Pass-through subscriber for every coordination bus event (settled / question / finding /
-   *  steer / answer) — what a durable caller hooks its coordination log onto. Omit = no observer. */
-  readonly onEvent?: (event: CoordinationEvent) => void | Promise<void>;
-  /** Questions + findings a durable coordination log replayed from a prior process of this run.
-   *  Questions seed the ledger (`list_questions`, blocking-stop policy); both feed the resume
-   *  brief. Omit = fresh (every run that is not a resume). */
+  /** Pass-through subscriber for every coordination bus event: settled/question/finding,
+   *  pre-delivery instruction receipts, and steer/answer delivery outcomes. A durable caller uses
+   *  this to append the coordination log. Omit = no observer. */
+  readonly onEvent?: (event: CoordinationEvent, record: BusRecord<CoordinationEvent>) => void | Promise<void>;
+  /** Re-publish resume-time settlements through the awaited observer before the first brain turn. */
+  readonly replaySettlements?: boolean;
+  /** Questions, findings, and authorized continuation receipts loaded from a prior process.
+   *  Questions seed the ledger (`list_questions`, blocking-stop policy); all three feed the resume
+   *  brief. Continuation receipts are evidence only and are never auto-delivered. Omit = fresh. */
   readonly priorCoordination?: PriorCoordination;
   /** How the settled-worker ledger becomes the run's output. Default `bestDelivered` — the single
    *  highest-scoring DELIVERED child (the exact keep-best every existing caller had). Runs under
    *  the delivered-only invariant (`runFinalizer`): whatever the finalizer, an undelivered or
    *  invalid child's output stays unreachable. */
   readonly finalizer?: SupervisorFinalizer;
+  /** Optional shared manager inbox used by a wrapper that must accept messages before async node
+   * setup finishes. Ordinary callers omit it and the driver owns a fresh inbox. */
+  readonly inbox?: Inbox;
 }
 /**
  * Build the intelligent recursive driver. Its `act` is the LLM tool-loop; spawn it as a
@@ -6542,7 +6717,7 @@ interface CoordinationMcpHandle {
    *  `settled()` for a finalize, so a delivered child the harness never awaited is not lost. */
   drainResolved: CoordinationTools['drainResolved'];
   isStopped(): boolean;
-  /** The full ordered bus-event log — observability audit + replay trail. */
+  /** The full ordered bus-event log for current-process observability and audit evidence. */
   history: CoordinationTools['history'];
   /** Bus throughput counters for live dashboards. */
   stats: CoordinationTools['stats'];
@@ -6557,6 +6732,7 @@ declare function serveCoordinationMcp(opts: {
   scope: Scope<unknown>;
   blobs: ResultBlobStore;
   makeWorkerAgent: MakeWorkerAgent;
+  authorizeDownMessage?: AuthorizeDownMessage;
   perWorker: Budget;
   /** Independent completion check exposed to the driver as `submit_result`. */
   deliverable?: DeliverableSpec<unknown>;
@@ -6583,188 +6759,19 @@ declare function serveCoordinationMcp(opts: {
   watchWorkers?: WorkerWatchOptions;
   /** Idle time after which `observe_agent` reports a worker as stalled. */
   stallAfterMs?: number;
-  /** Pass-through subscriber for every bus event (settled / question / finding). */
-  onEvent?: (event: CoordinationEvent) => void | Promise<void>;
+  /** Pass-through subscriber for every bus event, including pre-delivery instruction receipts and
+   * steer/answer delivery outcomes. */
+  onEvent?: (event: CoordinationEvent, record: BusRecord<CoordinationEvent>) => void | Promise<void>;
+  /** Re-publish resume-time settlements through the awaited observer before this server listens. */
+  replaySettlements?: boolean;
   questionPolicy?: QuestionPolicy;
   /** Questions replayed from a prior process of this run — seeds the question ledger. */
   priorQuestions?: ReadonlyArray<QuestionRecord>;
+  /** Product-selected tools already bound to this exact supervisor node. They share this server
+   *  with the coordination verbs, so the existing MCP duplicate-name guard applies before listen. */
+  nodeTools?: ReadonlyArray<McpToolDescriptor$1>;
 }): Promise<CoordinationMcpHandle>;
 //#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 → router brain (in-process tool-loop); a coding-CLI harness → sandboxed 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;
-}
-/**
- * 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;
-/** How to run a sandboxed 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 (sandbox / 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. */
-type 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;
-}) => Promise<void>;
-interface SupervisorAgentDeps {
-  readonly blobs: ResultBlobStore;
-  /** Resolve a spawned worker `profile` to a leaf agent — the recursion seam (same for both arms). */
-  readonly makeWorkerAgent: MakeWorkerAgent;
-  /** 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` null). 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 for a sandboxed-harness supervisor (`harness` set): runs the harness as the driver. */
-  readonly driveHarness?: DriveHarness;
-  /** 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>;
-  /** 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) => void | Promise<void>;
-  /** Questions + findings replayed from a prior process of this run (a durable coordination log).
-   *  Router arm: seeds the question ledger + the resume brief. Sandbox arm: seeds the ledger. */
-  readonly priorCoordination?: 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 (sandbox 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/delegate.d.ts
 /** The conserved pool a `delegate()` call applies when the caller does not pass its own `budget`.
  *  A modest token ceiling + a small iteration ceiling — generous enough for a few-worker decompose,
@@ -6794,7 +6801,10 @@ interface DelegateOptions<Out = unknown> {
   readonly brain?: ToolLoopChat;
   /** Override the default authoring-supervisor profile (name / extra system-prompt stance). The
    *  default already carries the authoring skill; override only to add a goal or rename. */
-  readonly supervisor?: Partial<Pick<SupervisorProfile, 'name' | 'systemPrompt'>>;
+  readonly supervisor?: {
+    readonly name?: string;
+    readonly systemPrompt?: string;
+  };
   /** Restrict the run to this subset of models (forwarded to `supervise()`). */
   readonly allowedModels?: readonly string[];
   readonly runId?: string;
@@ -6910,6 +6920,9 @@ declare function queueOf<Out>(units: ReadonlyArray<{
  * `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/otel-spans.d.ts
 /** OTLP span attribute values. Exported because `SupervisorSpanOptions.attributes` is public and
@@ -7003,16 +7016,16 @@ interface WorktreeCliExecutorOptions {
   repoRoot: string;
   /**
    * The supervisor-authored prompt/model plus materializable structural resources.
-   * `model.default` selects the one-shot model; `small`, `provider`, and `metadata` remain hints.
-   * Resource failures are fatal regardless of `resources.failOnError`.
-   * Tools, permissions, connections, confidential execution, modes, and extensions fail closed.
-   * Harness-specific nested controls that the pinned materializer cannot preserve also fail closed.
+   * `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;
-  /** The per-task instruction handed to the harness (composed under the system prompt). */
-  taskPrompt: string;
+  /** 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`). */
@@ -7049,13 +7062,16 @@ interface WorktreeCliExecutorOptions {
    * 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`/`taskPrompt` throws at construction. `resultArtifact()`
- * before `execute()` resolves throws.
+ * 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
  */
@@ -7107,10 +7123,11 @@ interface InMemoryRunContext {
    */
   readonly resume?: boolean;
   /**
-   * Present only on a DURABLE context: the coordination side-log (questions + analyst findings —
-   * the bus messages the spawn journal does not record). `supervise({ runDir })` appends to it as
-   * they publish and replays it on resume, so a restarted coordinator keeps them. In-memory
-   * contexts have none: nothing outlives the process to replay into.
+   * 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;
 }
@@ -7130,8 +7147,9 @@ declare function createInMemoryRunContext(opts?: InMemoryRunContextOptions): InM
  * 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, replayed into a resumed driver). The directory is created on first write.
+ * 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.
@@ -7193,12 +7211,25 @@ declare function supervisorRunDir(rootDir: string, id: string): string;
  * 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.
  *
@@ -7222,7 +7253,7 @@ interface ScopeArgs {
   readonly parentId: NodeId;
   /** Journal/blob root key the supervisor `beginTree`'d. */
   readonly root: NodeId;
-  /** The shared conserved reservation pool (one per supervised run). */
+  /** 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;
@@ -7241,6 +7272,11 @@ interface ScopeArgs {
   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;
+  /** @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. */
@@ -7256,6 +7292,17 @@ interface ScopeArgs {
    * ⇒ 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`
@@ -7283,6 +7330,11 @@ interface ScopeArgs {
     };
   };
 }
+/** 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>;
 /**
@@ -7298,6 +7350,248 @@ declare function createScope<Out>(args: ScopeArgs): Scope<Out>;
  */
 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;
+}
+/**
+ * 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;
+}
+/** 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>;
+  /** 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/supervise.d.ts
 /**
  * Build the worker seam from a backend (WHERE workers run) + an optional completion oracle (the
@@ -7313,6 +7607,9 @@ declare function settledToIteration<Out>(settled: Settled<Out>): Iteration<unkno
  * ahead of the worker seam.
  */
 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. */
@@ -7337,6 +7634,15 @@ interface SuperviseRegistry {
 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
@@ -7344,6 +7650,10 @@ interface SuperviseOptions {
    *  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;
@@ -7351,17 +7661,76 @@ interface SuperviseOptions {
    *  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`. */
+  /** 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;
-  /** The supervisor's router substrate (`harness` null). The profile's model wins. */
+  /** 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 a sandboxed-harness supervisor (`harness` set). */
+  /** 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 (`harness` null). */
+   *  `executeExtraTool`. Router arm only (`profile.harness` omitted or `cli-base`). */
   readonly extraTools?: ReadonlyArray<{
     readonly name: string;
     readonly description?: string;
@@ -7371,9 +7740,9 @@ interface SuperviseOptions {
   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-LIVE workers — `spawn_agent` fails closed once this many are in
-   *  flight. The conserved pool bounds TOTAL work; this bounds SIMULTANEOUS work (live boxes/
-   *  sandboxes a real fleet runs at once). Omit/`<= 0` = no cap (the pool stays the only fence). */
+  /** 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
@@ -7402,17 +7771,23 @@ interface SuperviseOptions {
   /**
    * 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, and the built-in
-   * driver is resume-AWARE out of the box: the children that already settled are replayed onto
+   * 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, prior questions/findings replay from the
-   * coordination log, and the finalize spans both processes' work. Unset = in-memory, fresh
-   * every call.
+   * 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, so those assignments
-   * resume as explicitly lost/in-doubt and re-run (reported, never silent).
+   * 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`.
@@ -7477,12 +7852,57 @@ interface SuperviseOptions {
    */
   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;
+}
+/** 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;
+}
+/** 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/supervisor.d.ts
 /** Create a supervisor that owns one recursive agent execution tree. */
 declare function createSupervisor<Task, Out>(): Supervisor<Task, Out>;
+/**
+ * Mint a `RootHandle` plus its supervisor-private control. The handle is the substrate a
+ * chat/pi-viz client attaches to (Q2): `view()` reads the live tree, `signal()` delivers
+ * an out-of-band message, `abort()` cascades. Before `run` binds it (and after `run`
+ * unbinds it) the handle is fail-loud: a client that talks to a handle that is not
+ * driving a live run gets a typed error, never a silent no-op.
+ */
+declare function createRootHandle<Out>(): SteerableRootHandle<Out>;
+//#endregion
+//#region src/runtime/supervise/trace-evidence.d.ts
+/** Schema version for content-addressed worker tool-trace artifacts. */
+declare const WORKER_TOOL_TRACE_SCHEMA_VERSION: 1;
+/** Bytes stored under `WorkerTraceEvidence.traceRef`. */
+interface WorkerToolTraceArtifact {
+  readonly schemaVersion: typeof WORKER_TOOL_TRACE_SCHEMA_VERSION;
+  readonly spans: ReadonlyArray<ToolSpan>;
+}
+/** Collect and persist one executor's structured tool trace without changing its task outcome. */
+declare function captureWorkerTraceEvidence(readSource: (() => TraceSource | undefined) | undefined, blobs: ResultBlobStore, executed: boolean): Promise<WorkerTraceEvidence>;
+/** Rehydrate exact persisted spans through agent-eval's one bounded trace-analysis adapter. */
+declare function workerTraceAnalysisStore(evidence: WorkerTraceEvidence, blobs: Pick<ResultBlobStore, 'get'>): Promise<TraceAnalysisStore>;
+/** Validate a stored trace artifact before an analyst or replay trusts it. */
+declare function parseWorkerToolTraceArtifact(value: unknown, traceRef?: string): WorkerToolTraceArtifact;
 //#endregion
 //#region src/runtime/supervise/trajectory-recorder.d.ts
 interface TrajectoryAnalysis {
@@ -7649,7 +8069,14 @@ interface AuthoredHarness {
   /** The supervisor-authored `AgentProfile` (systemPrompt + model reach the harness via §1.5). */
   profile: AgentProfile$1;
   /** Which local harness CLI drives this leaf. */
-  harness: 'claude' | 'codex' | 'opencode';
+  harness: LocalHarness;
+  /** Require measured usage from this leaf. Budgeted supervision refuses the default unmetered
+   *  local-CLI mode; set false only when the selected runner actually returns token usage. */
+  budgetExempt?: WorktreeCliExecutorOptions['budgetExempt'];
+  /** Run Codex through its measured, isolated JSONL path. This implies `budgetExempt: false`. */
+  codexReproducible?: WorktreeCliExecutorOptions['codexReproducible'];
+  /** Host paths denied to a reproducible Codex leaf. */
+  codexReadDeniedPaths?: WorktreeCliExecutorOptions['codexReadDeniedPaths'];
   /** Per-harness model/runId/baseRef overrides flow through the profile + these. */
   runId?: string;
   baseRef?: string;
@@ -7766,5 +8193,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 { safeWorkerFile as $, HarvestCorpusOptions as $a, InboxMessage as $c, BenchmarkStrategySummary as $i, createSiblingSandboxExecutor as $l, modelAuthoredChecks as $n, Persona as $o, CheckpointCapableBox as $r, plateauLength as $s, StopDecision as $t, DELEGATION_TRACE_MAX_SPANS as $u, GitWorkspaceOptions as A, LoopDispatchOptions as Aa, DelegateArgs as Ac, defaultToolDetectors as Ad, renderCorpusToInstructions as Ai, JsonRpcResponse as Al, assessAuthoredProfile as An, Pipeline as Ao, strategyAuthorContract as Ar, LeaderboardOptions as As, DelegateOptions as At, DelegateUiAuditArgs as Au, analyzeTrace as B, localSandboxClient as Ba, ProviderSeam as Bc, pendingWaits as Bd, RegistryAnalyzeProjection as Bi, DelegateRunCtx as Bl, CheckSourceCtx as Bn, TrajectoryReportFn as Bo, McpToolDescriptor as Br, renderLeaderboardSvg as Bs, supervisorAgent as Bt, DelegationProgress as Bu, closingWorkerNote as C, defineStrategy as Ca, McpServer as Cc, BusEvent as Cd, builtinShapes as Ci, GitRunner as Cl, ReservationTicket as Cn, LoopUntil as Co, pickChampion as Cr, deterministicCompletion as Cs, DispatchStopReason as Ct, DelegateCodeConfig as Cu, UntrackedCopyStats as D, sample as Da, DELEGATE_DESCRIPTION as Dc, PublishOptions as Dd, runPersonified as Di, createWorktree as Dl, ProfileRichness as Dn, PanelJudge as Do, AuthoredStrategy as Dr, GroupOf as Ds, freeSlots as Dt, DelegateResearchArgs as Du, CopyOptions as E, runAgentic as Ea, createMcpServer as Ec, EventBus as Ed, definePersona as Ei, captureWorktreeDiff as El, AuthoredProfile as En, Panel as Eo, AuthorStrategyOptions as Er, AxisScoresOf as Es, effectiveConcurrency as Et, DelegateFeedbackResult as Eu, gitWorkspace as F, RunLoopOptions as Fa, BridgeSeam as Fc, FileSpawnJournal as Fd, pipeline as Fi, InMemoryFeedbackStore as Fl, CheckExecChannel as Fn, ScopeAnalyzeInput as Fo, dumbDriver as Fr, ScoreOf as Fs, ResolvedSupervisorProfile as Ft, DelegationFeedbackSnapshot as Fu, supervise as G, resolveMcpServerLaunch as Ga, createExecutor as Gc, McpEndpoint as Gi, coderTaskFromArgs as Gl, StructuralRolloutResult as Gn, WidenDecision as Go, Deliverable as Gr, auditIntent as Gs, finalizeBestDelivered as Gt, FeedbackRating as Gu, SuperviseOptions as H, ResolvedMcpServerLaunch as Ha, RouterToolsSeam as Hc, buildSteerContext as Hi, DetachedWinnerSelection as Hl, StructuralRolloutConfig as Hn, Verify as Ho, StdioMcpServerSpec as Hr, AuditIntentInput as Hs, serveCoordinationMcp as Ht, DelegationStatus as Hu, jjWorkspace as I, defaultSelectWinner as Ia, CliSeam as Ic, InMemoryResultBlobStore as Id, selectValidWinner as Ii, eventToSnapshot as Il, CheckOutcome as In, ScopeWidenGate as Io, naiveDriver as Ir, leaderboard as Is, SupervisorAgentDeps as It, DelegationHistoryArgs as Iu, createScope as J, inlineSandboxClient as Ja, SandboxSteeringOptions as Jc, sanitizeMcpToolSchema as Ji, DelegationExecutor as Jl, compareCheckOutcomes as Jn, WinnerStrategy as Jo, OpenSandboxRunPromptOptions as Jr, AnytimeStrategySummary as Js, PlateauOptions as Jt, ResearchSource as Ju, workerFromBackend as K, resolveSecretEnv as Ka, createExecutorRegistry as Kc, McpEnvironmentOptions as Ki, detachedSessionDelegate as Kl, VisibleCheck as Kn, WidenLineage as Ko, OpenSandboxRunBeforeStartContext as Kr, defaultAuditorInstruction as Ks, AllWorkersStalledOptions as Kt, FeedbackRefersTo as Ku, localShell as L, runAgentRounds as La, CliWorktreeBridgeSeam as Lc, InMemorySpawnJournal as Ld, verify as Li, CoderDelegate as Ll, CheckRunContext as Ln, SteerContext as Lo, LocalMcpMaterialization as Lr, pairwiseSignificance as Ls, SupervisorProfile as Lt, DelegationHistoryEntry as Lu, Workspace as M, loopCampaignDispatch as Ma, DelegateResult as Mc, DeliverableSpec as Md, flatWidenGate as Mi, McpTransport as Ml, defaultProfileRichnessThresholds as Mn, RenderCorpusToInstructions as Mo, DumbDriverOptions as Mr, PairwiseOptions as Ms, delegate as Mt, DelegateUiAuditResult as Mu, WorkspaceCommit as N, loopDispatch as Na, createDelegateHandler as Nc, gateOnDeliverable as Nd, loopUntil as Ni, FeedbackEvent as Nl, profileRichnessFinding as Nn, RenderCorpusToInstructionsOptions as No, NaiveDriverOptions as Nr, PairwiseVerdict as Ns, CoordinationBinding as Nt, DelegateUiAuditRoute as Nu, copyUntrackedIntoClone as O, sampleThenRefine as Oa, DELEGATE_INPUT_SCHEMA as Oc, createEventBus as Od, FileCorpus as Oi, removeWorktree as Ol, ProfileRichnessThresholds as On, PanelSpec as Oo, assertStrategyContract as Or, Interval as Os, queueOf as Ot, DelegateResearchConfig as Ou, WorkspaceRun as P, RunAgentRoundsOptions as Pa, validateDelegateArgs as Pc, FileResultBlobStore as Pd, panel as Pi, FeedbackStore as Pl, supervisorInstructions as Pn, ScopeAnalyst as Po, SteeringDecision as Pr, ProfileKeyOf as Ps, DriveHarness as Pt, DelegationError as Pu, readWorkerSteerRequests as Q, inProcessSandboxClient as Qa, Inbox as Qc, BenchmarkReport as Qi, createFleetWorkspaceExecutor as Ql, filterAuthoredAsserts as Qn, Outcome as Qo, openSandboxRun as Qr, bestSoFar as Qs, ProgressView as Qt, DELEGATION_TRACE_MAX_BYTES as Qu, runInWorkspace as R, runLoop as Ra, CliWorktreeSeam as Rc, contentAddress as Rd, widen as Ri, CoderReview as Rl, CheckRunner as Rn, TrajectoryNode as Ro, MaterializeLocalMcpOptions as Rr, renderLeaderboardHtml as Rs, assertCoordinationBinding as Rt, DelegationHistoryResult as Ru, WorkerEvidenceInput as S, breadthStrategy as Sa, createCoordinationTools as Sc, CoderOutput as Sd, trajectoryReport as Si, DiffResult as Sl, ReservationRejection as Sn, FlatWidenGate as So, discriminatingMeans as Sr, completionAuthorizes as Ss, DispatchReport as St, DelegateCodeArgs as Su, settledWorkerOut as T, refine as Ta, createInProcessTransport as Tc, BusStats as Td, registerShape as Ti, WorktreeHandle as Tl, spendFromUsageEvents as Tn, LoopUntilState as To, selectChampion as Tr, stopSentinel as Ts, RollingDispatchOptions as Tt, DelegateFeedbackArgs as Tu, SuperviseRegistry as U, envKeyProvider as Ua, SandboxSeam as Uc, createScopeAnalyst as Ui, SettleDetachedCoderTurnOptions as Ul, StructuralRolloutMessage as Un, VerifySpec as Uo, connectStdioMcp as Ur, AuditIntentOptions as Us, DriverAgentOptions as Ut, DelegationStatusArgs as Uu, createSupervisor as V, KeyProvider as Va, RouterSeam as Vc, replaySpawnTree as Vd, assertTraceDerivedFindings as Vi, DetachedSessionDelegateOptions as Vl, RepairStop as Vn, TrajectoryReportOptions as Vo, StdioMcpConnection as Vr, renderPairwiseMarkdown as Vs, CoordinationMcpHandle as Vt, DelegationResultPayload as Vu, SuperviseRegistryTable as W, mcpSecretEnvMetadataKey as Wa, cliWorktreeExecutor as Wc, registryScopeAnalyst as Wi, UiAuditorDelegate as Wl, StructuralRolloutPolicy as Wn, Widen as Wo, materializeLocalMcp as Wr, IntentAudit as Ws, driverAgent as Wt, DelegationStatusResult as Wu, WorkerSteerRequest as X, InProcessPromptCtx as Xa, SteerableSandboxSession as Xc, BenchmarkConfig as Xi, FleetWorkspaceExecutorOptions as Xl, defaultExtractCandidate as Xn, DefinePersonaInput as Xo, SandboxRunAbortError as Xr, anytimeReport as Xs, ProgressTracker as Xt, UiAuditorDelegationOutput as Xu, settledToIteration as Y, InProcessOnPrompt as Ya, SteerableSandboxArgs as Yc, BenchmarkCell as Yi, FleetHandle as Yl, composeCheckSources as Yn, DefinePersona as Yo, SandboxRun as Yr, AnytimeTaskCurve as Ys, ProgressSample as Yt, UiAuditLensFilter as Yu, legacySupervisorRunDir as Z, InProcessSandboxClientOptions as Za, createSteerableSandboxSession as Zc, BenchmarkLift as Zi, SiblingSandboxExecutorOptions as Zl, defaultStructuralRolloutPolicy as Zn, LoopShape as Zo, TurnResult as Zr, areaUnderCurve as Zs, ProgressTrackerOptions as Zt, CappedDelegationTrace as Zu, WorktreeFanoutOptions as _, StrategyMessage as _a, QuestionPolicy as _c, JudgeError as _d, resolveSandboxClient as _i, WorktreeCommandResult as _l, CoordinationLog as _n, EqualKVerdict as _o, EvolutionCandidate as _r, defineLeaderboard as _s, SupervisorSpanOutcome as _t, DelegationTaskQueue as _u, SandboxInstance$1 as a, AgenticRunResult as aa, AnalystFindingEvent as ac, composeLoopTraceEmitters as ad, SandboxToolPartState as ai, piSeamKey as al, noProgressFor as an, ObserveOptions as ao, visibleCheckScore as ar, ShapeContext as as, InMemoryRunContext as at, RunDetachedTurnOptions as au, NOTE_MAX_CHARS as b, SurfaceScore as ba, SettledWorker as bc, RuntimeRunStateError as bd, promotionGate as bi, CreateWorktreeOptions as bl, BudgetPool as bn, FanoutSynthesis as bo, ReproductionCheck as br, CompletionPolicy as bs, assertModelAllowed as bt, SubmitOutput as bu, VerifierEnvironmentOptions as c, AgenticTool as ca, CoordinationTools as cc, DelegationStateCorruptError as cd, mapSandboxEvent as ci, PI_MCP_CONFIG_FLAG as cl, DeliveredOutput as cn, renderReport as co, CollectedAgentTurn as cr, LeaderboardBenchScore as cs, createFileRunContext as ct, formatDetachedSessionRef as cu, SuperviseSurfaceResult as d, RunAgenticOptions as da, DownMessageEvent as dc, FileDelegationStoreOptions as dd, CriuCapableClient as di, PiMcpPreparation as dl, SupervisorFinalizer as dn, Corpus as do, streamAgentTurn as dr, LeaderboardFlagSpec as ds, patchDelivered as dt, DelegationArgs as du, BenchmarkTaskRow as ea, renderAnytimeTable as ec, DelegationTraceCaps as ed, ForkCapableBox as ei, createInbox as el, StopRule as en, HarvestFailure as eo, officialChecksFromMeta as er, PersonaContext as es, supervisorRunDir as et, DetachedSessionRefParts as eu, SurfaceWorkerConfig as f, ShotPersona as fa, MakeWorkerAgent as fc, InMemoryDelegationStore as fd, SandboxCapabilities as fi, PiMcpReceipt as fl, bestDelivered as fn, CorpusFilter as fo, ChampionPick as fr, LeaderboardIterationInfo as fs, WorktreeCliExecutorOptions as ft, DelegationRecord as fu, AuthoredHarness as g, StrategyCtx as ga, QuestionOption as gc, ConfigError as gd, ResolveSandboxClientOptions as gi, WorktreeCheckRunner as gl, runTree as gn, EqualKOnCostOptions as go, EvolutionBandInfo as gr, LeaderboardSpec as gs, SupervisorSpanOptions as gt, DelegationRunContext as gu, superviseSurface as h, StrategyArtifacts as ha, QuestionLevel as hc, BackendTransportError as hd, acquireSandbox as hi, preparePiMcp as hl, runFinalizer as hn, EqualKOnCost as ho, EvolutionAuthor as hr, LeaderboardScore as hs, SupervisorSpanAttributes as ht, DelegationResumeTick as hu, SandboxEvent$1 as i, AgenticOptions as ia, createWaterfallCollector as ic, capDelegationTrace as id, createSandboxLineage as ii, piExecutor as il, createProgressTracker as in, ObserveInput as io, structuralRollout as ir, ShapeBudget as is, writeWorkerSteer as it, DriveTurnTick as iu, Shell as j, LoopOptionsForDispatch as ja, DelegateHandlerOptions as jc, watchTrace as jd, fanout as ji, McpToolDescriptor$1 as jl, authoredWorker as jn, PipelineStage as jo, ApplyContinuation as jr, LeaderboardRow as js, defaultDelegateBudget as jt, DelegateUiAuditConfig as ju, withUntrackedArtifacts as k, LoopCampaignDispatchOptions as ka, DELEGATE_TOOL_NAME as kc, WatchTraceOptions as kd, InMemoryCorpus as ki, JsonRpcMessage as kl, asAuthoredProfile as kn, PanelVerdict as ko, authorStrategy as kr, Leaderboard as ks, rollingDispatch as kt, DelegateResearchResult as ku, createVerifierEnvironment as l, ArtifactHandle as la, CoordinationToolsOptions as lc, DelegationStore as ld, mapSandboxToolEvent as li, PiMcpMount as ll, FinalizeContext as ln, AssertTraceDerivedFindings as lo, StreamAgentTurnOptions as lr, LeaderboardBenchTask as ls, createInMemoryRunContext as lt, parseDetachedSessionRef as lu, failuresAnalyst as m, Strategy as ma, QuestionDecision as mc, AgentEvalErrorCode as md, AcquireOptions as mi, piMcpAdapterAvailable as ml, pickBestDelivered as mn, EqualKArm as mo, EvolutionArchiveNode as mr, LeaderboardScenario as ms, createWorktreeCliExecutor as mt, DelegationResumeDriver as mu, AnalystFinding$1 as n, printBenchmarkReport as na, WaterfallReport as nc, DelegationTraceSpan as nd, SandboxLineageHandle as ni, PiExecutorOutput as nl, allWorkersStalled as nn, harvestCorpus as no, sandboxCheckRunner as nr, RunPersonified as ns, workerInboxFile as nt, DetachedTurnResumeDriverOptions as nu, computeFindingId$1 as o, AgenticSurface as oa, AnalystRegistry as oc, createDelegationTraceCollector as od, createSandboxToolPartState as oi, PI_MCP_ADAPTER as ol, plateau as on, defaultAnalystInstruction as oo, AgentTurnBackend as or, ShapeRegistry as os, InMemoryRunContextOptions as ot, createDetachedTurnResumeDriver as ou, SurfaceWorkerOut as p, ShotSpec as pa, Question as pc, AgentEvalError$1 as pd, probeSandboxCapabilities as pi, buildPiMcpServers as pl, collectDelivered as pn, CorpusRecord as po, ChampionPolicy as pr, LeaderboardRunContext as ps, WorktreePatchArtifact as pt, DelegationResumeContext as pu, ScopeArgs as q, secretEnvOfMcpServer as qa, DEFAULT_SANDBOX_STEERING_MAX_TURNS as qc, createMcpEnvironment as qi, settleDetachedCoderTurn as ql, canDisplace as qn, WidenSpec as qo, OpenSandboxRunOptions as qr, AnytimeReport as qs, NoProgressForOptions as qt, ResearchOutputShape as qu, CreateSandboxOptions$1 as r, runBenchmark as ra, WaterfallSpan as rc, buildDelegationTraceSpans as rd, SessionCapableBox as ri, PiSeam as rl, anyOf as rn, Observation as ro, selectBestIndex as rr, RunPersonifiedOptions as rs, workerInboxFileFromEventDir as rt, DriveTurnCapableBox as ru, makeFinding$1 as s, AgenticTask as sa, CoordinationEvent as sc, DelegationPersistenceError as sd, extractLlmCallEvent as si, PI_MCP_ADAPTER_ENV as sl, sampleFromSettled as sn, observe as so, AgentTurnUsage as sr, DefinedLeaderboard as ss, RunContext as st, detachedTurnEvents as su, AgentProfile$2 as t, Environment as ta, WaterfallCollector as tc, DelegationTraceCollector as td, SandboxLineage as ti, PI_RUNTIME as tl, allOf as tn, HarvestReport as to, resolveEntrySymbol as tr, PersonaExecutors as ts, supervisorRunsRoot as tt, DetachedTurn as tu, SuperviseSurfaceOptions as u, CorpusReadbackOptions as ua, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as uc, FileDelegationStore as ud, sumSandboxUsage as ui, PiMcpMountOptions as ul, FinalizerSettled as un, CombinatorShape as uo, collectAgentTurn as ur, LeaderboardBenchmarkAdapter as us, PatchDeliverableOptions as ut, runDetachedTurn as uu, worktreeFanout as v, StrategyResult as va, QuestionRecord as vc, NotFoundError as vd, PromotionGateOptions as vi, WorktreeHarnessResult as vl, FileCoordinationLog as vn, Fanout as vo, EvolutionGeneration as vr, CompletionAnalyst as vs, SupervisorSpanRecorder as vt, DelegationTaskQueueOptions as vu, composeWorkerEvidence as w, depthStrategy as wa, McpServerOptions as wc, BusRecord as wd, createShapeRegistry as wi, RemoveWorktreeOptions as wl, createBudgetPool as wn, LoopUntilSpec as wo, runStrategyEvolution as wr, sentinelCompletion as ws, DispatchUnit as wt, DelegateCodeResult as wu, VERIFY_TAIL_CHARS as x, adaptiveRefine as xa, WorkerWatchOptions as xc, ValidationError as xd, equalKOnCost as xi, DiffOptions as xl, BudgetReadout as xn, FanoutWinnerSelector as xo, StrategyEvolutionConfig as xr, CompletionVerdict as xs, ConcurrencyCaps as xt, hashIdempotencyInput as xu, EVIDENCE_MAX_CHARS as y, StrategyShotResult as ya, QuestionUrgency as yc, PlannerError as yd, PromotionVerdict as yi, WorktreeProfileMaterializationReceipt as yl, PriorCoordination as yn, FanoutOptions as yo, EvolutionReport as yr, CompletionEvidence as ys, createSupervisorSpanRecorder as yt, SubmitInput as yu, TrajectoryAnalysis as z, LocalSandboxClientOptions as za, ExecutorConfig as zc, materializeTreeView as zd, CreateScopeAnalystOptions as zi, CoderReviewer as zl, CheckSource as zn, TrajectoryReport as zo, McpSpawnFault as zr, renderLeaderboardMarkdown as zs, resolveSupervisorProfile as zt, DelegationProfile as zu };
-//# sourceMappingURL=index-COumPQka.d.ts.map
+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