@tangle-network/agent-runtime 0.115.1 → 0.117.0

package/dist/{index-BUWd8QJq.d.ts → index-DPWJxSRa.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, Bt as ExecutorProgress, H as ExecutorFactory, Ht as WorkerProgress, I as Agent, L as AgentSpec, Nt as TraceSource, 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, it as Settled, mt as TreeView, nt as Runtime, o as AgentEnvironmentProviderRegistry, ot as SpawnJournal, q as NodeId, rt as Scope, st as SpawnOpts, ut as Spend, vt as PendingWait, w as ProviderExecutorOptions, xt as WaitProbeRegistry, z as DefaultVerdict } from "./environment-provider-Cygthiy3.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-CTZjdIUg.js";
 import { o as UiLens, r as UiFinding, s as CoderTask } from "./substrate-BcnuSHXm.js";
-import { O as RuntimeTelemetryOptions, 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-BnB1E9nM.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 { 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, 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;
@@ -476,223 +628,6 @@ declare function createDelegationTraceCollector(onSpans: (spans: DelegationTrace
  */
 declare function composeLoopTraceEmitters(...emitters: ReadonlyArray<LoopTraceEmitter | undefined>): LoopTraceEmitter | undefined;
 //#endregion
-//#region src/otel-export.d.ts
-interface OtelExportConfig {
-  /** OTLP endpoint. Reads OTEL_EXPORTER_OTLP_ENDPOINT env by default. */
-  endpoint?: string;
-  /** OTLP headers. Reads OTEL_EXPORTER_OTLP_HEADERS env by default. */
-  headers?: Record<string, string>;
-  /** Batch size before flush. Default 64. */
-  batchSize?: number;
-  /** Flush interval ms. Default 5000. */
-  flushIntervalMs?: number;
-  /** Resource attributes stamped on every export. */
-  resourceAttributes?: Record<string, string | number | boolean>;
-  /** Service name. Default 'agent-runtime'. */
-  serviceName?: string;
-}
-interface OtelExporter {
-  /** Export a span. */
-  exportSpan(span: OtelSpan): void;
-  /** Force flush pending spans. */
-  flush(): Promise<void>;
-  /** Shutdown cleanly. */
-  shutdown(): Promise<void>;
-}
-interface OtelSpan {
-  traceId: string;
-  spanId: string;
-  parentSpanId?: string;
-  name: string;
-  kind?: number;
-  startTimeUnixNano: string;
-  endTimeUnixNano: string;
-  attributes?: OtelAttribute[];
-  status?: {
-    code: number;
-    message?: string;
-  };
-}
-interface OtelAttribute {
-  key: string;
-  value: {
-    stringValue?: string;
-    intValue?: string;
-    doubleValue?: number;
-    boolValue?: boolean;
-  };
-}
-/**
- * Create an OTEL exporter. Returns undefined when no endpoint is configured.
- */
-declare function createOtelExporter(config?: OtelExportConfig): OtelExporter | undefined;
-/**
- * Convert a LoopTraceEvent into an OtelSpan for export.
- */
-declare function loopEventToOtelSpan(event: {
-  kind: string;
-  runId: string;
-  timestamp: number;
-  payload: object;
-}, traceId: string, parentSpanId?: string): OtelSpan;
-interface RuntimeEventOtelOptions extends RuntimeTelemetryOptions {
-  /** Final customer redactor applied after the schema-aware runtime sanitizer. */
-  redact?: (value: unknown) => unknown;
-}
-/** Convert normalized runtime events into lossless, redacted child spans. */
-declare function buildRuntimeEventOtelSpans(events: ReadonlyArray<RuntimeStreamEvent>, traceId: string, parentSpanId?: string, options?: RuntimeEventOtelOptions): OtelSpan[];
-/**
- * Sink-neutral node in a reconstructed loop span tree. The root node's
- * `parentSpanId` is `undefined` — sinks decide how to parent it (the OTEL
- * mapper attaches the inherited delegation span; the delegation journal
- * leaves it as the tree root).
- */
-interface LoopSpanNode {
-  spanId: string;
-  parentSpanId?: string;
-  /** `'loop'` | `'loop.round'` | `'loop.iteration'`. */
-  name: string;
-  /** Topology level: loop root, plan round, or iteration branch. */
-  kind: 'loop' | 'round' | 'branch';
-  startMs: number;
-  endMs: number;
-  attrs: Record<string, string | number | boolean>;
-  /** True when the iteration carried an error — maps to OTEL status code 2. */
-  error: boolean;
-}
-/**
- * Build a nested, real-duration OTLP span tree for ONE loop run from its full
- * ordered `LoopTraceEvent` stream. Unlike `loopEventToOtelSpan` (one flat,
- * zero-duration span per event), this reconstructs the topology hierarchy a
- * GenAI trace viewer renders natively:
- *
- *   loop (invoke_workflow)
- *     └─ loop.round[k] (invoke_workflow)   ← tangle.loop.move.{kind,width,rationale}
- *          ├─ loop.iteration[i] (invoke_agent)  ← gen_ai.agent.name + usage + verdict + placement
- *          └─ …
- *
- * Attributes follow the current GenAI semconv (`gen_ai.*`) where they apply and
- * a namespaced `tangle.loop.*` / `tangle.cost.usd` extension for topology /
- * verdict / placement / cost (not yet standardized). Pure: feed it a buffered
- * per-runId event array (e.g. flushed on `loop.ended`) and export the result.
- */
-declare function buildLoopOtelSpans(events: ReadonlyArray<{
-  kind: string;
-  runId: string;
-  timestamp: number;
-  payload: object;
-}>, traceId: string, rootParentSpanId?: string): OtelSpan[];
-/**
- * Sink-neutral core behind {@link buildLoopOtelSpans}: reconstruct the
- * loop → round → branch span tree from one run's ordered `LoopTraceEvent`
- * stream. Consumed by the OTEL mapper above and by the MCP delegation
- * journal's compact trace tee — one topology reconstruction, two sinks.
- * Tolerates partial streams (a run that never reached `loop.ended` closes
- * at the last observed event's timestamp).
- */
-declare function buildLoopSpanNodes(events: ReadonlyArray<{
-  kind: string;
-  runId: string;
-  timestamp: number;
-  payload: object;
-}>): LoopSpanNode[];
-/**
- * Convert a flat record into the OTLP attribute list. Non-finite numbers are DROPPED (an OTLP
- * `doubleValue` of `NaN`/`Infinity` is not representable), integers ride as `intValue`. Exported so
- * a producer that mints its own `OtelSpan` (the supervisor span recorder) builds attributes exactly
- * the way every span in this file does, rather than re-deriving the encoding.
- */
-declare function toOtelAttributes(record: Record<string, string | number | boolean>): OtelAttribute[];
-/** Mint a fresh 16-hex-character OTLP span id. Exported so a producer that must know a span's id
- *  BEFORE the span closes (a node opened at spawn and parented by its children) uses this one
- *  generator instead of a second copy of it. */
-declare function generateSpanId(): string;
-/** Wire version the eval-runs ingest enforces (X-Tangle-Wire-Version + body). */
-declare const INTELLIGENCE_WIRE_VERSION = "2026-05-26.v1";
-interface EvalRunGeneration {
-  /** 0-based ordinal of this generation within the run (required by ingest). */
-  index: number;
-  /** Identity of the proposed surface change (content-addressed hash). */
-  surfaceHash: string;
-  /** Arbitrary provenance for this generation (rationale, evidence, source). */
-  surface?: unknown;
-  /** Per-scenario results; empty until the generation is measured. */
-  cells?: unknown[];
-  /** Mean composite score (0 when unmeasured — pair with labels.measured). */
-  compositeMean: number;
-  costUsd: number;
-  durationMs: number;
-}
-interface EvalRunEvent {
-  runId: string;
-  runDir: string;
-  /** ISO timestamp. */
-  timestamp: string;
-  status: 'started' | 'baseline-complete' | 'generation-complete' | 'gate-decided' | 'finished' | 'errored';
-  labels?: Record<string, string>;
-  baseline?: EvalRunGeneration;
-  generations?: EvalRunGeneration[];
-  gateDecision?: 'ship' | 'hold' | 'need_more_work' | 'model_ceiling' | 'arch_ceiling';
-  holdoutLift?: number;
-  totalCostUsd: number;
-  totalDurationMs: number;
-  errorMessage?: string;
-}
-interface EvalRunsExportConfig {
-  /** Bearer key — tenant is resolved server-side from it. Reads TANGLE_API_KEY. */
-  apiKey?: string;
-  /** Intelligence base. Reads TANGLE_INTELLIGENCE_URL env, else prod. */
-  base?: string;
-  /** Idempotency-Key header (e.g. the runId) — safe retries + upsert. */
-  idempotencyKey?: string;
-}
-interface EvalRunsExportResult {
-  ok: boolean;
-  status: number;
-  accepted: number;
-  rejected: Array<{
-    index: number;
-    reason: string;
-  }>;
-}
-/**
- * Ship self-improvement eval-run events to Tangle Intelligence. Unlike the
- * best-effort span exporter, this RESOLVES with the ingest verdict (accepted /
- * rejected per event) so a consumer's loop can assert its provenance landed.
- * Throws only on a missing key or network failure.
- */
-declare function exportEvalRuns(events: EvalRunEvent[], config?: EvalRunsExportConfig): Promise<EvalRunsExportResult>;
-//#endregion
-//#region src/mcp/trace-propagation.d.ts
-interface TraceContext {
-  /** Trace id inherited from the parent process, or a fresh one. */
-  traceId: string;
-  /** Parent span id from the delegation that launched this MCP server. */
-  parentSpanId?: string;
-}
-/**
- * Read trace context from the process environment.
- * Returns a context with inherited ids or a freshly generated root.
- */
-declare function readTraceContextFromEnv(): TraceContext;
-/**
- * Create a LoopTraceEmitter that:
- *   1. Parents all spans under the inherited PARENT_SPAN_ID.
- *   2. Exports spans to OTEL when OTEL_EXPORTER_OTLP_ENDPOINT is set.
- *
- * Returns both the emitter and the optional exporter handle for shutdown.
- */
-declare function createPropagatingTraceEmitter(ctx: TraceContext): {
-  emitter: LoopTraceEmitter;
-  exporter: OtelExporter | undefined;
-  context: TraceContext;
-};
-/**
- * Build env vars to pass to a child MCP subprocess so it inherits the
- * current trace context.
- */
-declare function traceContextToEnv(ctx: TraceContext): Record<string, string>;
-//#endregion
 //#region src/mcp/types.d.ts
 /** @experimental */
 type DelegationProfile = 'coder' | 'researcher' | 'ui-auditor';
@@ -2123,7 +2058,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
  */
@@ -2136,8 +2072,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;
@@ -2186,6 +2123,12 @@ interface SteerableSandboxArgs {
   readonly taskToPrompt: (task: unknown) => string;
   readonly options?: SandboxSteeringOptions;
   readonly loopCtx?: Partial<Omit<ExecCtx, 'sandboxClient' | 'signal'>>;
+  /**
+   * Inherited `TRACE_ID` / `PARENT_SPAN_ID` for the box, merged into `CreateSandboxOptions.env` so
+   * the remote worker's own spans join the supervisor's trace under the spawning node's span.
+   * Absent when the run records no spans — the create options are then untouched.
+   */
+  readonly traceEnv?: Record<string, string>;
   readonly contentRef: (prefix: string, value: unknown) => string;
   readonly now?: () => number;
 }
@@ -2244,7 +2187,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`.
  */
@@ -2252,7 +2197,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;
@@ -2278,7 +2223,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;
@@ -2292,19 +2238,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. */
@@ -2319,6 +2266,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
@@ -2398,8 +2352,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;
@@ -2447,8 +2401,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). */
@@ -2547,13 +2509,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';
@@ -2595,7 +2570,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 {
@@ -2603,16 +2578,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;
@@ -2629,8 +2651,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;
@@ -2643,7 +2691,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
@@ -2654,7 +2709,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.
@@ -2714,6 +2770,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. */
@@ -2722,9 +2780,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;
@@ -6222,24 +6280,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;
@@ -6313,6 +6387,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<{
@@ -6323,16 +6398,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
@@ -6381,31 +6472,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
@@ -6636,6 +6748,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
@@ -6661,6 +6774,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
@@ -6708,18 +6824,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
@@ -6753,7 +6875,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'];
@@ -6768,6 +6890,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>;
@@ -6794,188 +6917,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,
@@ -7005,7 +6959,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;
@@ -7121,6 +7078,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
@@ -7172,6 +7132,15 @@ interface SupervisorSpanRecorder {
   readonly traceId: string;
   /** The run's root span id — pass it to a child process to join this trace. */
   readonly rootSpanId: string;
+  /**
+   * The trace context a worker spawned BY node `spawningNodeId` should inherit, so its own spans
+   * join THIS trace under the span of the node that spawned it. Thread it to a run as
+   * `SupervisorOpts.workerTrace` (`supervise()` does this whenever it builds a recorder) and the
+   * `Scope` seeds it onto every child's `ExecutorContext`; a backend with an environment channel
+   * stamps it with `workerTraceEnv`. An unknown node — one whose span was never opened — resolves
+   * to the run's root span rather than to nothing, so a worker is never filed outside its own run.
+   */
+  readonly workerTrace: WorkerTraceResolver;
   /**
    * Close the root span (and any node that never settled, marked as such), export, and flush. Safe
    * to call twice; never throws — a telemetry failure is not a run failure.
@@ -7205,16 +7174,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`). */
@@ -7251,13 +7220,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
  */
@@ -7309,10 +7281,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;
 }
@@ -7332,8 +7305,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.
@@ -7424,7 +7398,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;
@@ -7443,6 +7417,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. */
@@ -7451,6 +7430,24 @@ interface ScopeArgs {
    *  SAME stream `runAgentRounds`/`tool-loop` feed, so the recursive tree is ONE observable stream
    *  (the topology viewer reads it). Undefined ⇒ the journal stays the only record. */
   readonly hooks?: RuntimeHooks;
+  /**
+   * Trace context to hand down to each spawned worker (`SupervisorOpts.workerTrace`). Called with
+   * THIS scope's own `parentId` — the node doing the spawning — and the resolved context is seeded
+   * onto each child's `ExecutorContext` under `workerTraceSeamKey`. Absent (the untraced default)
+   * ⇒ no seam is seeded and no worker environment is touched.
+   */
+  readonly workerTrace?: WorkerTraceResolver;
+  /** @internal Trusted root-adapter publication channel. It is never exposed as a Scope method. */
+  readonly ownerMaterialization?: {
+    readonly runtime: NodeSnapshot['runtime'];
+    readonly authoredProfile?: unknown;
+    readonly attemptId: string;
+    readonly prior?: ProfileMaterializationReceipt;
+    readonly journalRoot?: NodeId;
+    readonly nodeId?: NodeId;
+    readonly requiredKnown?: boolean;
+    readonly onReceipt?: (materialization: ProfileMaterializationReceipt, binding: ExecutionBindingReceipt) => void;
+  };
   /**
    * Resume seam — set ONLY by the supervisor when `SupervisorOpts.resume` is on AND a non-empty
    * journal tree exists for this root. It carries the replayed committed work (so `scope.resume`
@@ -7478,6 +7475,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>;
 /**
@@ -7493,11 +7495,266 @@ 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
- *  deliverable check that makes "settled ⟺ delivered" true — the guard against "ran but didn't
- *  deliver"). The ONE place a backend becomes a spawnable worker. */
-declare function workerFromBackend(backend: ExecutorConfig, deliverable?: DeliverableSpec<unknown>): MakeWorkerAgent;
+/**
+ * Build the worker seam from a backend (WHERE workers run) + an optional completion oracle (the
+ * deliverable check that makes "settled ⟺ delivered" true — the guard against "ran but didn't
+ * deliver"). The ONE place a backend becomes a spawnable worker.
+ *
+ * `seams` exists because this path builds the leaf executor EAGERLY and hands it back as a BYO
+ * `executorSpec.executor`. The registry resolves a BYO executor without ever consulting the
+ * per-child `ExecutorContext` the `Scope` seeds, so anything the scope would have supplied is
+ * invisible here and has to be passed in. It is a FUNCTION because it is resolved once per worker
+ * construction, so a caller may hand back something the run only learns later — which is exactly how
+ * `supervise()` gives a traced run's workers their trace context without ordering the span recorder
+ * ahead of the worker seam.
+ */
+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. */
@@ -7522,6 +7779,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
@@ -7529,6 +7795,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;
@@ -7536,17 +7806,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;
@@ -7556,9 +7885,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
@@ -7587,17 +7916,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`.
@@ -7662,12 +7997,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 {
@@ -7835,6 +8215,13 @@ interface AuthoredHarness {
   profile: AgentProfile$1;
   /** Which local harness CLI drives this leaf. */
   harness: 'claude' | 'codex' | 'opencode';
+  /** 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;
@@ -7951,5 +8338,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, defaultToolDetectors as $d, BenchmarkStrategySummary as $i, createSiblingSandboxExecutor as $l, modelAuthoredChecks as $n, Persona as $o, CheckpointCapableBox as $r, plateauLength as $s, StopDecision as $t, readTraceContextFromEnv as $u, GitWorkspaceOptions as A, LoopDispatchOptions as Aa, DelegateArgs as Ac, DelegationPersistenceError 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, JudgeError 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, DelegationTraceCaps 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, capDelegationTrace 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, buildDelegationTraceSpans 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, InMemoryDelegationStore 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, CoderOutput as Gd, 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, PlannerError as Hd, 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, AgentEvalError$1 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, BusStats as Jd, 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, BusEvent as Kd, 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, AgentEvalErrorCode 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, DelegationStore 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, FileDelegationStore 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, composeLoopTraceEmitters 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, FileDelegationStoreOptions 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, WatchTraceOptions as Qd, BenchmarkReport as Qi, createFleetWorkspaceExecutor as Ql, filterAuthoredAsserts as Qn, Outcome as Qo, openSandboxRun as Qr, bestSoFar as Qs, ProgressView as Qt, createPropagatingTraceEmitter as Qu, runInWorkspace as R, runLoop as Ra, CliWorktreeSeam as Rc, BackendTransportError 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, DELEGATION_TRACE_MAX_SPANS 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, DelegationTraceSpan 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, RuntimeRunStateError as Ud, 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, NotFoundError 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, ValidationError as Wd, 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, PublishOptions as Xd, 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, EventBus as Yd, 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, createEventBus as Zd, BenchmarkLift as Zi, SiblingSandboxExecutorOptions as Zl, defaultStructuralRolloutPolicy as Zn, LoopShape as Zo, TurnResult as Zr, areaUnderCurve as Zs, ProgressTrackerOptions as Zt, TraceContext as Zu, WorktreeFanoutOptions as _, StrategyMessage as _a, QuestionPolicy as _c, generateSpanId 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, INTELLIGENCE_WIRE_VERSION as ad, InMemoryResultBlobStore as af, 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, CappedDelegationTrace 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, OtelExportConfig as cd, materializeTreeView as cf, 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, RuntimeEventOtelOptions 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, traceContextToEnv as ed, watchTrace as ef, 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, buildLoopOtelSpans 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, exportEvalRuns 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, createOtelExporter 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, EvalRunsExportResult as id, FileSpawnJournal as if, 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, DelegationStateCorruptError 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, createDelegationTraceCollector 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, OtelExporter as ld, pendingWaits as lf, 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, buildRuntimeEventOtelSpans 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, EvalRunGeneration as nd, gateOnDeliverable as nf, 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, LoopSpanNode as od, InMemorySpawnJournal as of, 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, buildLoopSpanNodes 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, BusRecord as qd, 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, EvalRunsExportConfig as rd, FileResultBlobStore as rf, 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, OtelAttribute as sd, contentAddress as sf, 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, EvalRunEvent as td, DeliverableSpec as tf, 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, OtelSpan as ud, replaySpawnTree as uf, 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, loopEventToOtelSpan 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, DelegationTraceCollector 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, DELEGATION_TRACE_MAX_BYTES 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, toOtelAttributes 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, ConfigError 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-BUWd8QJq.d.ts.map
+export { SuperviseRegistry as $, LoopDispatchOptions as $a, McpServer as $c, CoderOutput as $d, renderCorpusToInstructions as $i, DiffResult as $l, authoredWorker as $n, Pipeline as $o, strategyAuthorContract as $r, LeaderboardOptions as $s, effectiveConcurrency as $t, DelegateCodeArgs as $u, GitWorkspaceOptions as A, AgenticTask as Aa, AuthorizeDownMessage as Ac, DELEGATION_TRACE_MAX_SPANS as Ad, DefineProfileMaterializationContractOptions as Af, extractLlmCallEvent as Ai, InboxMessage as Al, SupervisorFinalizer as An, observe as Ao, AgentTurnUsage as Ar, DefinedLeaderboard as As, writeWorkerSteer as At, createSiblingSandboxExecutor as Au, analyzeTrace as B, StrategyMessage as Ba, DownMessageEvent as Bc, DelegationStore as Bd, promptControlProfileMaterialization as Bf, resolveSandboxClient as Bi, PiMcpMount as Bl, PriorCoordination as Bn, EqualKVerdict as Bo, EvolutionCandidate as Br, defineLeaderboard as Bs, createWorktreeCliExecutor as Bt, parseDetachedSessionRef as Bu, closingWorkerNote as C, BenchmarkTaskRow as Ca, renderAnytimeTable as Cc, FeedbackRefersTo as Cd, pendingWaits as Cf, ForkCapableBox as Ci, createExecutorRegistry as Cl, createProgressTracker as Cn, HarvestFailure as Co, officialChecksFromMeta as Cr, PersonaContext as Cs, legacySupervisorRunDir as Ct, detachedSessionDelegate as Cu, UntrackedCopyStats as D, AgenticOptions as Da, createWaterfallCollector as Dc, UiAuditorDelegationOutput as Dd, AgentProfileMaterializationAxis as Df, createSandboxLineage as Di, SteerableSandboxSession as Dl, DeliveredOutput as Dn, ObserveInput as Do, structuralRollout as Dr, ShapeBudget as Ds, supervisorRunsRoot as Dt, FleetWorkspaceExecutorOptions as Du, CopyOptions as E, runBenchmark as Ea, WaterfallSpan as Ec, UiAuditLensFilter as Ed, AGENT_PROFILE_MATERIALIZATION_AXES as Ef, SessionCapableBox as Ei, SteerableSandboxArgs as El, sampleFromSettled as En, Observation as Eo, selectBestIndex as Er, RunPersonifiedOptions as Es, supervisorRunDir as Et, FleetHandle as Eu, gitWorkspace as F, ShotPersona as Fa, CoordinationToolsOptions as Fc, capDelegationTrace as Fd, assertProfileMaterialization as Ff, SandboxCapabilities as Fi, piExecutor as Fl, runTree as Fn, CorpusFilter as Fo, ChampionPick as Fr, LeaderboardIterationInfo as Fs, createInMemoryRunContext as Ft, DriveTurnTick as Fu, workerTraceAnalysisStore as G, breadthStrategy as Ga, QuestionOption as Gc, AgentEvalErrorCode as Gd, sandboxActProfileMaterialization as Gf, trajectoryReport as Gi, piMcpAdapterAvailable as Gl, ReservationTicket as Gn, FlatWidenGate as Go, discriminatingMeans as Gr, completionAuthorizes as Gs, createSupervisorSpanRecorder as Gt, DelegationResumeDriver as Gu, WorkerToolTraceArtifact as H, StrategyShotResult as Ha, Question as Hc, FileDelegationStoreOptions as Hd, promptOnlyProfileMaterialization as Hf, PromotionVerdict as Hi, PiMcpPreparation as Hl, BudgetPoolRestore as Hn, FanoutOptions as Ho, EvolutionReport as Hr, CompletionEvidence as Hs, SupervisorSpanOptions as Ht, DelegationArgs as Hu, jjWorkspace as I, ShotSpec as Ia, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as Ic, composeLoopTraceEmitters as Id, controlProfileMaterialization as If, probeSandboxCapabilities as Ii, piSeamKey as Il, CoordinationDeliveryEvidence as In, CorpusRecord as Io, ChampionPolicy as Ir, LeaderboardRunContext as Is, PatchDeliverableOptions as It, RunDetachedTurnOptions as Iu, AuthorizedSpawn as J, refine as Ja, QuestionUrgency as Jc, JudgeError as Jd, registerShape as Ji, WorktreeCommandResult as Jl, AuthoredProfile as Jn, LoopUntilState as Jo, selectChampion as Jr, stopSentinel as Js, ConcurrencyCaps as Jt, DelegationTaskQueue as Ju, createRootHandle as K, defineStrategy as Ka, QuestionPolicy as Kc, BackendTransportError as Kd, validateProfileMaterialization as Kf, builtinShapes as Ki, preparePiMcp as Kl, createBudgetPool as Kn, LoopUntil as Ko, pickChampion as Kr, deterministicCompletion as Ks, assertModelAllowed as Kt, DelegationResumeTick as Ku, localShell as L, Strategy as La, DownMessageAuthorizationInput as Lc, createDelegationTraceCollector as Ld, defineProfileMaterializationContract as Lf, AcquireOptions as Li, PI_MCP_ADAPTER as Ll, CoordinationLog as Ln, EqualKArm as Lo, EvolutionArchiveNode as Lr, LeaderboardScenario as Ls, patchDelivered as Lt, createDetachedTurnResumeDriver as Lu, Workspace as M, ArtifactHandle as Ma, ContinuationInstruction as Mc, DelegationTraceCollector as Md, ProfileMaterializationContract as Mf, mapSandboxToolEvent as Mi, PI_RUNTIME as Ml, collectDelivered as Mn, AssertTraceDerivedFindings as Mo, StreamAgentTurnOptions as Mr, LeaderboardBenchTask as Ms, InMemoryRunContextOptions as Mt, DetachedTurn as Mu, WorkspaceCommit as N, CorpusReadbackOptions as Na, CoordinationEvent as Nc, DelegationTraceSpan as Nd, ProfileMaterializationIssue as Nf, sumSandboxUsage as Ni, PiExecutorOutput as Nl, pickBestDelivered as Nn, CombinatorShape as No, collectAgentTurn as Nr, LeaderboardBenchmarkAdapter as Ns, RunContext as Nt, DetachedTurnResumeDriverOptions as Nu, copyUntrackedIntoClone as O, AgenticRunResult as Oa, AnalystFindingEvent as Oc, CappedDelegationTrace as Od, AssertProfileMaterializationOptions as Of, SandboxToolPartState as Oi, createSteerableSandboxSession as Ol, FinalizeContext as On, ObserveOptions as Oo, visibleCheckScore as Or, ShapeContext as Os, workerInboxFile as Ot, SiblingSandboxExecutorOptions as Ou, WorkspaceRun as P, RunAgenticOptions as Pa, CoordinationTools as Pc, buildDelegationTraceSpans as Pd, ValidateProfileMaterializationOptions as Pf, CriuCapableClient as Pi, PiSeam as Pl, runFinalizer as Pn, Corpus as Po, streamAgentTurn as Pr, LeaderboardFlagSpec as Ps, createFileRunContext as Pt, DriveTurnCapableBox as Pu, SuperviseOptions as Q, LoopCampaignDispatchOptions as Qa, createCoordinationTools as Qc, ValidationError as Qd, InMemoryCorpus as Qi, DiffOptions as Ql, assessAuthoredProfile as Qn, PanelVerdict as Qo, authorStrategy as Qr, Leaderboard as Qs, RollingDispatchOptions as Qt, hashIdempotencyInput as Qu, runInWorkspace as R, StrategyArtifacts as Ra, DownMessageDeliveryAttempt as Rc, DelegationPersistenceError as Rd, fullProfileMaterialization as Rf, acquireSandbox as Ri, PI_MCP_ADAPTER_ENV as Rl, CoordinationOwnerId as Rn, EqualKOnCost as Ro, EvolutionAuthor as Rr, LeaderboardScore as Rs, WorktreeCliExecutorOptions as Rt, detachedTurnEvents as Ru, WorkerEvidenceInput as S, BenchmarkStrategySummary as Sa, plateauLength as Sc, FeedbackRating as Sd, materializeTreeView as Sf, CheckpointCapableBox as Si, createExecutor as Sl, anyOf as Sn, HarvestCorpusOptions as So, modelAuthoredChecks as Sr, Persona as Ss, WorkerSteerRequest as St, coderTaskFromArgs as Su, settledWorkerOut as T, printBenchmarkReport as Ta, WaterfallReport as Tc, ResearchSource as Td, contentAddress as Tf, SandboxLineageHandle as Ti, SandboxSteeringOptions as Tl, plateau as Tn, harvestCorpus as To, sandboxCheckRunner as Tr, RunPersonified as Ts, safeWorkerFile as Tt, DelegationExecutor as Tu, captureWorkerTraceEvidence as U, SurfaceScore as Ua, QuestionDecision as Uc, InMemoryDelegationStore as Ud, promptResourceProfileMaterialization as Uf, promotionGate as Ui, PiMcpReceipt as Ul, BudgetReadout as Un, FanoutSynthesis as Uo, ReproductionCheck as Ur, CompletionPolicy as Us, SupervisorSpanOutcome as Ut, DelegationRecord as Uu, WORKER_TOOL_TRACE_SCHEMA_VERSION as V, StrategyResult as Va, MakeWorkerAgent as Vc, FileDelegationStore as Vd, promptModelProfileMaterialization as Vf, PromotionGateOptions as Vi, PiMcpMountOptions as Vl, BudgetPool as Vn, Fanout as Vo, EvolutionGeneration as Vr, CompletionAnalyst as Vs, SupervisorSpanAttributes as Vt, runDetachedTurn as Vu, parseWorkerToolTraceArtifact as W, adaptiveRefine as Wa, QuestionLevel as Wc, AgentEvalError$1 as Wd, renderProfileMaterializationIssues as Wf, equalKOnCost as Wi, buildPiMcpServers as Wl, ReservationRejection as Wn, FanoutWinnerSelector as Wo, StrategyEvolutionConfig as Wr, CompletionVerdict as Ws, SupervisorSpanRecorder as Wt, DelegationResumeContext as Wu, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as X, sample as Xa, WorkerSpawnContext as Xc, PlannerError as Xd, runPersonified as Xi, WorktreeProfileMaterializationReceipt as Xl, ProfileRichnessThresholds as Xn, PanelJudge as Xo, AuthoredStrategy as Xr, GroupOf as Xs, DispatchStopReason as Xt, SubmitInput as Xu, AuthorizedSpawnContext as Y, runAgentic as Ya, SettledWorker as Yc, NotFoundError as Yd, definePersona as Yi, WorktreeHarnessResult as Yl, ProfileRichness as Yn, Panel as Yo, AuthorStrategyOptions as Yr, AxisScoresOf as Ys, DispatchReport as Yt, DelegationTaskQueueOptions as Yu, DeliverableResolutionInput as Z, sampleThenRefine as Za, WorkerWatchOptions as Zc, RuntimeRunStateError as Zd, FileCorpus as Zi, CreateWorktreeOptions as Zl, asAuthoredProfile as Zn, PanelSpec as Zo, assertStrategyContract as Zr, Interval as Zs, DispatchUnit as Zt, SubmitOutput as Zu, WorktreeFanoutOptions as _, sanitizeMcpToolSchema as _a, AnytimeStrategySummary as _c, DelegationProgress as _d, SpawnForestInDoubtNode as _f, OpenSandboxRunPromptOptions as _i, ProviderSeam as _l, ProgressView as _n, inlineSandboxClient as _o, compareCheckOutcomes as _r, WinnerStrategy as _s, resolveSupervisorProfile as _t, DelegateRunCtx as _u, SandboxInstance$1 as a, selectValidWinner as aa, leaderboard as ac, DelegateResearchConfig as ad, createEventBus as af, naiveDriver as ai, DELEGATE_TOOL_NAME as al, delegate as an, defaultSelectWinner as ao, CheckOutcome as ar, ScopeWidenGate as as, DriveHarnessOwnerContext as at, removeWorktree as au, NOTE_MAX_CHARS as b, BenchmarkLift as ba, areaUnderCurve as bc, DelegationStatusArgs as bd, SpawnForestTree as bf, TurnResult as bi, SandboxSeam as bl, allOf as bn, InProcessSandboxClientOptions as bo, defaultStructuralRolloutPolicy as br, LoopShape as bs, createScope as bt, SettleDetachedCoderTurnOptions as bu, VerifierEnvironmentOptions as c, CreateScopeAnalystOptions as ca, renderLeaderboardMarkdown as cc, DelegateUiAuditConfig as cd, watchTrace as cf, McpSpawnFault as ci, DelegateHandlerOptions as cl, DriverAgentOptions as cn, LocalSandboxClientOptions as co, CheckSource as cr, TrajectoryReport as cs, ResolveSupervisorTools as ct, McpToolDescriptor$1 as cu, SuperviseSurfaceResult as d, buildSteerContext as da, AuditIntentInput as dc, DelegationError as dd, FileResultBlobStore as df, StdioMcpServerSpec as di, validateDelegateArgs as dl, AllWorkersStalledOptions as dn, ResolvedMcpServerLaunch as do, StructuralRolloutConfig as dr, Verify as ds, SupervisorNodeContext as dt, FeedbackStore as du, fanout as ea, LeaderboardRow as ec, DelegateCodeConfig as ed, BusEvent as ef, ApplyContinuation as ei, McpServerOptions as el, freeSlots as en, LoopOptionsForDispatch as eo, canonicalizeAuthoredProfile as er, PipelineStage as es, SuperviseRegistryTable as et, GitRunner as eu, SurfaceWorkerConfig as f, createScopeAnalyst as fa, AuditIntentOptions as fc, DelegationFeedbackSnapshot as fd, FileSpawnJournal as ff, connectStdioMcp as fi, BridgeSeam as fl, NoProgressForOptions as fn, envKeyProvider as fo, StructuralRolloutMessage as fr, VerifySpec as fs, SupervisorNodeContextSeed as ft, InMemoryFeedbackStore as fu, AuthoredHarness as g, createMcpEnvironment as ga, AnytimeReport as gc, DelegationProfile as gd, SpawnForestEvent as gf, OpenSandboxRunOptions as gi, ExecutorConfig as gl, ProgressTrackerOptions as gn, secretEnvOfMcpServer as go, canDisplace as gr, WidenSpec as gs, assertCoordinationBinding as gt, CoderReviewer as gu, superviseSurface as h, McpEnvironmentOptions as ha, defaultAuditorInstruction as hc, DelegationHistoryResult as hd, SpawnForest as hf, OpenSandboxRunBeforeStartContext as hi, CliWorktreeSeam as hl, ProgressTracker as hn, resolveSecretEnv as ho, VisibleCheck as hr, WidenLineage as hs, SupervisorToolInvocationContext as ht, CoderReview as hu, SandboxEvent$1 as i, pipeline as ia, ScoreOf as ic, DelegateResearchArgs as id, PublishOptions as if, dumbDriver as ii, DELEGATE_INPUT_SCHEMA as il, defaultDelegateBudget as in, RunLoopOptions as io, CheckExecChannel as ir, ScopeAnalyzeInput as is, DriveHarness as it, createWorktree as iu, Shell as j, AgenticTool as ja, AuthorizedDownMessage as jc, DelegationTraceCaps as jd, KnownAgentProfileMaterializationAxis as jf, mapSandboxEvent as ji, createInbox as jl, bestDelivered as jn, renderReport as jo, CollectedAgentTurn as jr, LeaderboardBenchScore as js, InMemoryRunContext as jt, DetachedSessionRefParts as ju, withUntrackedArtifacts as k, AgenticSurface as ka, AnalystRegistry as kc, DELEGATION_TRACE_MAX_BYTES as kd, CanonicalAgentProfileMaterializationAxis as kf, createSandboxToolPartState as ki, Inbox as kl, FinalizerSettled as kn, defaultAnalystInstruction as ko, AgentTurnBackend as kr, ShapeRegistry as ks, workerInboxFileFromEventDir as kt, createFleetWorkspaceExecutor as ku, createVerifierEnvironment as l, RegistryAnalyzeProjection as la, renderLeaderboardSvg as lc, DelegateUiAuditResult as ld, DeliverableSpec as lf, McpToolDescriptor as li, DelegateResult as ll, driverAgent as ln, localSandboxClient as lo, CheckSourceCtx as lr, TrajectoryReportFn as ls, ResolvedSupervisorProfile as lt, McpTransport as lu, failuresAnalyst as m, McpEndpoint as ma, auditIntent as mc, DelegationHistoryEntry as md, InMemorySpawnJournal as mf, Deliverable as mi, CliWorktreeBridgeSeam as ml, ProgressSample as mn, resolveMcpServerLaunch as mo, StructuralRolloutResult as mr, WidenDecision as ms, SupervisorToolDescriptor as mt, CoderDelegate as mu, AnalystFinding$1 as n, loopUntil as na, PairwiseVerdict as nc, DelegateFeedbackArgs as nd, BusStats as nf, NaiveDriverOptions as ni, createMcpServer as nl, rollingDispatch as nn, loopDispatch as no, profileRichnessFinding as nr, RenderCorpusToInstructionsOptions as ns, workerFromBackend as nt, WorktreeHandle as nu, computeFindingId$1 as o, verify as oa, pairwiseSignificance as oc, DelegateResearchResult as od, WatchTraceOptions as of, LocalMcpMaterialization as oi, DelegateArgs as ol, CoordinationMcpHandle as on, runAgentRounds as oo, CheckRunContext as or, SteerContext as os, ObserveSupervisorNodeEvent as ot, JsonRpcMessage as ou, SurfaceWorkerOut as p, registryScopeAnalyst as pa, IntentAudit as pc, DelegationHistoryArgs as pd, InMemoryResultBlobStore as pf, materializeLocalMcp as pi, CliSeam as pl, PlateauOptions as pn, mcpSecretEnvMetadataKey as po, StructuralRolloutPolicy as pr, Widen as ps, SupervisorProfile as pt, eventToSnapshot as pu, createSupervisor as q, depthStrategy as qa, QuestionRecord as qc, ConfigError as qd, worktreeCliProfileMaterialization as qf, createShapeRegistry as qi, WorktreeCheckRunner as ql, spendFromUsageEvents as qn, LoopUntilSpec as qo, runStrategyEvolution as qr, sentinelCompletion as qs, assertProfileModelsAllowed as qt, DelegationRunContext as qu, CreateSandboxOptions$1 as r, panel as ra, ProfileKeyOf as rc, DelegateFeedbackResult as rd, EventBus as rf, SteeringDecision as ri, DELEGATE_DESCRIPTION as rl, DelegateOptions as rn, RunAgentRoundsOptions as ro, supervisorInstructions as rr, ScopeAnalyst as rs, CoordinationBinding as rt, captureWorktreeDiff as ru, makeFinding$1 as s, widen as sa, renderLeaderboardHtml as sc, DelegateUiAuditArgs as sd, defaultToolDetectors as sf, MaterializeLocalMcpOptions as si, DelegateError as sl, serveCoordinationMcp as sn, runLoop as so, CheckRunner as sr, TrajectoryNode as ss, ResolveDriveHarness as st, JsonRpcResponse as su, AgentProfile$2 as t, flatWidenGate as ta, PairwiseOptions as tc, DelegateCodeResult as td, BusRecord as tf, DumbDriverOptions as ti, createInProcessTransport as tl, queueOf as tn, loopCampaignDispatch as to, defaultProfileRichnessThresholds as tr, RenderCorpusToInstructions as ts, supervise as tt, RemoveWorktreeOptions as tu, SuperviseSurfaceOptions as u, assertTraceDerivedFindings as ua, renderPairwiseMarkdown as uc, DelegateUiAuditRoute as ud, gateOnDeliverable as uf, StdioMcpConnection as ui, createDelegateHandler as ul, finalizeBestDelivered as un, KeyProvider as uo, RepairStop as ur, TrajectoryReportOptions as us, SupervisorAgentDeps as ut, FeedbackEvent as uu, worktreeFanout as v, BenchmarkCell as va, AnytimeTaskCurve as vc, DelegationResultPayload as vd, SpawnForestMissingTree as vf, SandboxRun as vi, RouterSeam as vl, StopDecision as vn, InProcessOnPrompt as vo, composeCheckSources as vr, DefinePersona as vs, supervisorAgent as vt, DetachedSessionDelegateOptions as vu, composeWorkerEvidence as w, Environment as wa, WaterfallCollector as wc, ResearchOutputShape as wd, replaySpawnTree as wf, SandboxLineage as wi, DEFAULT_SANDBOX_STEERING_MAX_TURNS as wl, noProgressFor as wn, HarvestReport as wo, resolveEntrySymbol as wr, PersonaExecutors as ws, readWorkerSteerRequests as wt, settleDetachedCoderTurn as wu, VERIFY_TAIL_CHARS as x, BenchmarkReport as xa, bestSoFar as xc, DelegationStatusResult as xd, loadSpawnForest as xf, openSandboxRun as xi, cliWorktreeExecutor as xl, allWorkersStalled as xn, inProcessSandboxClient as xo, filterAuthoredAsserts as xr, Outcome as xs, settledToIteration as xt, UiAuditorDelegate as xu, EVIDENCE_MAX_CHARS as y, BenchmarkConfig as ya, anytimeReport as yc, DelegationStatus as yd, SpawnForestNode as yf, SandboxRunAbortError as yi, RouterToolsSeam as yl, StopRule as yn, InProcessPromptCtx as yo, defaultExtractCandidate as yr, DefinePersonaInput as ys, ScopeArgs as yt, DetachedWinnerSelection as yu, TrajectoryAnalysis as z, StrategyCtx as za, DownMessageDeliveryOutcome as zc, DelegationStateCorruptError as zd, profileMaterializationAxes as zf, ResolveSandboxClientOptions as zi, PI_MCP_CONFIG_FLAG as zl, FileCoordinationLog as zn, EqualKOnCostOptions as zo, EvolutionBandInfo as zr, LeaderboardSpec as zs, WorktreePatchArtifact as zt, formatDetachedSessionRef as zu };
+//# sourceMappingURL=index-DPWJxSRa.d.ts.map