@tangle-network/agent-runtime 0.143.0 → 0.153.2

package/dist/{index-C2caGomG.d.ts → index-DLn9WI-f.d.ts}

@@ -1,18 +1,19 @@
-import { C as MountRecorder, D as SelectionReceipt, E as SandboxClient, S as MountManifestEntry, a as Iteration, at as RuntimeStreamEvent, 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-DeX8ibLc.js";
+import { C as MountRecorder, D as SelectionReceipt, E as SandboxClient, S as MountManifestEntry, 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-DeX8ibLc.js";
 import { n as AnalystRegistryLike } from "./types-zWfqDjeL.js";
 import { l as RuntimeHooks } from "./runtime-hooks-Bj6wJHlH.js";
-import { B as SpawnOpts, E as ProviderModelExecutionEvidence, F as Runtime, G as SpendGap, I as Scope, J as Supervisor, Jt as PendingWait, K as SteerableRootHandle, L as Settled, O as ResultBlobStore, Q as UsageEvent, R as SpawnEvent, S as NodeSnapshot, St as OtelExporter, U as Spend, X as TreeView, Zt as WaitProbeRegistry, a as DefaultVerdict, b as NodeExecutionIdentity, d as ExecutorFactory, h as ExecutorResult, i as Budget, j as RootHandle, k as ResumedKeyState, ln as TraceSource, lt as TraceContext, m as ExecutorRegistry, n as AgentExecutionRef, o as ExecutionBindingReceipt, q as SupervisedResult, r as AgentSpec, rt as WorkerTraceResolver, s as Executor, t as Agent, tt as WorkerTraceEvidence, vn as WorkerProgress, w as ProfileMaterializationReceipt, x as NodeId, xt as OtelExportConfig, y as NoWinnerError, z as SpawnJournal } from "./types-Df9vulGc.js";
-import { At as JsonRpcMessage, Ct as PeerMailbox, E as KeyProvider, F as WorktreeHarnessResult, J as runLocalHarness, Mt as McpToolDescriptor$1, N as WorktreeCheckRunner, Nt as McpTransport, Q as GitRunner, at as ToolSpec, b as Inbox, gt as PeerMailEvent, it as RouterTransportConfig, jt as JsonRpcResponse, l as RouterToolsSeam, lt as ToolLoopCompactionOptions, o as ExecutorConfig, st as ToolLoopChat, vt as PeerMailLimits } from "./runtime-J6Toky8K.js";
+import { $n as RetainedRunHandle, A as ProviderModelExecutionEvidence, B as Scope, Bn as RecoverRetainedRunResult, C as NoWinnerError, E as NodeSnapshot, F as RootHandle, Gn as RetainedRunAdmission, H as SpawnEvent, Ln as ReconnectRetainedRunOptions, M as ResultBlobStore, Mn as RetainedInteractiveRunHandle, N as ResumedKeyState, O as ProfileMaterializationReceipt, On as ReconnectRetainedInteractiveRunOptions, Ot as OtelExportConfig, Pn as StartRetainedInteractiveRunOptions, Q as Supervisor, Rn as RecoverRetainedRunIntentOptions, T as NodeId, Tn as WorkerProgress, U as SpawnJournal, V as Settled, Vn as RetainedInteractiveAdmission, W as SpawnOpts, X as SteerableRootHandle, Xn as RetainedRunEffect, Y as SpendGap, Z as SupervisedResult, _ as ExecutorRegistry, a as DefaultVerdict, ar as StartRetainedRunOptions, ct as WorkerTraceEvidence, et as TreeView, gn as TraceSource, gt as TraceContext, i as Budget, in as WaitProbeRegistry, ir as StartRetainedRunInEnvironmentOptions, kn as RecoverRetainedInteractiveRunOptions, kt as OtelExporter, n as AgentExecutionRef, o as ExecutionBindingReceipt, p as ExecutorFactory, q as Spend, r as AgentSpec, rt as UsageEvent, s as Executor, t as Agent, tn as PendingWait, tt as UnconfirmedTeardown, ut as WorkerTraceResolver, v as ExecutorResult, w as NodeExecutionIdentity, z as Runtime, zn as RecoverRetainedRunOptions } from "./types-BPQhQRrC.js";
+import { Bt as JsonRpcMessage, Et as PeerMailEvent, G as WorktreeHarnessResult, Ht as McpToolDescriptor$1, I as KeyProvider, Nt as PeerMailbox, Ot as PeerMailLimits, U as WorktreeCheckRunner, Ut as McpTransport, Vt as JsonRpcResponse, _t as ToolLoopChat, b as Inbox, ct as GitRunner, ht as ToolSpec, it as runLocalHarness, l as RouterToolsSeam, mt as RouterTransportConfig, o as ExecutorConfig, yt as ToolLoopCompactionOptions } from "./runtime-B-5dp5Iz.js";
 import { o as UiLens, r as UiFinding, s as CoderTask } from "./substrate-BcnuSHXm.js";
-import "./environment-provider-B8eZ85Ga.js";
-import "./stream-agent-turn-C1Vs_3B9.js";
-import { AGENT_PROFILE_MATERIALIZATION_AXES, AgentExactRunControlRef, AgentInteractiveSession, AgentInteractiveSessionControlClaim, AgentInteractiveSessionPromptAcknowledgement, AgentInteractiveSessionPromptCommand, AgentInteractiveSessionRef, AgentInteractiveSessionStart, AgentInteractiveSessionStatus, AgentNativeContextContinuationOptions, AgentNativeContextContinuationResult, AgentProfile, AgentProfile as AgentProfile$2, AgentProfile as AgentProfile$3, AgentProfilePrompt, AgentProfileSecurityPolicy, AgentSessionStatus, CanonicalAgentProfileMaterializationAxis, InteractionAcknowledgement, InteractionResponseCommand, NativeContextBoundaryProof, NativeContextContinuationRequest, NativeContextContinuationTurn, RuntimeEventEnvelope, Sha256Digest, StreamEvent, profileMaterializationAxes as profileMaterializationAxes$1 } from "@tangle-network/agent-interface";
-import { AgentEvalError, AgentEvalError as AgentEvalError$1, AgentEvalErrorCode, AgentProfile as AgentProfile$1, AnalystFinding, AnalystFinding as AnalystFinding$1, AnalystFinding as AnalystFinding$2, AnalystRunInputs, ChatClient, ConfigError, CustomTokenPricing, DetectorSignal, HarnessType as HarnessType$1, 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 "./environment-provider-DJG0yIYl.js";
+import "./stream-agent-turn-BGyszuPH.js";
+import { AGENT_PROFILE_MATERIALIZATION_AXES, AgentInteractiveSessionControlClaim, AgentInteractiveSessionRef, AgentInteractiveSessionStart, AgentInteractiveSessionStatus, AgentProfile, AgentProfile as AgentProfile$2, AgentProfile as AgentProfile$3, AgentProfilePrompt, AgentProfileSecurityPolicy, CanonicalAgentProfileMaterializationAxis, Sha256Digest, profileMaterializationAxes as profileMaterializationAxes$1 } from "@tangle-network/agent-interface";
+import { AgentEvalError, AgentEvalError as AgentEvalError$1, AgentEvalErrorCode, AgentProfile as AgentProfile$1, AnalystFinding, AnalystFinding as AnalystFinding$1, AnalystFinding as AnalystFinding$2, AnalystRunInputs, ChatClient, ConfigError, CustomTokenPricing, DetectorSignal, HarnessType as HarnessType$1, JudgeError, MaximumCharge, NotFoundError, ProposalFinding, RankTestMethod, RegistryRunOpts, RunRecord, StreamingDetector, ToolSpan, TraceAnalysisStore, ValidationError, buildTrajectory, computeFindingId as computeFindingId$1, makeFinding as makeFinding$1 } from "@tangle-network/agent-eval";
 import { DispatchFn, ExternalOptimizerModelCall, JudgeConfig, ProfileDispatchFn, RunProfileMatrixOptions, RunProfileMatrixResult, Scenario } from "@tangle-network/agent-eval/campaign";
+import "@tangle-network/agent-profile-materialize";
 import { AgentRunOutcome } from "@tangle-network/sandbox/runtime";
 import { BackendType, BranchOptions, 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";
-import { AgentEnvironment, AgentEnvironmentCapabilities, AgentEnvironmentProvider, AgentTurnInput, AgentTurnResult, CreateAgentEnvironmentInput } from "@tangle-network/agent-interface/environment-provider";
+import { AgentEnvironment, AgentEnvironmentCapabilities, AgentEnvironmentProvider } from "@tangle-network/agent-interface/environment-provider";
 //#region src/agent/profile-materialization.d.ts
 type KnownAgentProfileMaterializationAxis = CanonicalAgentProfileMaterializationAxis;
 /** AgentProfile axis name, with `custom:<name>` reserved for caller-owned extensions. */
@@ -416,259 +417,6 @@ interface CoderOutput {
   reviewerNotes?: string;
 }
 //#endregion
-//#region src/runtime/retained-run-types.d.ts
-/** Cursor plus runtime sequence needed to continue one ordered replay. @stable */
-interface RetainedRunReplayPoint {
-  readonly cursor: string;
-  readonly sequence: number;
-}
-/** Options for replaying canonical events strictly after a saved point. @stable */
-interface RetainedRunEventOptions {
-  readonly after?: RetainedRunReplayPoint;
-  readonly signal?: AbortSignal;
-}
-/** Effect recorded for one retained control operation. @stable */
-type RetainedRunEffect = 'cancel_requested' | 'cancelled' | 'not_live' | 'unknown';
-/** Stable status snapshot for a retained run. @stable */
-interface RetainedRunSnapshot {
-  readonly runId: string;
-  readonly controlRef: AgentExactRunControlRef;
-  readonly status: AgentSessionStatus | null;
-  readonly effect: RetainedRunEffect;
-  readonly observedAt: string;
-  readonly reason?: string;
-  readonly signal?: string;
-}
-/** Durable acknowledgement state for one retained control operation. @stable */
-interface RetainedRunCancellation {
-  readonly operationId: string;
-  readonly requestDigest: Sha256Digest;
-  readonly status: 'accepted' | 'replayed' | 'conflict' | 'unknown';
-  readonly effect: RetainedRunEffect;
-  readonly snapshot: RetainedRunSnapshot;
-  readonly reason?: string;
-  readonly signal?: string;
-}
-/** Options for an idempotent retained cancellation. @stable */
-interface RetainedRunCancelOptions {
-  readonly operationId: string;
-  readonly reason?: string;
-  readonly signal?: AbortSignal;
-}
-/** Runtime controls plus the exact user turn bound into a continuation request. @stable */
-type NativeContextContinuationInput = NativeContextContinuationTurn & Omit<AgentNativeContextContinuationOptions, 'turn'>;
-/** Result of one verified same-session continuation. @stable */
-type NativeContextContinuationExecution = AgentNativeContextContinuationResult;
-/** Reconstructable control of one provider-retained run. @stable */
-interface RetainedRunHandle {
-  readonly controlRef: AgentExactRunControlRef;
-  /** Capabilities measured from the exact environment that owns this run. */
-  readonly capabilities: AgentEnvironmentCapabilities;
-  status(options?: {
-    waitMs?: number;
-    signal?: AbortSignal;
-  }): Promise<RetainedRunSnapshot>;
-  events(options?: RetainedRunEventOptions): AsyncIterable<RuntimeEventEnvelope>;
-  result(): Promise<AgentTurnResult>;
-  respondToInteraction(command: InteractionResponseCommand, options?: {
-    signal?: AbortSignal;
-  }): Promise<InteractionAcknowledgement>;
-  contextBoundary(options?: {
-    signal?: AbortSignal;
-  }): Promise<NativeContextBoundaryProof | null>;
-  continueNative(request: NativeContextContinuationRequest, turn: NativeContextContinuationInput): Promise<NativeContextContinuationExecution>;
-  cancel(options: RetainedRunCancelOptions): Promise<RetainedRunCancellation>;
-}
-/**
- * Sanitized headless intent durable before environment creation.
- *
- * The request digest binds the public create and turn material without
- * retaining secret values. The original start material is required to replay
- * this record after a process crash.
- * @stable
- */
-interface RetainedRunIntentAdmission {
-  readonly phase: 'intent';
-  readonly provider: string;
-  readonly idempotencyKey: string;
-  readonly turnId: string;
-  readonly sessionId: string;
-  readonly executionId: string;
-  readonly runId: string;
-  readonly requestedProfileDigest: Sha256Digest;
-  readonly requestDigest: Sha256Digest;
-}
-/** Recovery coordinates durable after environment creation and before dispatch. @stable */
-interface RetainedRunEnvironmentAdmission {
-  readonly phase: 'environment';
-  readonly provider: string;
-  readonly environmentId: string;
-  readonly idempotencyKey: string;
-  readonly turnId: string;
-  /** Caller-supplied or runtime-minted; always the identity the dispatch will request. */
-  readonly sessionId: string;
-  /** Caller-supplied or runtime-minted; always the identity the dispatch will request. */
-  readonly executionId: string;
-}
-/** The verified exact reference, durable before the start promise resolves. @stable */
-interface RetainedRunDispatchedAdmission {
-  readonly phase: 'dispatched';
-  readonly controlRef: AgentExactRunControlRef;
-  readonly idempotencyKey: string;
-  readonly turnId: string;
-}
-/**
- * Sanitized intent durable before an interactive environment create begins.
- *
- * The digest covers the public start and create material without retaining that
- * material. It never carries environment variables, secret values, or provider
- * options. The replay input supplies private values after this check.
- * @stable
- */
-interface RetainedInteractiveIntentAdmission {
-  readonly phase: 'interactive_intent';
-  readonly provider: string;
-  readonly idempotencyKey: string;
-  readonly interactiveIdempotencyKey: string;
-  readonly sessionId: string;
-  readonly executionId: string;
-  readonly runId: string;
-  readonly requestedProfileDigest: Sha256Digest;
-  readonly requestDigest: Sha256Digest;
-}
-/** Exact interactive start request durable after environment creation. @stable */
-interface RetainedInteractiveEnvironmentAdmission {
-  readonly phase: 'interactive_environment';
-  readonly provider: string;
-  readonly environmentId: string;
-  readonly idempotencyKey: string;
-  readonly interactiveIdempotencyKey: string;
-  readonly request: AgentInteractiveSessionStart;
-}
-/** Provider-issued interactive process reference durable before start returns. @stable */
-interface RetainedInteractiveStartedAdmission {
-  readonly phase: 'interactive_started';
-  readonly idempotencyKey: string;
-  readonly interactiveIdempotencyKey: string;
-  readonly ref: AgentInteractiveSessionRef;
-}
-/** Durable records for one exact native coding-agent process. @stable */
-type RetainedInteractiveAdmission = RetainedInteractiveIntentAdmission | RetainedInteractiveEnvironmentAdmission | RetainedInteractiveStartedAdmission;
-/** One detached-run admission record the runtime persists before creation or dispatch proceeds. @stable */
-type RetainedRunAdmission = RetainedRunIntentAdmission | RetainedRunEnvironmentAdmission | RetainedRunDispatchedAdmission;
-/**
- * Awaited durability hook for retained admission records.
- *
- * The runtime blocks after the pre-create intent, environment creation, and
- * provider work until the hook resolves. No retained run becomes caller-visible
- * before its exact recovery record is durable. A rejection keeps provider state
- * for recovery when provider work has already started.
- *
- * @stable
- */
-type RetainedRunAdmissionHook = (admission: RetainedRunAdmission) => Promise<void>;
-/** Environment, turn, and optional identity needed to replay one retained start. @stable */
-interface RetainedRunStartMaterial {
-  readonly environment: CreateAgentEnvironmentInput & {
-    idempotencyKey: string;
-  };
-  readonly turn: AgentTurnInput & {
-    turnId: string;
-  };
-  /**
-   * Explicit dispatch coordinates. When omitted, the runtime mints
-   * deterministic coordinates from `(environment.idempotencyKey, turn.turnId)`
-   * so every process derives the same values.
-   */
-  readonly identity?: {
-    readonly sessionId: string;
-    readonly executionId: string;
-  };
-}
-/** A retained start is retry-safe only when environment and turn keys are explicit. @stable */
-interface StartRetainedRunOptions extends RetainedRunStartMaterial {
-  readonly provider: AgentEnvironmentProvider;
-  /** A previously persisted intent used to replay the exact create operation. */
-  readonly intent?: RetainedRunIntentAdmission;
-  readonly onAdmission: RetainedRunAdmissionHook;
-  readonly now?: () => number;
-}
-/** A fresh retained session inside a provider environment that already exists. @stable */
-interface StartRetainedRunInEnvironmentOptions {
-  readonly provider: AgentEnvironmentProvider;
-  readonly environment: {
-    /** Stable provider environment identifier used by `provider.get`. */
-    readonly id: string;
-    /** Original environment key. The provider must return the matching retained metadata. */
-    readonly idempotencyKey: string;
-  };
-  readonly turn: AgentTurnInput & {
-    turnId: string;
-  };
-  /**
-   * Explicit fresh-session coordinates. When omitted, the runtime mints them
-   * from `(environment.idempotencyKey, turn.turnId)`.
-   */
-  readonly identity?: {
-    readonly sessionId: string;
-    readonly executionId: string;
-  };
-  readonly onAdmission: RetainedRunAdmissionHook;
-  readonly now?: () => number;
-}
-/** Inputs sufficient to rebuild a control client in a new process. @stable */
-interface ReconnectRetainedRunOptions {
-  readonly provider: AgentEnvironmentProvider;
-  readonly controlRef: AgentExactRunControlRef;
-  readonly now?: () => number;
-}
-/** Recover a headless start after its pre-create intent was persisted. @stable */
-interface RecoverRetainedRunIntentOptions {
-  readonly provider: AgentEnvironmentProvider;
-  readonly admission: RetainedRunIntentAdmission;
-  /** The exact original environment, turn, and optional identity material. */
-  readonly replay: RetainedRunStartMaterial;
-  readonly onAdmission: RetainedRunAdmissionHook;
-  readonly now?: () => number;
-}
-/**
- * Pre-dispatch admission coordinates for one recovery attempt.
- *
- * A `phase: 'environment'` admission record carries these fields, so a caller
- * can pass that record after a crash before the dispatched record landed.
- *
- * @stable
- */
-interface RecoverRetainedRunOptions {
-  readonly provider: AgentEnvironmentProvider;
-  readonly environmentId: string;
-  readonly sessionId: string;
-  readonly executionId: string;
-  readonly now?: () => number;
-}
-/**
- * Outcome of one recovery attempt from pre-dispatch admission coordinates.
- *
- * `not_found`: the provider no longer holds the environment; nothing remains
- * to destroy. `recovered`: the provider self-identified the session with a
- * strict exact reference matching the recorded coordinates. `unverifiable`:
- * the environment exists but the provider cannot self-identify the session;
- * never destroy on this outcome — keep the environment, retry
- * `reconnectRetainedRun` with a dispatched admission record, or inspect it
- * with provider-native tools.
- *
- * @stable
- */
-type RecoverRetainedRunResult = {
-  readonly outcome: 'recovered';
-  readonly handle: RetainedRunHandle;
-} | {
-  readonly outcome: 'not_found';
-} | {
-  readonly outcome: 'unverifiable';
-  readonly environment: AgentEnvironment;
-};
-//#endregion
 //#region src/errors.d.ts
 /**
  *
@@ -2199,13 +1947,25 @@ interface QuestionRecord extends Question {
   readonly openedAt: number;
 }
 type QuestionPolicy = 'auto' | 'mustDecide' | 'bubble' | 'failClosed';
+/**
+ * What one analyst lens may return.
+ *
+ * Two shapes, because two real producers exist and neither can be dropped. An eval-registry lens
+ * returns validated `AnalystFinding`s — the schema every upstream consumer already reads. An
+ * authored lens like `failuresAnalyst` returns a written brief for the driver and has no findings
+ * to validate against. The union names both, so the boundary can no longer silently accept an
+ * unvalidated shape (#630) while the authored lens keeps working.
+ */
+type AnalystLensOutput = ReadonlyArray<AnalystFinding> | {
+  readonly summary: string;
+};
 interface AnalystRegistry {
   readonly kinds: ReadonlyArray<{
     id: string;
     description: string;
     area: string;
   }>;
-  readonly run: (kindId: string, trace: TraceAnalysisStore) => Promise<unknown>;
+  readonly run: (kindId: string, trace: TraceAnalysisStore) => Promise<AnalystLensOutput>;
 }
 /** A trace-analyst result re-entered as a message on the bus (the `finding` event kind). */
 interface AnalystFindingEvent {
@@ -2519,6 +2279,41 @@ interface CoordinationToolsOptions {
   readonly peerMail?: {
     readonly limits?: Partial<PeerMailLimits>;
   };
+  /**
+   * OPT-IN async gate run on every spawn BEFORE an assignment is minted, budget is reserved, or
+   * `Scope.spawn` is called — the one pre-journal point where a network question may be asked.
+   *
+   * `Scope.spawn` and `MakeWorkerAgent` are synchronous, so a check that needs the backend's
+   * answer (does this bridge route the child's wire id; is it already at admission capacity)
+   * cannot live there. Returning a {@link SpawnRefusal} refuses the spawn as a tool result: no
+   * assignment, no reservation, no journal entry, no worker — and the refusal is counted on
+   * {@link CoordinationTools.stats} so a gate that never refuses is visible as such.
+   *
+   * Returning `undefined` admits the spawn. A THROW is not a refusal: it propagates, because a
+   * pre-flight that fails open would hand back exactly the silent admission it exists to stop.
+   */
+  readonly preflightSpawn?: SpawnPreflight;
+}
+/** Why a pre-flight refused a spawn. Each cause is a distinct, separately countable decision. */
+type SpawnRefusalCause = 'model-route' | 'bridge-full' | 'unmountable-tool';
+/** A pre-flight's refusal: the cause it decided on, and the operator-facing evidence for it. */
+interface SpawnRefusal {
+  readonly cause: SpawnRefusalCause;
+  /** Names the exact thing that failed — the unrouted wire id, the admission numbers, the tool. */
+  readonly detail: string;
+}
+/** What a pre-flight sees: the authored child profile and the spawn it is being asked to admit. */
+interface SpawnPreflightContext {
+  readonly label: string;
+  readonly key?: string;
+  readonly task: unknown;
+}
+/** The gate `CoordinationToolsOptions.preflightSpawn` installs. */
+type SpawnPreflight = (profile: AgentProfile, context: SpawnPreflightContext) => Promise<SpawnRefusal | undefined>;
+/** Bus throughput plus the pre-flight's own refusal ledger. */
+interface CoordinationStats extends BusStats {
+  /** One counter per refusal cause, present only when a pre-flight is installed. */
+  readonly preflight?: Readonly<Record<SpawnRefusalCause, number>>;
 }
 /** Online-detector wiring for spawned workers (`CoordinationToolsOptions.watchWorkers`). */
 interface WorkerWatchOptions {
@@ -2555,8 +2350,11 @@ interface CoordinationTools {
    *  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;
+  /** Bus throughput counters (published / pulled / by-kind) for live dashboards, plus one
+   *  counter per {@link SpawnRefusalCause} the pre-flight refused. `preflight` is present
+   *  whenever `preflightSpawn` is installed, with every cause at 0 until one fires — a gate that
+   *  never refuses has to be readable as such. */
+  stats(): CoordinationStats;
   /** The run's peer-mail post office, present only when `peerMail` was enabled. The transport
    *  layer stands the capability endpoint up over it; the parent reads `history()` for the audit
    *  trail and calls `stopThread` to end a peer exchange. */
@@ -4559,12 +4357,37 @@ interface SupervisorNodeContext {
 }
 /** Context known before `Agent.act`; Runtime adds the concrete node, profile, and task. */
 type SupervisorNodeContextSeed = Omit<SupervisorNodeContext, 'nodeId' | 'profile' | 'task'>;
+/**
+ * The coordination verbs THIS manager serves, callable in code from a product tool handler.
+ *
+ * Each verb dispatches by name to the live coordination descriptor's own handler, so a spawn made
+ * here crosses the identical path the MCP verb crosses: `makeWorkerAgent` → `authorizeSpawn` /
+ * security / `allowedModels`, the conserved pool reservation, `maxLiveWorkers`, the journal, and
+ * the event bus. There is no second spawn path and no way to bypass a gate by calling in code.
+ *
+ * The set is deliberately the COORDINATION surface only. `submit_result`, `stop`, and `ask_parent`
+ * are the manager's own lifecycle verbs — a product tool that could settle the run or answer as
+ * the manager would be a second brain, not a composition surface.
+ *
+ * Arguments and results are the same JSON shapes the MCP tools take and return.
+ */
+interface CoordinationVerbs {
+  spawnAgent(args: unknown): Promise<unknown>;
+  awaitEvent(args: unknown): Promise<unknown>;
+  steerAgent(args: unknown): Promise<unknown>;
+  observeAgent(args: unknown): Promise<unknown>;
+  listQuestions(args: unknown): Promise<unknown>;
+  answerQuestion(args: unknown): Promise<unknown>;
+  runAnalyst(args: unknown): Promise<unknown>;
+}
 /** 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. */
+ * immutable snapshot supplied to the resolver; `signal` and `verbs` are the live control
+ * references Runtime adds. `signal` aborts when this manager's scope is cancelled by the caller,
+ * RootHandle, deadline, breaker, or a recursive parent; `verbs` composes THIS manager's children
+ * in code (see {@link CoordinationVerbs}). */
 interface SupervisorToolInvocationContext extends SupervisorNodeContext {
   readonly signal: AbortSignal;
+  readonly verbs: CoordinationVerbs;
 }
 /** 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
@@ -4671,15 +4494,21 @@ interface SupervisorAgentDeps {
    *  that name to the node's latest settled worker; `spawn_agent`'s per-call `continuity`
    *  overrides. Omit = every spawn fresh (status quo). */
   readonly continuityByProfile?: Readonly<Record<string, ContinuityMode>>;
-  /** 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` /
+  /** PROGRESS-derived stop rule (BOTH arms). Ends a run that has stopped learning BEFORE it
+   *  exhausts a ceiling; it can never keep a run alive past one. Router arm: evaluated before each
+   *  driver inference turn. External arm: evaluated on each worker settle, and a stop aborts
+   *  `stopSignal` so the harness ends at its next turn boundary. 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. */
+  /** One-shot notification of WHY a `stopRule` ended the run (BOTH arms). */
   readonly onProgressStop?: (reason: string) => void;
+  /** Turn cap for the supervisor's own loop. Router arm: driver inference turns (see
+   *  `DriverAgentOptions.maxTurns`). External arm: the cap belongs to the harness loop, so
+   *  `supervise()` applies it in the drive seam it builds and this field is not read here. */
   readonly maxTurns?: number;
-  /** Give the supervisor brain a chapter-lifecycle on its OWN context window (router arm only) — it
+  /** Give the supervisor brain a chapter-lifecycle on its OWN context window (ROUTER ARM ONLY; a
+   *  harness-brained supervisor is refused at construction rather than silently ignoring it) — 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;
@@ -4701,10 +4530,30 @@ interface SupervisorAgentDeps {
    *  unreachable from an off-host harness. A non-loopback host fails closed — see
    *  {@link assertCoordinationBinding}. */
   readonly coordination?: CoordinationBinding;
+  /** OPT-IN async gate run before every spawn mints an assignment or reserves budget — the one
+   *  pre-journal point that may ask the backend a question (does this bridge route the child's
+   *  wire id; is it already at admission capacity). `supervise` derives one automatically for a
+   *  bridge backend; see `CoordinationToolsOptions.preflightSpawn`. */
+  readonly preflightSpawn?: SpawnPreflight;
+  /** OPT-IN peer mail (external arm): serve the sibling `send_mail` / `read_mail` post office
+   *  beside the coordination MCP and mint each spawn a capability URL on
+   *  `WorkerSpawnContext.peerMailUrl`. A router-brained supervisor is refused: it serves no
+   *  listener, so there is no post office a worker could reach. */
+  readonly peerMail?: boolean | {
+    limits?: Partial<PeerMailLimits>;
+  };
   /** The durable run directory this manager acknowledges worker-scoped cancel requests from
    *  (router arm only — the in-process turn loop is the acknowledger). See
    *  `DriverAgentOptions.controlDir`. */
   readonly controlDir?: string;
+  /** Which cancel requests this manager's acknowledger owns: `'run'` (default; the tree root —
+   *  its own direct-child node ids plus label/profile-name references) or `'subtree'` (a nested
+   *  manager — exact direct-child node ids only). Exactly one manager owns any request, so two
+   *  acknowledgers can never apply one operation. See `DriverAgentOptions.controlScope`. */
+  readonly controlScope?: 'run' | 'subtree';
+  /** Abort the whole run — the seam a run-scoped cancel request is applied through (router arm,
+   *  `'run'` scope only). See `DriverAgentOptions.abortRun`. */
+  readonly abortRun?: (reason: string) => void;
 }
 /** Test-only dependency shape. It is exported only through the package's explicit `/testing`
  * entry; production supervisor surfaces cannot replace profile-derived model execution. */
@@ -4796,6 +4645,17 @@ 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;
+  /** OPT-IN peer mail for the run's workers: sibling-to-sibling `send_mail` / `read_mail`, bounded
+   *  and audited (`CoordinationToolsOptions.peerMail`). The runtime mints one capability URL per
+   *  spawn, serves the mail listener beside the coordination MCP, and hands each worker its
+   *  endpoint on {@link WorkerSpawnContext.peerMailUrl}. Mounting that URL into the worker is the
+   *  `makeWorkerAgent` owner's job today: the runtime never writes it into a worker profile, since
+   *  the fresh random URL would move the canonical profile digest, and bridge workers cannot mount
+   *  it out of band until the bridge carries runtime attachments (#774). Requires a harness-brained
+   *  supervisor; a router-brained supervisor is refused rather than silently unmailed. */
+  readonly peerMail?: boolean | {
+    limits?: Partial<PeerMailLimits>;
+  };
   /** 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
@@ -4881,7 +4741,11 @@ interface SuperviseOptions {
   /** 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. */
+   * context, including recursive parent and root cascades, plus `context.verbs` — that manager's
+   * own coordination verbs, callable in code so a product tool can COMPOSE its children (fan out,
+   * chain, join, retry) in one tool call instead of one model turn per verb. Every verb crosses
+   * the same authorizeSpawn / security / allowedModels gate, pool reservation, `maxLiveWorkers`
+   * cap, journal, and bus the MCP verb crosses, at every depth and on both arms. */
   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. */
@@ -4968,9 +4832,14 @@ interface SuperviseOptions {
    *  `registry.probes`. */
   readonly probes?: WaitProbeRegistry | string;
   /**
-   * PROGRESS-derived stop rule (router-brained supervisor). Ends a run that has stopped LEARNING
-   * before it exhausts a ceiling — the answer to "a run should end because it is done or stuck,
-   * not because it ran out". It composes with the budget guards and can never override one.
+   * PROGRESS-derived stop rule (BOTH arms). Ends a run that has stopped LEARNING before it
+   * exhausts a ceiling — the answer to "a run should end because it is done or stuck, not because
+   * it ran out". It composes with the budget guards and can never override one.
+   *
+   * The evaluation boundary differs by arm because the loop does: a router-brained supervisor is
+   * evaluated before each of its own inference turns; a harness-brained supervisor is evaluated on
+   * each worker settle, and a stop aborts its stop signal so the harness ends at its next turn
+   * boundary. Both arms fold the same settled ledger through the same evaluator.
    *
    * Build it from `supervise/stop-rules`: `plateau({window, minDelta})`,
    * `noProgressFor({ms, settles})`, `allWorkersStalled({...})`, combined with `anyOf`/`allOf`. The
@@ -4978,22 +4847,37 @@ interface SuperviseOptions {
    * only (unchanged behavior).
    */
   readonly stopRule?: StopRule;
-  /** One-shot notification of WHY a `stopRule` ended the run — so a caller records the reason
-   *  instead of inferring an early stop from an unexhausted budget. */
+  /** One-shot notification of WHY a `stopRule` ended the run (BOTH arms) — so a caller records the
+   *  reason instead of inferring an early stop from an unexhausted budget. */
   readonly onProgressStop?: (reason: string) => void;
   readonly maxDepth?: number;
+  /** Turn cap for the supervisor's OWN loop (BOTH arms). Router arm: inference turns of the
+   *  driver's tool loop. Harness arm: turns the harness reports, counted off its `iteration`
+   *  stream — reaching the cap aborts the stop signal, so the harness ends at its next turn
+   *  boundary rather than mid-request. `0` lifts the cap on both arms and leaves the conserved
+   *  pool, the deadline, and abort as the bounds; a negative value is refused. Omit = the router
+   *  arm's default cap, and no turn cap on the harness arm. */
   readonly maxTurns?: number;
-  /** Give the supervisor brain a chapter-lifecycle on its OWN context window (router arm only): once
-   *  its coordination transcript exceeds `thresholdTokens` it distills to a compact progress note and
-   *  continues, instead of re-billing the whole transcript every turn (the cost that makes the LLM-brain
-   *  front door lose to a dumb-Ralph respawn). The live `Scope` roster is the durable state across
-   *  chapters. Default off. `distill` defaults to a brain self-summary + the settled-worker roster. */
+  /** Give the supervisor brain a chapter-lifecycle on its OWN context window (ROUTER ARM ONLY —
+   *  a harness owns its own context window and its own compaction, so this is refused for a
+   *  harness-brained supervisor rather than silently ignored): once its coordination transcript
+   *  exceeds `thresholdTokens` it distills to a compact progress note and continues, instead of
+   *  re-billing the whole transcript every turn (the cost that makes the LLM-brain front door lose
+   *  to a dumb-Ralph respawn). The live `Scope` roster is the durable state across chapters.
+   *  Default off. `distill` defaults to a brain self-summary + the settled-worker roster. */
   readonly compaction?: ToolLoopCompactionOptions;
   readonly runId?: string;
   readonly now?: () => number;
   /** Restrict the run to this subset of models. When set, every configured model — the
    *  supervisor router model, the profile's model, and the backend's model — must be a member,
-   *  or `supervise()` throws a `ConfigError` before any compute is spent. Unset = unrestricted. */
+   *  or `supervise()` throws a `ConfigError` before any compute is spent. Unset = unrestricted.
+   *
+   *  This is a MODEL-ID filter, not a route filter. The compared values are the bare ids a profile
+   *  declares — `model.default`, `model.small`, `subagents[].model`, `modes[].model`. The composed
+   *  wire id (`harness/provider/model`) is never built here and never compared, so an entry written
+   *  in qualified form matches nothing, and a child that names an allowed id is admitted whatever
+   *  harness and provider its own profile declares. Pin the route with `authorizeSpawn`: it reads
+   *  the authored child profile and may refuse the spawn before any reservation. */
   readonly allowedModels?: readonly string[];
   /** How the settled-worker ledger becomes the run's output. Default `bestDelivered` — the single
    *  highest-scoring DELIVERED child (the exact behavior every existing caller had). Alternatives:
@@ -5053,6 +4937,7 @@ declare function supervise(profile: SupervisorProfile, task: unknown, opts: Supe
   downCount: number;
   spentTotal: Spend;
   providerModel?: ProviderModelExecutionEvidence;
+  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
   spendGaps?: ReadonlyArray<SpendGap>;
   error?: never;
 } | {
@@ -5063,6 +4948,7 @@ declare function supervise(profile: SupervisorProfile, task: unknown, opts: Supe
   downCount: number;
   spentTotal: Spend;
   providerModel?: ProviderModelExecutionEvidence;
+  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
   spendGaps?: ReadonlyArray<SpendGap>;
   error: NoWinnerError;
 } | {
@@ -5074,6 +4960,7 @@ declare function supervise(profile: SupervisorProfile, task: unknown, opts: Supe
   tree: TreeView;
   spentTotal: Spend;
   providerModel?: ProviderModelExecutionEvidence;
+  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
   spendGaps?: ReadonlyArray<SpendGap>;
   spentBreakdown?: {
     driverInference: Spend;
@@ -5089,6 +4976,7 @@ declare function superviseWithTestBrain(profile: SupervisorProfile, task: unknow
   downCount: number;
   spentTotal: Spend;
   providerModel?: ProviderModelExecutionEvidence;
+  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
   spendGaps?: ReadonlyArray<SpendGap>;
   error?: never;
 } | {
@@ -5099,6 +4987,7 @@ declare function superviseWithTestBrain(profile: SupervisorProfile, task: unknow
   downCount: number;
   spentTotal: Spend;
   providerModel?: ProviderModelExecutionEvidence;
+  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
   spendGaps?: ReadonlyArray<SpendGap>;
   error: NoWinnerError;
 } | {
@@ -5110,6 +4999,7 @@ declare function superviseWithTestBrain(profile: SupervisorProfile, task: unknow
   tree: TreeView;
   spentTotal: Spend;
   providerModel?: ProviderModelExecutionEvidence;
+  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
   spendGaps?: ReadonlyArray<SpendGap>;
   spentBreakdown?: {
     driverInference: Spend;
@@ -5741,8 +5631,9 @@ declare class InMemoryCorpus implements Corpus {
  * back silently) and folding by `id`: a later identical line dedups, a later conflicting line
  * under the same `id` is a corruption (fail loud). `append` first replays to enforce the same
  * idempotence/conflict contract as the in-mem impl, then fsyncs the new line so a crash between
- * writes never loses an acknowledged fact. Shares the JSONL append-line spine with the spawn
- * journal, but the interface stays separate (a learned fact is not a replay record).
+ * writes never loses an acknowledged fact. Reads and appends over the shared append-only
+ * spine (`durable/jsonl-file`) — the same one the spawn journal uses — but the interface stays
+ * separate (a learned fact is not a replay record).
  */
 declare class FileCorpus implements Corpus {
   private readonly path;
@@ -5835,7 +5726,12 @@ declare function equalKOnCost(arms: ReadonlyArray<EqualKArm>, options?: EqualKOn
  */
 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. */
+ * backend may select for cheap work, named subagents, or modes.
+ *
+ * Every compared value is a bare model id. The composed `harness/provider/model` wire id
+ * (`profileBridgeWireModel`) is neither built nor compared here, so this admits any route that
+ * declares an allowed id, and a qualified entry in `allowed` matches nothing. Route pinning
+ * belongs to `SuperviseOptions.authorizeSpawn`. */
 declare function assertProfileModelsAllowed(profile: AgentProfile, allowed: readonly string[] | undefined): void;
 //#endregion
 //#region src/runtime/profile-chat-client.d.ts
@@ -5948,54 +5844,6 @@ interface ResolveSandboxClientOptions {
  */
 declare function resolveSandboxClient(opts: ResolveSandboxClientOptions): SandboxClient;
 //#endregion
-//#region src/runtime/retained-interactive-types.d.ts
-/** Environment and exact AgentProfile used to start one native coding-agent process. @stable */
-type RetainedInteractiveEnvironmentInput = Omit<CreateAgentEnvironmentInput, 'idempotencyKey' | 'profile' | 'signal'> & {
-  readonly idempotencyKey: string;
-  readonly profile: AgentProfile;
-};
-/** Material used to create and start one native coding-agent TUI. @stable */
-interface RetainedInteractiveStartMaterial {
-  readonly environment: RetainedInteractiveEnvironmentInput;
-  readonly interactiveIdempotencyKey: string;
-  readonly initialPrompt?: string;
-  readonly cwd?: string;
-  readonly cols?: number;
-  readonly rows?: number;
-}
-/** Start one retry-safe native coding-agent TUI in a new environment. @stable */
-interface StartRetainedInteractiveRunOptions extends RetainedInteractiveStartMaterial {
-  readonly provider: AgentEnvironmentProvider;
-  /** A previously persisted intent used to replay the exact create operation. */
-  readonly intent?: RetainedInteractiveIntentAdmission;
-  readonly onAdmission: RetainedInteractiveAdmissionHook;
-  readonly signal?: AbortSignal;
-}
-/** Persist each exact interactive record before the runtime proceeds. @stable */
-type RetainedInteractiveAdmissionHook = (admission: RetainedInteractiveAdmission) => Promise<void>;
-/** Reconstruct one exact provider-owned native coding-agent process. @stable */
-interface ReconnectRetainedInteractiveRunOptions {
-  readonly provider: AgentEnvironmentProvider;
-  readonly ref: AgentInteractiveSessionRef;
-  readonly signal?: AbortSignal;
-}
-/** Recover a start after a pre-create crash or a lost provider response. @stable */
-interface RecoverRetainedInteractiveRunOptions {
-  readonly provider: AgentEnvironmentProvider;
-  readonly admission: RetainedInteractiveIntentAdmission | RetainedInteractiveEnvironmentAdmission;
-  /** Required when recovering from an intent before an environment existed. */
-  readonly replay?: RetainedInteractiveStartMaterial;
-  readonly onAdmission: RetainedInteractiveAdmissionHook;
-  readonly signal?: AbortSignal;
-}
-/** Exact interactive process controls plus measured environment capabilities. @stable */
-interface RetainedInteractiveRunHandle extends AgentInteractiveSession {
-  readonly capabilities: AgentEnvironmentCapabilities;
-  sendPrompt(command: AgentInteractiveSessionPromptCommand, options?: {
-    signal?: AbortSignal;
-  }): Promise<AgentInteractiveSessionPromptAcknowledgement>;
-}
-//#endregion
 //#region src/runtime/retained-interactive.d.ts
 /**
  * Start one retry-safe native coding-agent TUI without dispatching a headless turn.
@@ -6142,163 +5990,6 @@ interface CriuCapableClient {
   }>;
 }
 //#endregion
-//#region src/runtime/sandbox-events.d.ts
-/** The provider/model the platform reports it actually bound to a turn, when it reports one.
- *  `source` is the platform's own account of where that choice came from — `environment` means
- *  the platform chose, not the request. */
-interface SandboxServedBackend {
-  readonly provider?: string;
-  readonly model?: string;
-  readonly source?: string;
-}
-/**
- * Read the served execution identity off one Sandbox event.
- *
- * The platform reports `effectiveBackend` on `execution.started` and again on the terminal
- * event (`@tangle-network/sandbox`, `EffectiveBackend`). Absence returns `undefined`
- * and must stay unknown — a request is not a receipt, so nothing here may be inferred from
- * what was asked for.
- */
-declare function sandboxEventServedBackend(event: SandboxEvent): SandboxServedBackend | undefined;
-/**
- * Fail the execution when the platform reports serving a model other than the exact one asked for.
- *
- * Measured motive (agent-runtime#892, live infrastructure 2026-08-17): 6 of 6 boxes whose profile
- * declared `zai-coding-plan/glm-5.2` reported
- * `{"provider":"openai-compat","model":"deepseek/deepseek-v4-flash","source":"environment"}`,
- * while the materialization receipt recorded the declared model as `status: "known"`. Sending
- * `backend.model` makes that substitution unlikely; only reading the report back makes it
- * detectable. A run that cannot say which model produced its evidence must not settle as one
- * that can.
- *
- * Silent when the platform reports no served model: unobserved stays unobserved.
- */
-declare function assertSandboxServedModel(event: SandboxEvent, expected: {
-  readonly provider?: string;
-  readonly model?: string;
-} | undefined): void;
-/**
- * Extract a `RuntimeStreamEvent`-shaped `llm_call` from a sandbox event when
- * the event carries usage/cost data. Returns `undefined` for non-cost events
- * so the kernel can iterate the full stream without branching.
- *
- * Pure by contract: it never throws on a failed run. The terminal truth
- * boundary is the public Sandbox outcome tracker, applied after the complete
- * stream. Post-hoc readers — {@link sumSandboxUsage}, the
- * analyst trace store, the chat projection — must stay able to read a failed
- * turn's events, which is when reading them matters most.
- *
- * Canonical cost-carrying types observed in the wild:
- *   - `llm_call` — `data: { model, tokensIn, tokensOut, costUsd, ... }`
- *   - `message.completed` / `result` — `data: { usage: { inputTokens,
- *      outputTokens, totalCostUsd? } }`
- *   - `cost.usage` / `usage` — same shape under a dedicated type
- *
- * Numeric coercion is strict: `Number.isFinite` gates every accumulator write
- * so a sentinel `NaN` from a misbehaving backend cannot poison the ledger.
- */
-declare function extractLlmCallEvent(event: SandboxEvent, agentRunName: string): (RuntimeStreamEvent & {
-  type: 'llm_call';
-}) | undefined;
-/**
- * Sum the token usage + USD cost of a sandbox turn's events — the one honest way to meter an
- * `openSandboxRun` cell. Folds `extractLlmCallEvent` over the stream (which reads usage off EVERY backend
- * event shape), so a `runProfileMatrix` dispatch can report it to `ctx.cost`:
- *
- *     receipt: (turn) => {
- *       const u = sumSandboxUsage(turn.events)
- *       return { model, inputTokens: u.input, outputTokens: u.output,
- *         ...(u.tokensKnown === false ? { usageUnknown: true } : {}),
- *         ...(u.usdKnown !== false && u.costUsd > 0 ? { actualCostUsd: u.costUsd } : {}),
- *         ...(u.usdKnown === false ? { costUnknown: true } : {}),
- *         ...(u.estimatedCostUsd !== undefined ? { estimatedCostUsd: u.estimatedCostUsd } : {}) }
- *     }
- *
- * Without this a cell reads `{tokens:0, cost:0}` and the backend-integrity guard correctly aborts the
- * matrix as a stub. `agentRunName` is the fallback model label for cost-only events (default `'agent'`).
- */
-declare function sumSandboxUsage(events: readonly SandboxEvent[], agentRunName?: string): {
-  input: number;
-  output: number;
-  costUsd: number;
-  tokensKnown?: false;
-  usdKnown?: false;
-  estimatedCostUsd?: number;
-};
-/**
- * Cross-event state for {@link mapSandboxToolEvent}. Sandbox backends emit a
- * tool invocation as MANY `message.part.updated` frames on the same call id
- * (pending → running → completed), so faithful projection needs per-call
- * status memory: one `tool_call` on first sighting, at most one `tool_result`
- * on the terminal transition, nothing on intermediate re-frames. Create one
- * state per turn via {@link createSandboxToolPartState}.
- *
- * @experimental
- */
-interface SandboxToolPartState {
-  /** Last seen status per tool call id. A terminal status is sticky — later
-   *  frames on a settled call project to nothing. */
-  statusByCall: Map<string, string>;
-  /** Sequence for synthesized call ids when an event carries none. */
-  seq: number;
-}
-/**
- * Fresh per-turn {@link SandboxToolPartState} for {@link mapSandboxToolEvent} — an
- * empty call-status map so each turn projects tool frames independently.
- *
- * @experimental
- */
-declare function createSandboxToolPartState(): SandboxToolPartState;
-/**
- * Project one `SandboxEvent` onto the `tool_call` / `tool_result` variants of
- * `RuntimeStreamEvent` — the tool-part projection `mapSandboxEvent`
- * deliberately does NOT perform. Opt-in and additive: `mapSandboxEvent`'s
- * default vocabulary (text/reasoning deltas + `llm_call`) is unchanged;
- * consumers that need the tool surface (chat UIs rendering tool activity)
- * compose this projector alongside it — `streamAgentTurn` does exactly that
- * under its `preserveToolParts` option.
- *
- * Handled shapes (observed on the opencode / claude-code sandbox backends):
- *   - `message.part.updated` with `part.type === 'tool'` — stateful: a
- *     `tool_call` on the call id's first frame (args from `state.input` or
- *     `state.metadata.input`), a `tool_result` when the status transitions to
- *     `completed` (result from `state.output` / `metadata.output`) or to a
- *     terminal failure (result is `{ error, status, output? }` — the error
- *     surfaced in-band, never dropped).
- *   - bare `tool*` event types (`tool.call`, `tool_result`, …) — stateless:
- *     `*result*` types project to `tool_result`, the rest to `tool_call`.
- *
- * Returns `[]` for every non-tool event.
- *
- * @experimental
- */
-declare function mapSandboxToolEvent(event: SandboxEvent, state: SandboxToolPartState): (RuntimeStreamEvent & {
-  type: 'tool_call' | 'tool_result';
-})[];
-/**
- * Project one `SandboxEvent` onto the `RuntimeStreamEvent` chat-UX vocabulary,
- * for runtimes that bridge a sandbox `streamPrompt` into the
- * `AgentRuntime.act` streaming contract. Returns `undefined` for events that
- * have no faithful projection — the raw stream is preserved separately for the
- * `OutputAdapter`, so an unmapped event never loses data.
- *
- * Mapped (the task-optional incremental variants — no synthesized task
- * lifecycle, no guessed tool-part shapes):
- *   - `message.part.updated` text part → `text_delta`
- *   - `message.part.updated` reasoning/thinking part → `reasoning_delta`
- *   - cost-bearing events → `llm_call` (shared with the ledger extractor)
- *
- * Tool parts are deliberately NOT mapped here (unchanged default) — compose
- * {@link mapSandboxToolEvent} alongside when a consumer needs them.
- *
- * The opencode backend emits incremental text as
- * `{ type: 'message.part.updated', data: { part: { type, text }, delta } }`;
- * `delta` is the increment, `part.text` the running accumulation.
- */
-declare function mapSandboxEvent(event: SandboxEvent, opts?: {
-  agentRunName?: string;
-}): RuntimeStreamEvent | undefined;
-//#endregion
 //#region src/runtime/sandbox-lineage.d.ts
 /**
  * A live box plus the session that threads its iterations together. Handed back
@@ -7320,6 +7011,9 @@ interface DriverAgentOptions {
    *  `CoordinationToolsOptions.continuityByProfile`); `spawn_agent`'s per-call `continuity`
    *  argument overrides. Omit = every spawn fresh (status quo). */
   readonly continuityByProfile?: Readonly<Record<string, ContinuityMode>>;
+  /** OPT-IN async gate run before every spawn mints an assignment or reserves budget. See
+   *  `CoordinationToolsOptions.preflightSpawn`. */
+  readonly preflightSpawn?: SpawnPreflight;
   /** 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);
@@ -7399,10 +7093,35 @@ interface DriverAgentOptions {
    * writes the durable {@link WorkerCancellation} acknowledgement: `cancel_requested` when the
    * abort is issued, `cancelled` only when the worker reaches a terminal `down` on the settle
    * path, `not_live` when the worker is already gone — a missing worker never reads as success.
-   * A request naming a deeper descendant stays unanswered (cancel its lead instead). Omit = no
-   * acknowledger (in-memory runs keep in-process control via handles).
+   * Which requests this driver OWNS is set by {@link controlScope}. Omit = no acknowledger
+   * (in-memory runs keep in-process control via handles).
    */
   readonly controlDir?: string;
+  /**
+   * Which cancel requests this driver's acknowledger owns when `controlDir` is set.
+   *
+   * `'run'` (the default, and the tree root's role): exact node ids of its OWN direct children,
+   * plus every label/profile-name reference. `'subtree'` (a nested manager): exact direct-child
+   * node ids ONLY — never labels or profile names, which can match workers under more than one
+   * manager. Ownership makes each operation appliable by exactly ONE manager, so two acknowledgers
+   * sharing one `controlDir` can never abort two workers for one operation or race on the
+   * acknowledgement file. At the end of `act`, the owner writes an expiry record for each owned
+   * request still open: `not_live` for one never applied, `unknown` for an abort whose settle the
+   * run ended too soon to observe — so a reader can tell run-over from in-progress.
+   */
+  /** Called with this driver's coordination tool descriptors once they exist and before the brain
+   *  loop starts — the seam a node tool uses to call the same verbs in code
+   *  (`SupervisorToolInvocationContext.verbs`). */
+  readonly onCoordinationTools?: (tools: ReadonlyArray<McpToolDescriptor$1>) => void;
+  readonly controlScope?: 'run' | 'subtree';
+  /**
+   * Abort the WHOLE run — the seam a run-scoped cancel request (`cancelRun`) is applied through.
+   * Wired by `supervise()` to the run's ONE cascade controller (the attached root control), so a
+   * run cancel takes the same path a caller's `RootHandle.abort` takes; there is no second
+   * controller and no poller. Read only by the `'run'`-scoped manager with a `controlDir`; omit
+   * and a run-scoped request stays unanswered.
+   */
+  readonly abortRun?: (reason: string) => void;
 }
 /**
  * Build the intelligent recursive driver. Its `act` is the LLM tool-loop; spawn it as a
@@ -7517,6 +7236,14 @@ declare function serveCoordinationMcp(opts: {
   peerMail?: boolean | {
     limits?: Partial<PeerMailLimits>;
   };
+  /** OPT-IN async gate run before every spawn mints an assignment or reserves budget — the one
+   *  pre-journal point that may ask the backend a question. See
+   *  `CoordinationToolsOptions.preflightSpawn`. */
+  preflightSpawn?: SpawnPreflight;
+  /** Called with this server's coordination tool descriptors once they exist and BEFORE the
+   *  listener opens — the seam a caller uses to give an already-bound node tool a way to call the
+   *  same verbs in code (`SupervisorToolInvocationContext.verbs`). */
+  onCoordinationTools?: (tools: ReadonlyArray<McpToolDescriptor$1>) => void;
 }): Promise<CoordinationMcpHandle>;
 //#endregion
 //#region src/runtime/supervise/delegate.d.ts
@@ -8097,7 +7824,9 @@ interface WorkerCancelRequest {
   readonly at: string;
   /** Who asked — 'human', a brain label, a tool name. Provenance, not authorization. */
   readonly source: string;
-  /** The worker the request targets: a workerId (node id), a profile name, or a spawn label. */
+  /** The worker the request targets: a workerId (node id — routed to the owning manager at any
+   *  depth), or a profile name or spawn label (resolved by the root manager against its direct
+   *  children only). */
   readonly worker: string;
   readonly reason?: string;
 }
@@ -8108,11 +7837,18 @@ interface WorkerCancelRequest {
  * `effect` reuses the retained-run vocabulary ({@link RetainedRunEffect}) so the runtime has one
  * spelling of the four cancellation states:
  *  - `'unknown'`          — not yet resolved by the runtime (also what `cancelWorker` returns for
- *                           a request no acknowledger has answered). Never a success.
+ *                           a request no acknowledger has answered), or — terminally, with the
+ *                           run-over detail — an abort was issued but the run ended before the
+ *                           termination could be observed. Never a success.
  *  - `'cancel_requested'` — the runtime issued the worker's abort; termination not yet proven.
  *  - `'cancelled'`        — the worker reached a terminal `down` state on the settle path.
- *  - `'not_live'`         — the worker was not live to cancel (already settled, or it settled
- *                           `done` despite the abort). Never a success of THIS operation.
+ *  - `'not_live'`         — the worker was not live to cancel (already settled, it settled
+ *                           `done` despite the abort, or the run ended before the request was
+ *                           ever applied). Never a success of THIS operation.
+ *
+ * Expiry is run end: the owning manager's final pass closes every still-open request it owns
+ * (`not_live` never applied, `unknown` issued-but-unproven), so a pending request cannot outlive
+ * its run and abort a future spawn that happens to reuse a label.
  */
 interface WorkerCancellation {
   readonly operationId: string;
@@ -8131,12 +7867,53 @@ interface WorkerCancellation {
   readonly detail?: string;
   /**
    * Every node id this operation PROVED terminated: the requested worker plus each descendant of
-   * its subtree observed to reach a terminal `down`/`cancelled` journal record at or after
-   * `requestedAt` (a cancelled lead cascades to its subtree by design — the scope signal chain —
-   * so the acknowledgement names the set, not one id). Empty until termination is proven.
+   * its subtree observed to reach a terminal `down`/`cancelled` journal record at or after the
+   * abort was ISSUED — the acknowledger's own `observedAt` on the `cancel_requested` record
+   * (runtime clock), never the client's `requestedAt` (a cancelled lead cascades to its subtree
+   * by design — the scope signal chain — so the acknowledgement names the set, not one id).
+   * Proven at acknowledgement time; post-abort causation is approximate: a descendant that died
+   * of its own cause after the abort is indistinguishable from the cascade and may be included,
+   * a late teardown journal joins the set on a later pass while the manager still runs, and one
+   * still absent at run end is absent from the set. Grows monotonically; empty until termination
+   * is proven.
    */
   readonly terminated: ReadonlyArray<string>;
 }
+/** One durable run-scoped cancel request: cancel the WHOLE run, not one worker. */
+interface RunCancelRequest {
+  /** Caller-minted stable operation identifier — the idempotency key of the whole operation. */
+  readonly operationId: string;
+  /** ISO timestamp of the write. */
+  readonly at: string;
+  /** Who asked — 'human', a brain label, a tool name. Provenance, not authorization. */
+  readonly source: string;
+  readonly reason?: string;
+}
+/**
+ * The durable acknowledgement state for the run-scoped cancel operation, keyed by `operationId`.
+ * The runtime is the ONLY writer; {@link cancelRun} only reads it.
+ *
+ * `effect` is the same {@link RetainedRunEffect} vocabulary the worker-scoped and retained-run
+ * paths use, so the runtime has one spelling of the four cancellation states:
+ *  - `'unknown'`          — no runtime has answered yet. Never a success.
+ *  - `'cancel_requested'` — the root manager issued the run's cascading abort; the run's terminal
+ *                           state is not yet observed.
+ *  - `'cancelled'`        — the run reached its terminal state ABORTED after that request.
+ *  - `'not_live'`         — the run was not live to cancel: it settled on its own despite the
+ *                           request, or it ended before the request was applied.
+ */
+interface RunCancellation {
+  readonly operationId: string;
+  readonly effect: RetainedRunEffect;
+  /** ISO timestamp of the original request. */
+  readonly requestedAt: string;
+  /** ISO timestamp of the runtime's most recent observation of this operation. */
+  readonly observedAt: string;
+  /** The caller's reason, carried verbatim from the request. */
+  readonly reason?: string;
+  /** The runtime's explanation of how it arrived at `effect`. */
+  readonly detail?: string;
+}
 /** The root every supervisor run of one workspace lives under. */
 declare function supervisorRunsRoot(rootDir: string): string;
 /** The run directory every artifact of one supervisor run lives under. */
@@ -8202,9 +7979,10 @@ declare function readWorkerCancellation(eventDir: string, operationId: string):
  * durable state.
  *
  * The write half of the acknowledged-cancellation contract (`writeWorkerSteer` is the steer
- * analog): append the request to the run's cancellation inbox, where the runtime's acknowledger
- * (the coordination driver's turn loop) applies it — aborting exactly that worker's subtree and
- * recording what it proved. This function never applies the cancellation itself; writing a
+ * analog): append the request to the run's cancellation inbox, where the OWNING manager's
+ * acknowledger (its turn loop — the root for label/profile references, the parent manager for an
+ * exact node id at any depth) applies it — aborting exactly that worker's subtree and recording
+ * what it proved. This function never applies the cancellation itself; writing a
  * request file is not an acknowledgement.
  *
  * Idempotency is a lookup: when an acknowledgement for `operationId` already exists, it is
@@ -8217,6 +7995,39 @@ declare function cancelWorker(eventDir: string, worker: string, operationId: str
   readonly reason?: string;
   readonly source?: string;
 }): WorkerCancellation;
+/** The run-scoped cancel request file of one run — one {@link RunCancelRequest}. */
+declare function runCancelRequestFile(eventDir: string): string;
+/** The run-scoped acknowledgement file of one run — one {@link RunCancellation}. */
+declare function runCancellationFile(eventDir: string): string;
+/** Read the run-scoped cancel request, or `undefined` when none was written. */
+declare function readRunCancelRequest(eventDir: string): RunCancelRequest | undefined;
+/**
+ * Read the acknowledgement for the run-scoped cancel operation. `undefined` when the runtime has
+ * not answered. A record holding a DIFFERENT `operationId` belongs to another operation on the
+ * same run — fail loud rather than answer for it.
+ */
+declare function readRunCancellation(eventDir: string, operationId: string): RunCancellation | undefined;
+/**
+ * Request the cancellation of the WHOLE run, idempotently, and return the operation's current
+ * durable state.
+ *
+ * The run-scoped twin of {@link cancelWorker}: write the request into the run's cancellation
+ * directory, where the run's own root manager applies it — aborting the root through the one
+ * cascade controller the run already has, so every live worker comes down with it. This function
+ * never applies the cancellation itself; writing a request file is not an acknowledgement.
+ *
+ * Idempotency is a lookup: when an acknowledgement for `operationId` already exists it is returned
+ * AS-IS and nothing is written. A request the runtime has not answered yet returns
+ * `effect: 'unknown'` (never a success); call again with the same `operationId` — or
+ * {@link readRunCancellation} — to read the acknowledged result after a reconnect.
+ *
+ * A run carries ONE run-scoped operation: a second request under a different `operationId` throws
+ * rather than silently replacing the pending one, because both would claim the same single abort.
+ */
+declare function cancelRun(eventDir: string, operationId: string, options?: {
+  readonly reason?: string;
+  readonly source?: string;
+}): RunCancellation;
 //#endregion
 //#region src/runtime/supervise/scope.d.ts
 /** Construction args for `createScope`. The supervisor threads the shared pool, journal,
@@ -8586,6 +8397,32 @@ interface SurfaceWorkerOut {
   readonly summary: string;
   readonly failing?: readonly string[];
 }
+/**
+ * Adapt an `agent-eval` `AnalystRegistry` into the lens shape `supervise({ analysts })` takes.
+ *
+ * The two registries were never structurally compatible: eval's class exposes `list()` and
+ * `run(runId, inputs, opts)` and returns an `AnalystRunResult`, while `supervise` wants `kinds`
+ * and `run(kindId, trace)`. So `'kinds' in buildDefaultAnalystRegistry()` is `false` and the five
+ * calibrated lenses in `DEFAULT_TRACE_ANALYST_KINDS` were unreachable from any supervised run —
+ * every consumer hand-rolled a lens instead (#630).
+ *
+ * The adapter lives HERE, not in eval, for one reason: eval must never import runtime, and runtime
+ * already owns both shapes — it consumes `AnalystFinding` / `AnalystRunResult` from eval for its
+ * analyst loop and defines the supervise lens itself. Writing it in eval would mean eval declaring
+ * a duck-typed copy of a type this package already exports.
+ *
+ * `kinds` is the DEFINITION list, not `registry.list()`, because `Analyst` carries no `area` while
+ * `TraceAnalystDefinition` does — `list()` cannot supply the field the lens shape requires. Every
+ * id must be registered: an unknown kind throws at adapt time rather than returning nothing at run
+ * time, when the driver would read the silence as "no findings".
+ */
+declare function analystsFromRegistry(registry: AnalystRegistryLike, kinds?: ReadonlyArray<{
+  id: string;
+  description: string;
+  area: string;
+}>, opts?: {
+  runOpts?: RegistryRunOpts;
+}): AnalystRegistry;
 /** The default self-improvement LENS — authored content, not a code path. On each settled worker it hands
  *  the driver the still-FAILING tests (not just a score), so the next spawn targets the persistently-hard
  *  cases. Swap `analysts` to change what the driver improves from — that's the one knob. */
@@ -8772,5 +8609,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 { captureWorkerTraceEvidence as $, sample as $a, LeaderboardScore as $c, DelegationTraceCaps as $d, BusStats as $f, definePersona as $i, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as $l, CheckSource as $n, allWorkersStalled as $o, SandboxRunAbortError as $r, EqualKOnCost as $s, analyzesFindingsReportPrompt as $t, DetachedSessionRefParts as $u, NOTE_MAX_CHARS as A, runBenchmark as Aa, WidenLineage as Ac, DelegateUiAuditConfig as Ad, RecoverRetainedRunResult as Af, recoverRetainedInteractiveRun as Ai, defaultAuditorInstruction as Al, ChatWorkerSeamOptions as An, SupervisorNodeContextSeed as Ao, KnownAgentProfileMaterializationAxis as Ap, discriminatingMeans as Ar, LocalSandboxClientOptions as As, createFileRunContext as At, createDelegateHandler as Au, GitWorkspaceOptions as B, Strategy as Ba, RunPersonified as Bc, DelegationResultPayload as Bd, RetainedRunEffect as Bf, resolveSandboxClient as Bi, WaterfallReport as Bl, spendFromUsageEvents as Bn, CoordinationOwnerId as Bo, promptModelProfileMaterialization as Bp, LocalMcpMaterialization as Br, harvestCorpus as Bs, GraphEdge as Bt, DetachedSessionDelegateOptions as Bu, SurfaceWorkerOut as C, BenchmarkConfig as Ca, TrajectoryReport as Cc, DelegateCodeResult as Cd, RuntimeRunStateError as Cf, reconnectRetainedRun as Ci, renderLeaderboardMarkdown as Cl, DriverAgentOptions as Cn, ObserveSupervisorNodeEvent as Co, replaySpawnTree as Cp, EvolutionAuthor as Cr, classifyDriverFailure as Cs, workerControlLogFile as Ct, DELEGATE_DESCRIPTION as Cu, WorktreeFanoutOptions as D, BenchmarkTaskRow as Da, VerifySpec as Dc, DelegateResearchConfig as Dd, ReconnectRetainedRunOptions as Df, ClaimRetainedInteractiveControlOptions as Di, AuditIntentOptions as Dl, ChatSessionStore as Dn, SupervisorAgentDeps as Do, AssertProfileMaterializationOptions as Dp, EvolutionReport as Dr, defaultSelectWinner as Ds, InMemoryRunContext as Dt, DelegateError as Du, AuthoredHarness as E, BenchmarkStrategySummary as Ea, Verify as Ec, DelegateResearchArgs as Ed, NativeContextContinuationInput as Ef, startRetainedRunInEnvironment as Ei, AuditIntentInput as El, ChatCompletionsTransport as En, ResolvedSupervisorProfile as Eo, AgentProfileMaterializationAxis as Ep, EvolutionGeneration as Er, TerminalDecision as Es, writeWorkerSteer as Et, DelegateArgs as Eu, settledWorkerOut as F, AgenticTool as Fa, LoopShape as Fc, DelegationHistoryArgs as Fd, RetainedRunAdmission as Ff, RetainedInteractiveEnvironmentInput as Fi, areaUnderCurve as Fl, BudgetPoolRestore as Fn, resolveSupervisorProfile as Fo, controlProfileMaterialization as Fp, AuthoredStrategy as Fr, InProcessSandboxClientOptions as Fs, WorktreePatchArtifact as Ft, eventToSnapshot as Fu, gitWorkspace as G, StrategyShotResult as Ga, DefinedLeaderboard as Gc, FeedbackRefersTo as Gd, RetainedRunReplayPoint as Gf, profileOptimizerModelCall as Gi, AnalyzeOnSettleRoute as Gl, assessAuthoredProfile as Gn, PlateauOptions as Go, validateProfileMaterialization as Gp, StdioMcpServerSpec as Gr, observe as Gs, RunGraphTestOptions as Gt, detachedSessionDelegate as Gu, Workspace as H, StrategyCtx as Ha, ShapeBudget as Hc, DelegationStatusArgs as Hd, RetainedRunEventOptions as Hf, PromotionVerdict as Hi, createWaterfallCollector as Hl, ProfileRichness as Hn, PriorCoordination as Ho, promptResourceProfileMaterialization as Hp, McpSpawnFault as Hr, ObserveInput as Hs, GraphNode as Ht, SettleDetachedCoderTurnOptions as Hu, CopyOptions as I, ArtifactHandle as Ia, Outcome as Ic, DelegationHistoryEntry as Id, RetainedRunAdmissionHook as If, RetainedInteractiveRunHandle as Ii, bestSoFar as Il, BudgetReadout as In, supervisorAgent as Io, defineProfileMaterializationContract as Ip, assertStrategyContract as Ir, inProcessSandboxClient as Is, createWorktreeCliExecutor as It, CoderDelegate as Iu, runInWorkspace as J, breadthStrategy as Ja, LeaderboardBenchmarkAdapter as Jc, UiAuditLensFilter as Jd, StartRetainedRunInEnvironmentOptions as Jf, equalKOnCost as Ji, ContinuationInstruction as Jl, supervisorInstructions as Jn, ProgressTrackerOptions as Jo, Deliverable as Jr, CombinatorShape as Js, runGraph as Jt, FleetHandle as Ju, jjWorkspace as K, SurfaceScore as Ka, LeaderboardBenchScore as Kc, ResearchOutputShape as Kd, RetainedRunSnapshot as Kf, assertModelAllowed as Ki, AuthorizeDownMessage as Kl, defaultProfileRichnessThresholds as Kn, ProgressSample as Ko, worktreeCliProfileMaterialization as Kp, connectStdioMcp as Kr, renderReport as Ks, TraversalContinuity as Kt, settleDetachedCoderTurn as Ku, UntrackedCopyStats as L, CorpusReadbackOptions as La, Persona as Lc, DelegationHistoryResult as Ld, RetainedRunCancelOptions as Lf, RetainedInteractiveStartMaterial as Li, plateauLength as Ll, ReservationRejection as Ln, supervisorAgentWithTestBrain as Lo, fullProfileMaterialization as Lp, authorStrategy as Lr, HarvestCorpusOptions as Ls, AgentGraph as Lt, CoderReview as Lu, WorkerEvidenceInput as M, AgenticRunResult as Ma, WinnerStrategy as Mc, DelegateUiAuditRoute as Md, RetainedInteractiveEnvironmentAdmission as Mf, ReconnectRetainedInteractiveRunOptions as Mi, AnytimeStrategySummary as Ml, chatWorkerSeam as Mn, SupervisorToolDescriptor as Mo, ProfileMaterializationIssue as Mp, runStrategyEvolution as Mr, inlineSandboxClient as Ms, PatchDeliverableOptions as Mt, FeedbackEvent as Mu, closingWorkerNote as N, AgenticSurface as Na, DefinePersona as Nc, DelegationError as Nd, RetainedInteractiveIntentAdmission as Nf, RecoverRetainedInteractiveRunOptions as Ni, AnytimeTaskCurve as Nl, createChatSessionStore as Nn, SupervisorToolInvocationContext as No, ValidateProfileMaterializationOptions as Np, selectChampion as Nr, InProcessOnPrompt as Ns, patchDelivered as Nt, FeedbackStore as Nu, worktreeFanout as O, Environment as Oa, Widen as Oc, DelegateResearchResult as Od, RecoverRetainedRunIntentOptions as Of, claimRetainedInteractiveControl as Oi, IntentAudit as Ol, ChatTransportExecutorOptions as On, SupervisorAgentTestDeps as Oo, CanonicalAgentProfileMaterializationAxis as Op, ReproductionCheck as Or, isTerminalDecision as Os, InMemoryRunContextOptions as Ot, DelegateHandlerOptions as Ou, composeWorkerEvidence as P, AgenticTask as Pa, DefinePersonaInput as Pc, DelegationFeedbackSnapshot as Pd, RetainedInteractiveStartedAdmission as Pf, RetainedInteractiveAdmissionHook as Pi, anytimeReport as Pl, BudgetPool as Pn, assertCoordinationBinding as Po, assertProfileMaterialization as Pp, AuthorStrategyOptions as Pr, InProcessPromptCtx as Ps, WorktreeCliExecutorOptions as Pt, InMemoryFeedbackStore as Pu, WorkerToolTraceArtifact as Q, runAgentic as Qa, LeaderboardScenario as Qc, DELEGATION_TRACE_MAX_SPANS as Qd, BusRecord as Qf, registerShape as Qi, CoordinationToolsOptions as Ql, CheckRunner as Qn, allOf as Qo, SandboxRun as Qr, EqualKArm as Qs, RegisteredPrompt as Qt, createSiblingSandboxExecutor as Qu, copyUntrackedIntoClone as R, RunAgenticOptions as Ra, PersonaContext as Rc, DelegationProfile as Rd, RetainedRunCancellation as Rf, StartRetainedInteractiveRunOptions as Ri, renderAnytimeTable as Rl, ReservationTicket as Rn, CoordinationDeliveryEvidence as Ro, profileMaterializationAxes$1 as Rp, strategyAuthorContract as Rr, HarvestFailure as Rs, EdgeDeliveryOutcome as Rt, CoderReviewer as Ru, SurfaceWorkerConfig as S, BenchmarkCell as Sa, TrajectoryNode as Sc, DelegateCodeConfig as Sd, RetainedRunDispatchBindingError as Sf, acquireSandbox as Si, renderLeaderboardHtml as Sl, serveCoordinationMcp as Sn, DriveHarnessOwnerContext as So, pendingWaits as Sp, EvolutionArchiveNode as Sr, DriverRetryPolicy as Ss, workerCancellationsDir as St, createMcpServer as Su, superviseSurface as T, BenchmarkReport as Ta, TrajectoryReportOptions as Tc, DelegateFeedbackResult as Td, NativeContextContinuationExecution as Tf, startRetainedRun as Ti, renderPairwiseMarkdown as Tl, finalizeBestDelivered as Tn, ResolveSupervisorTools as To, AGENT_PROFILE_MATERIALIZATION_AXES as Tp, EvolutionCandidate as Tr, TERMINAL_DECISIONS as Ts, workerInboxFileFromEventDir as Tt, DELEGATE_TOOL_NAME as Tu, WorkspaceCommit as U, StrategyMessage as Ua, ShapeContext as Uc, DelegationStatusResult as Ud, RetainedRunHandle as Uf, promotionGate as Ui, AnalystFindingEvent as Ul, ProfileRichnessThresholds as Un, AllWorkersStalledOptions as Uo, renderProfileMaterializationIssues as Up, McpToolDescriptor as Ur, ObserveOptions as Us, GraphResult as Ut, UiAuditorDelegate as Uu, Shell as V, StrategyArtifacts as Va, RunPersonifiedOptions as Vc, DelegationStatus as Vd, RetainedRunEnvironmentAdmission as Vf, PromotionGateOptions as Vi, WaterfallSpan as Vl, AuthoredProfile as Vn, FileCoordinationLog as Vo, promptOnlyProfileMaterialization as Vp, MaterializeLocalMcpOptions as Vr, Observation as Vs, GraphEdgeCapError as Vt, DetachedWinnerSelection as Vu, WorkspaceRun as W, StrategyResult as Wa, ShapeRegistry as Wc, FeedbackRating as Wd, RetainedRunIntentAdmission as Wf, profileChatClient as Wi, AnalystRegistry as Wl, asAuthoredProfile as Wn, NoProgressForOptions as Wo, sandboxActProfileMaterialization as Wp, StdioMcpConnection as Wr, defaultAnalystInstruction as Ws, RunGraphOptions as Wt, coderTaskFromArgs as Wu, analyzeTrace as X, depthStrategy as Xa, LeaderboardIterationInfo as Xc, CappedDelegationTrace as Xd, CoderOutput as Xf, builtinShapes as Xi, CoordinationEvent as Xl, CheckOutcome as Xn, StopDecision as Xo, OpenSandboxRunOptions as Xr, CorpusFilter as Xs, PromptHandle as Xt, SiblingSandboxExecutorOptions as Xu, TrajectoryAnalysis as Y, defineStrategy as Ya, LeaderboardFlagSpec as Yc, UiAuditorDelegationOutput as Yd, StartRetainedRunOptions as Yf, trajectoryReport as Yi, ContinuityMode as Yl, CheckExecChannel as Yn, ProgressView as Yo, OpenSandboxRunBeforeStartContext as Yr, Corpus as Ys, runGraphWithTestBrain as Yt, FleetWorkspaceExecutorOptions as Yu, WORKER_TOOL_TRACE_SCHEMA_VERSION as Z, refine as Za, LeaderboardRunContext as Zc, DELEGATION_TRACE_MAX_BYTES as Zd, BusEvent as Zf, createShapeRegistry as Zi, CoordinationTools as Zl, CheckRunContext as Zn, StopRule as Zo, OpenSandboxRunPromptOptions as Zr, CorpusRecord as Zs, PromptRegistry as Zt, createFleetWorkspaceExecutor as Zu, boxSurfaceReader as _, registryScopeAnalyst as _a, RenderCorpusToInstructionsOptions as _c, DelegationTaskQueueOptions as _d, NotFoundError as _f, sumSandboxUsage as _i, PairwiseVerdict as _l, rollingDispatch as _n, supervise as _o, SpawnForestMissingTree as _p, selectBestIndex as _r, runFinalizer as _s, supervisorRunDir as _t, createCoordinationTools as _u, SandboxInstance$1 as a, flatWidenGate as aa, FanoutWinnerSelector as ac, createDetachedTurnResumeDriver as ad, createDelegationTraceCollector as af, SandboxLineage as ai, CompletionVerdict as al, kernelPromptRegistry as an, SuperviseOptionsForDispatch as ao, watchTrace as ap, StructuralRolloutResult as ar, SupervisorSpanAttributes as as, createScope as at, Question as au, SuperviseSurfaceOptions as b, createMcpEnvironment as ba, ScopeWidenGate as bc, hashIdempotencyInput as bd, RetainedInteractiveBindingError as bf, probeSandboxCapabilities as bi, leaderboard as bl, delegate as bn, CoordinationBinding as bo, loadSpawnForest as bp, ChampionPick as br, DriverAttemptsExhaustedError as bs, workerCancelRequestsFile as bt, McpServerOptions as bu, VerifierEnvironmentOptions as c, pipeline as ca, LoopUntilSpec as cc, parseDetachedSessionRef as cd, DelegationStore as cf, createSandboxLineage as ci, sentinelCompletion as cl, supervisorPolicyPrompt as cn, superviseDispatch as co, gateOnDeliverable as cp, compareCheckOutcomes as cr, SupervisorSpanRecorder as cs, WorkerCancellation as ct, QuestionOption as cu, HarvestSurfaceDiffsOptions as d, widen as da, PanelJudge as dc, DelegationRecord as dd, InMemoryDelegationStore as df, assertSandboxServedModel as di, GroupOf as dl, DispatchStopReason as dn, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as do, FileSpawnJournal as dp, defaultStructuralRolloutPolicy as dr, FinalizeContext as ds, legacySupervisorRunDir as dt, QuestionUrgency as du, runPersonified as ea, EqualKOnCostOptions as ec, DetachedTurn as ed, DelegationTraceCollector as ef, TurnResult as ei, LeaderboardSpec as el, createPromptRegistry as en, sampleThenRefine as eo, EventBus as ep, CheckSourceCtx as er, anyOf as es, parseWorkerToolTraceArtifact as et, DownMessageAuthorizationInput as eu, SurfaceDiff as f, CreateScopeAnalystOptions as fa, PanelSpec as fc, DelegationResumeContext as fd, AgentEvalError$1 as ff, createSandboxToolPartState as fi, Interval as fl, DispatchUnit as fn, DeliverableResolutionInput as fo, InMemoryResultBlobStore as fp, filterAuthoredAsserts as fr, FinalizerSettled as fs, legacySupervisorRunsRoot as ft, SettledWorker as fu, WatchedSurface as g, createScopeAnalyst as ga, RenderCorpusToInstructions as gc, DelegationTaskQueue as gd, JudgeError as gf, sandboxEventServedBackend as gi, PairwiseOptions as gl, queueOf as gn, SuperviseTestOptions as go, SpawnForestInDoubtNode as gp, sandboxCheckRunner as gr, pickBestDelivered as gs, safeWorkerFile as gt, canonicalFindingEvent as gu, SurfaceReader as h, buildSteerContext as ha, PipelineStage as hc, DelegationRunContext as hd, ConfigError as hf, mapSandboxToolEvent as hi, LeaderboardRow as hl, freeSlots as hn, SuperviseRegistryTable as ho, SpawnForestEvent as hp, resolveEntrySymbol as hr, collectDelivered as hs, readWorkerSteerRequests as ht, WorkerWatchOptions as hu, SandboxEvent$1 as i, fanout as ia, FanoutSynthesis as ic, RunDetachedTurnOptions as id, composeLoopTraceEmitters as if, ForkCapableBox as ii, CompletionPolicy as il, formatPromptHandle as in, SuperviseDispatchOptions as io, defaultToolDetectors as ip, StructuralRolloutPolicy as ir, sampleFromSettled as is, ScopeArgs as it, MakeWorkerAgent as iu, VERIFY_TAIL_CHARS as j, AgenticOptions as ja, WidenSpec as jc, DelegateUiAuditResult as jd, RetainedInteractiveAdmission as jf, startRetainedInteractiveRun as ji, AnytimeReport as jl, chatTransportExecutor as jn, SupervisorProfile as jo, ProfileMaterializationContract as jp, pickChampion as jr, localSandboxClient as js, createInMemoryRunContext as jt, validateDelegateArgs as ju, EVIDENCE_MAX_CHARS as k, printBenchmarkReport as ka, WidenDecision as kc, DelegateUiAuditArgs as kd, RecoverRetainedRunOptions as kf, reconnectRetainedInteractiveRun as ki, auditIntent as kl, ChatTransportTool as kn, SupervisorNodeContext as ko, DefineProfileMaterializationContractOptions as kp, StrategyEvolutionConfig as kr, runAgentRounds as ks, RunContext as kt, DelegateResult as ku, createVerifierEnvironment as l, selectValidWinner as la, LoopUntilState as lc, runDetachedTurn as ld, FileDelegationStore as lf, SandboxServedBackend as li, stopSentinel as ll, ConcurrencyCaps as ln, AuthorizedSpawn as lo, mapExecutorResult as lp, composeCheckSources as lr, createSupervisorSpanRecorder as ls, WorkerSteerRequest as lt, QuestionPolicy as lu, SurfaceReadOutcome as m, assertTraceDerivedFindings as ma, Pipeline as mc, DelegationResumeTick as md, BackendTransportError as mf, mapSandboxEvent as mi, LeaderboardOptions as ml, effectiveConcurrency as mn, SuperviseRegistry as mo, SpawnForest as mp, officialChecksFromMeta as mr, bestDelivered as ms, readWorkerCancellation as mt, WorkerSpawnContext as mu, AnalystFinding$1 as n, InMemoryCorpus as na, Fanout as nc, DriveTurnCapableBox as nd, buildDelegationTraceSpans as nf, BranchCapableBox as ni, CompletionAnalyst as nl, dumbContinuationFailPrompt as nn, LoopDispatchOptions as no, createEventBus as np, StructuralRolloutConfig as nr, noProgressFor as ns, createRootHandle as nt, DownMessageDeliveryOutcome as nu, computeFindingId$1 as o, loopUntil as oa, FlatWidenGate as oc, detachedTurnEvents as od, DelegationPersistenceError as of, SandboxLineageHandle as oi, completionAuthorizes as ol, naiveContinuationPrompt as on, loopCampaignDispatch as oo, DeliverableSpec as op, VisibleCheck as or, SupervisorSpanOptions as os, settledToIteration as ot, QuestionDecision as ou, SurfaceReadBox as p, RegistryAnalyzeProjection as pa, PanelVerdict as pc, DelegationResumeDriver as pd, AgentEvalErrorCode as pf, extractLlmCallEvent as pi, Leaderboard as pl, RollingDispatchOptions as pn, SuperviseOptions as po, InMemorySpawnJournal as pp, modelAuthoredChecks as pr, SupervisorFinalizer as ps, readWorkerCancelRequests as pt, WorkerResumeContext as pu, localShell as q, adaptiveRefine as qa, LeaderboardBenchTask as qc, ResearchSource as qd, RetainedRunStartMaterial as qf, assertProfileModelsAllowed as qi, AuthorizedDownMessage as ql, profileRichnessFinding as qn, ProgressTracker as qo, materializeLocalMcp as qr, AssertTraceDerivedFindings as qs, defaultEdgeTraversalCap as qt, DelegationExecutor as qu, CreateSandboxOptions$1 as r, renderCorpusToInstructions as ra, FanoutOptions as rc, DriveTurnTick as rd, capDelegationTrace as rf, CheckpointCapableBox as ri, CompletionEvidence as rl, dumbContinuationPassPrompt as rn, LoopOptionsForDispatch as ro, WatchTraceOptions as rp, StructuralRolloutMessage as rr, plateau as rs, createSupervisor as rt, DownMessageEvent as ru, makeFinding$1 as s, panel as sa, LoopUntil as sc, formatDetachedSessionRef as sd, DelegationStateCorruptError as sf, SessionCapableBox as si, deterministicCompletion as sl, promptHandle as sn, loopDispatch as so, ExecutorResultMapping as sp, canDisplace as sr, SupervisorSpanOutcome as ss, WorkerCancelRequest as st, QuestionLevel as su, AgentProfile$2 as t, FileCorpus as ta, EqualKVerdict as tc, DetachedTurnResumeDriverOptions as td, DelegationTraceSpan as tf, openSandboxRun as ti, defineLeaderboard as tl, delegatesWorkerBriefPrompt as tn, LoopCampaignDispatchOptions as to, PublishOptions as tp, RepairStop as tr, createProgressTracker as ts, workerTraceAnalysisStore as tt, DownMessageDeliveryAttempt as tu, BoxSurfaceReaderOptions as u, verify as ua, Panel as uc, DelegationArgs as ud, FileDelegationStoreOptions as uf, SandboxToolPartState as ui, AxisScoresOf as ul, DispatchReport as un, AuthorizedSpawnContext as uo, FileResultBlobStore as up, defaultExtractCandidate as ur, DeliveredOutput as us, cancelWorker as ut, QuestionRecord as uu, fsSurfaceReader as v, McpEndpoint as va, ScopeAnalyst as vc, SubmitInput as vd, PlannerError as vf, CriuCapableClient as vi, ProfileKeyOf as vl, DelegateOptions as vn, superviseWithTestBrain as vo, SpawnForestNode as vp, structuralRollout as vr, DriverAttemptRecord as vs, supervisorRunsRoot as vt, normalizeAnalyzeOnSettle as vu, failuresAnalyst as w, BenchmarkLift as wa, TrajectoryReportFn as wc, DelegateFeedbackArgs as wd, ValidationError as wf, recoverRetainedRun as wi, renderLeaderboardSvg as wl, driverAgent as wn, ResolveDriveHarness as wo, contentAddress as wp, EvolutionBandInfo as wr, RunAgentRoundsOptions as ws, workerInboxFile as wt, DELEGATE_INPUT_SCHEMA as wu, SuperviseSurfaceResult as x, sanitizeMcpToolSchema as xa, SteerContext as xc, DelegateCodeArgs as xd, RetainedRunAdmissionError as xf, AcquireOptions as xi, pairwiseSignificance as xl, CoordinationMcpHandle as xn, DriveHarness as xo, materializeTreeView as xp, ChampionPolicy as xr, DriverProgressMark as xs, workerCancellationFile as xt, createInProcessTransport as xu, harvestSurfaceDiffs as y, McpEnvironmentOptions as ya, ScopeAnalyzeInput as yc, SubmitOutput as yd, RetainedInteractiveAdmissionError as yf, SandboxCapabilities as yi, ScoreOf as yl, defaultDelegateBudget as yn, workerFromBackend as yo, SpawnForestTree as yp, visibleCheckScore as yr, DriverAttemptStop as ys, supervisorWorkersDir as yt, McpServer as yu, withUntrackedArtifacts as z, ShotSpec as za, PersonaExecutors as zc, DelegationProgress as zd, RetainedRunDispatchedAdmission as zf, ResolveSandboxClientOptions as zi, WaterfallCollector as zl, createBudgetPool as zn, CoordinationLog as zo, promptControlProfileMaterialization as zp, strategyAuthorSystemPrompt as zr, HarvestReport as zs, EdgeTraversal as zt, DelegateRunCtx as zu };
-//# sourceMappingURL=index-C2caGomG.d.ts.map
+export { WorkerToolTraceArtifact as $, loopDispatch as $a, completionAuthorizes as $c, DelegationTraceCollector as $d, AGENT_PROFILE_MATERIALIZATION_AXES as $f, panel as $i, MakeWorkerAgent as $l, assessAuthoredProfile as $n, SupervisorSpanOptions as $o, StdioMcpServerSpec as $r, FlatWidenGate as $s, RunGraphTestOptions as $t, DetachedTurn as $u, EVIDENCE_MAX_CHARS as A, RunAgenticOptions as Aa, Persona as Ac, DelegateUiAuditResult as Ad, createEventBus as Af, startRetainedInteractiveRun as Ai, plateauLength as Al, serveCoordinationMcp as An, supervisorAgentWithTestBrain as Ao, EvolutionArchiveNode as Ar, HarvestCorpusOptions as As, workerCancellationsDir as At, validateDelegateArgs as Au, withUntrackedArtifacts as B, breadthStrategy as Ba, LeaderboardBenchTask as Bc, DelegationStatus as Bd, InMemoryResultBlobStore as Bf, equalKOnCost as Bi, AuthorizeDownMessage as Bl, chatWorkerSeam as Bn, ProgressTracker as Bo, runStrategyEvolution as Br, AssertTraceDerivedFindings as Bs, PatchDeliverableOptions as Bt, DetachedWinnerSelection as Bu, SurfaceWorkerOut as C, AgenticOptions as Ca, WidenLineage as Cc, DelegateFeedbackArgs as Cd, ValidationError as Cf, recoverRetainedRun as Ci, defaultAuditorInstruction as Cl, freeSlots as Cn, SupervisorNodeContextSeed as Co, resolveEntrySymbol as Cr, LocalSandboxClientOptions as Cs, runCancellationFile as Ct, DELEGATE_INPUT_SCHEMA as Cu, AuthoredHarness as D, AgenticTool as Da, DefinePersonaInput as Dc, DelegateResearchResult as Dd, BusStats as Df, claimRetainedInteractiveControl as Di, anytimeReport as Dl, defaultDelegateBudget as Dn, assertCoordinationBinding as Do, visibleCheckScore as Dr, InProcessPromptCtx as Ds, supervisorWorkersDir as Dt, DelegateHandlerOptions as Du, superviseSurface as E, AgenticTask as Ea, DefinePersona as Ec, DelegateResearchConfig as Ed, BusRecord as Ef, ClaimRetainedInteractiveControlOptions as Ei, AnytimeTaskCurve as El, DelegateOptions as En, SupervisorToolInvocationContext as Eo, structuralRollout as Er, InProcessOnPrompt as Es, supervisorRunsRoot as Et, DelegateError as Eu, composeWorkerEvidence as F, StrategyMessage as Fa, ShapeBudget as Fc, DelegationHistoryEntry as Fd, ExecutorResultMapping as Ff, promotionGate as Fi, createWaterfallCollector as Fl, ChatSessionStore as Fn, PriorCoordination as Fo, EvolutionReport as Fr, ObserveInput as Fs, InMemoryRunContext as Ft, CoderDelegate as Fu, WorkspaceRun as G, sample as Ga, LeaderboardScenario as Gc, ResearchOutputShape as Gd, SpawnForestMissingTree as Gf, definePersona as Gi, CoordinationStats as Gl, ReservationRejection as Gn, allOf as Go, authorStrategy as Gr, EqualKArm as Gs, AgentGraph as Gt, settleDetachedCoderTurn as Gu, Shell as H, depthStrategy as Ha, LeaderboardFlagSpec as Hc, DelegationStatusResult as Hd, SpawnForest as Hf, builtinShapes as Hi, ContinuationInstruction as Hl, BudgetPool as Hn, ProgressView as Ho, AuthorStrategyOptions as Hr, Corpus as Hs, WorktreeCliExecutorOptions as Ht, UiAuditorDelegate as Hu, settledWorkerOut as I, StrategyResult as Ia, ShapeContext as Ic, DelegationHistoryResult as Id, gateOnDeliverable as If, profileChatClient as Ii, AnalystFindingEvent as Il, ChatTransportExecutorOptions as In, AllWorkersStalledOptions as Io, ReproductionCheck as Ir, ObserveOptions as Is, InMemoryRunContextOptions as It, CoderReview as Iu, localShell as J, LoopDispatchOptions as Ja, defineLeaderboard as Jc, UiAuditorDelegationOutput as Jd, loadSpawnForest as Jf, InMemoryCorpus as Ji, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as Jl, spendFromUsageEvents as Jn, createProgressTracker as Jo, LocalMcpMaterialization as Jr, EqualKVerdict as Js, GraphEdge as Jt, FleetWorkspaceExecutorOptions as Ju, gitWorkspace as K, sampleThenRefine as Ka, LeaderboardScore as Kc, ResearchSource as Kd, SpawnForestNode as Kf, runPersonified as Ki, CoordinationTools as Kl, ReservationTicket as Kn, allWorkersStalled as Ko, strategyAuthorContract as Kr, EqualKOnCost as Ks, EdgeDeliveryOutcome as Kt, DelegationExecutor as Ku, CopyOptions as L, StrategyShotResult as La, ShapeRegistry as Lc, DelegationProfile as Ld, mapExecutorResult as Lf, profileOptimizerModelCall as Li, AnalystLensOutput as Ll, ChatTransportTool as Ln, NoProgressForOptions as Lo, StrategyEvolutionConfig as Lr, defaultAnalystInstruction as Ls, RunContext as Lt, CoderReviewer as Lu, VERIFY_TAIL_CHARS as M, Strategy as Ma, PersonaExecutors as Mc, DelegationError as Md, defaultToolDetectors as Mf, resolveSandboxClient as Mi, WaterfallCollector as Ml, driverAgent as Mn, CoordinationLog as Mo, EvolutionBandInfo as Mr, HarvestReport as Ms, workerInboxFile as Mt, FeedbackStore as Mu, WorkerEvidenceInput as N, StrategyArtifacts as Na, RunPersonified as Nc, DelegationFeedbackSnapshot as Nd, watchTrace as Nf, PromotionGateOptions as Ni, WaterfallReport as Nl, finalizeBestDelivered as Nn, CoordinationOwnerId as No, EvolutionCandidate as Nr, harvestCorpus as Ns, workerInboxFileFromEventDir as Nt, InMemoryFeedbackStore as Nu, WorktreeFanoutOptions as O, ArtifactHandle as Oa, LoopShape as Oc, DelegateUiAuditArgs as Od, EventBus as Of, reconnectRetainedInteractiveRun as Oi, areaUnderCurve as Ol, delegate as On, resolveSupervisorProfile as Oo, ChampionPick as Or, InProcessSandboxClientOptions as Os, workerCancelRequestsFile as Ot, DelegateResult as Ou, closingWorkerNote as P, StrategyCtx as Pa, RunPersonifiedOptions as Pc, DelegationHistoryArgs as Pd, DeliverableSpec as Pf, PromotionVerdict as Pi, WaterfallSpan as Pl, ChatCompletionsTransport as Pn, FileCoordinationLog as Po, EvolutionGeneration as Pr, Observation as Ps, writeWorkerSteer as Pt, eventToSnapshot as Pu, WORKER_TOOL_TRACE_SCHEMA_VERSION as Q, loopCampaignDispatch as Qa, CompletionVerdict as Qc, DelegationTraceCaps as Qd, contentAddress as Qf, loopUntil as Qi, DownMessageEvent as Ql, asAuthoredProfile as Qn, SupervisorSpanAttributes as Qo, StdioMcpConnection as Qr, FanoutWinnerSelector as Qs, RunGraphOptions as Qt, DetachedSessionRefParts as Qu, UntrackedCopyStats as R, SurfaceScore as Ra, DefinedLeaderboard as Rc, DelegationProgress as Rd, FileResultBlobStore as Rf, assertModelAllowed as Ri, AnalystRegistry as Rl, ChatWorkerSeamOptions as Rn, PlateauOptions as Ro, discriminatingMeans as Rr, observe as Rs, createFileRunContext as Rt, DelegateRunCtx as Ru, SurfaceWorkerConfig as S, runBenchmark as Sa, WidenDecision as Sc, DelegateCodeResult as Sd, RuntimeRunStateError as Sf, reconnectRetainedRun as Si, auditIntent as Sl, effectiveConcurrency as Sn, SupervisorNodeContext as So, officialChecksFromMeta as Sr, runAgentRounds as Ss, runCancelRequestFile as St, DELEGATE_DESCRIPTION as Su, failuresAnalyst as T, AgenticSurface as Ta, WinnerStrategy as Tc, DelegateResearchArgs as Td, BusEvent as Tf, startRetainedRunInEnvironment as Ti, AnytimeStrategySummary as Tl, rollingDispatch as Tn, SupervisorToolDescriptor as To, selectBestIndex as Tr, inlineSandboxClient as Ts, supervisorRunDir as Tt, DelegateArgs as Tu, Workspace as U, refine as Ua, LeaderboardIterationInfo as Uc, FeedbackRating as Ud, SpawnForestEvent as Uf, createShapeRegistry as Ui, ContinuityMode as Ul, BudgetPoolRestore as Un, StopDecision as Uo, AuthoredStrategy as Ur, CorpusFilter as Us, WorktreePatchArtifact as Ut, coderTaskFromArgs as Uu, GitWorkspaceOptions as V, defineStrategy as Va, LeaderboardBenchmarkAdapter as Vc, DelegationStatusArgs as Vd, InMemorySpawnJournal as Vf, trajectoryReport as Vi, AuthorizedDownMessage as Vl, createChatSessionStore as Vn, ProgressTrackerOptions as Vo, selectChampion as Vr, CombinatorShape as Vs, patchDelivered as Vt, SettleDetachedCoderTurnOptions as Vu, WorkspaceCommit as W, runAgentic as Wa, LeaderboardRunContext as Wc, FeedbackRefersTo as Wd, SpawnForestInDoubtNode as Wf, registerShape as Wi, CoordinationEvent as Wl, BudgetReadout as Wn, StopRule as Wo, assertStrategyContract as Wr, CorpusRecord as Ws, createWorktreeCliExecutor as Wt, detachedSessionDelegate as Wu, TrajectoryAnalysis as X, SuperviseDispatchOptions as Xa, CompletionEvidence as Xc, DELEGATION_TRACE_MAX_BYTES as Xd, pendingWaits as Xf, fanout as Xi, DownMessageDeliveryAttempt as Xl, ProfileRichness as Xn, plateau as Xo, McpSpawnFault as Xr, FanoutOptions as Xs, GraphNode as Xt, createFleetWorkspaceExecutor as Xu, runInWorkspace as Y, LoopOptionsForDispatch as Ya, CompletionAnalyst as Yc, CappedDelegationTrace as Yd, materializeTreeView as Yf, renderCorpusToInstructions as Yi, DownMessageAuthorizationInput as Yl, AuthoredProfile as Yn, noProgressFor as Yo, MaterializeLocalMcpOptions as Yr, Fanout as Ys, GraphEdgeCapError as Yt, SiblingSandboxExecutorOptions as Yu, analyzeTrace as Z, SuperviseOptionsForDispatch as Za, CompletionPolicy as Zc, DELEGATION_TRACE_MAX_SPANS as Zd, replaySpawnTree as Zf, flatWidenGate as Zi, DownMessageDeliveryOutcome as Zl, ProfileRichnessThresholds as Zn, sampleFromSettled as Zo, McpToolDescriptor as Zr, FanoutSynthesis as Zs, GraphResult as Zt, createSiblingSandboxExecutor as Zu, boxSurfaceReader as _, BenchmarkReport as _a, TrajectoryReportFn as _c, SubmitInput as _d, PlannerError as _f, CriuCapableClient as _i, renderLeaderboardSvg as _l, ConcurrencyCaps as _n, ResolveDriveHarness as _o, renderProfileMaterializationIssues as _p, composeCheckSources as _r, RunAgentRoundsOptions as _s, readRunCancelRequest as _t, normalizeAnalyzeOnSettle as _u, SandboxInstance$1 as a, RegistryAnalyzeProjection as aa, PanelSpec as ac, detachedTurnEvents as ad, DelegationPersistenceError as af, OpenSandboxRunPromptOptions as ai, Interval as al, PromptRegistry as an, SuperviseOptions as ao, ProfileMaterializationContract as ap, CheckRunContext as ar, FinalizerSettled as as, ScopeArgs as at, QuestionRecord as au, SuperviseSurfaceOptions as b, Environment as ba, VerifySpec as bc, DelegateCodeArgs as bd, RetainedRunAdmissionError as bf, AcquireOptions as bi, AuditIntentOptions as bl, DispatchUnit as bn, SupervisorAgentDeps as bo, worktreeCliProfileMaterialization as bp, filterAuthoredAsserts as br, defaultSelectWinner as bs, readWorkerCancellation as bt, createInProcessTransport as bu, VerifierEnvironmentOptions as c, createScopeAnalyst as ca, PipelineStage as cc, runDetachedTurn as cd, FileDelegationStore as cf, TurnResult as ci, LeaderboardRow as cl, createPromptRegistry as cn, SuperviseTestOptions as co, assertProfileMaterialization as cp, CheckSourceCtx as cr, collectDelivered as cs, RunCancelRequest as ct, SpawnPreflight as cu, HarvestSurfaceDiffsOptions as d, McpEnvironmentOptions as da, ScopeAnalyst as dc, DelegationResumeContext as dd, AgentEvalError$1 as df, CheckpointCapableBox as di, ProfileKeyOf as dl, dumbContinuationPassPrompt as dn, workerFromBackend as do, fullProfileMaterialization as dp, StructuralRolloutMessage as dr, DriverAttemptRecord as ds, WorkerCancellation as dt, SpawnRefusalCause as du, pipeline as ea, LoopUntil as ec, DetachedTurnResumeDriverOptions as ed, DelegationTraceSpan as ef, connectStdioMcp as ei, deterministicCompletion as el, TraversalContinuity as en, superviseDispatch as eo, AgentProfileMaterializationAxis as ep, defaultProfileRichnessThresholds as er, SupervisorSpanOutcome as es, captureWorkerTraceEvidence as et, Question as eu, SurfaceDiff as f, createMcpEnvironment as fa, ScopeAnalyzeInput as fc, DelegationResumeDriver as fd, AgentEvalErrorCode as ff, ForkCapableBox as fi, ScoreOf as fl, formatPromptHandle as fn, CoordinationBinding as fo, profileMaterializationAxes$1 as fp, StructuralRolloutPolicy as fr, DriverAttemptStop as fs, WorkerSteerRequest as ft, WorkerResumeContext as fu, WatchedSurface as g, BenchmarkLift as ga, TrajectoryReport as gc, DelegationTaskQueueOptions as gd, NotFoundError as gf, createSandboxLineage as gi, renderLeaderboardMarkdown as gl, supervisorPolicyPrompt as gn, ObserveSupervisorNodeEvent as go, promptResourceProfileMaterialization as gp, compareCheckOutcomes as gr, classifyDriverFailure as gs, legacySupervisorRunsRoot as gt, createCoordinationTools as gu, SurfaceReader as h, BenchmarkConfig as ha, TrajectoryNode as hc, DelegationTaskQueue as hd, JudgeError as hf, SessionCapableBox as hi, renderLeaderboardHtml as hl, promptHandle as hn, DriveHarnessOwnerContext as ho, promptOnlyProfileMaterialization as hp, canDisplace as hr, DriverRetryPolicy as hs, legacySupervisorRunDir as ht, canonicalFindingEvent as hu, SandboxEvent$1 as i, CreateScopeAnalystOptions as ia, PanelJudge as ic, createDetachedTurnResumeDriver as id, createDelegationTraceCollector as if, OpenSandboxRunOptions as ii, GroupOf as il, PromptHandle as in, DeliverableResolutionInput as io, KnownAgentProfileMaterializationAxis as ip, CheckOutcome as ir, FinalizeContext as is, createSupervisor as it, QuestionPolicy as iu, NOTE_MAX_CHARS as j, ShotSpec as ja, PersonaContext as jc, DelegateUiAuditRoute as jd, WatchTraceOptions as jf, ResolveSandboxClientOptions as ji, renderAnytimeTable as jl, DriverAgentOptions as jn, CoordinationDeliveryEvidence as jo, EvolutionAuthor as jr, HarvestFailure as js, workerControlLogFile as jt, FeedbackEvent as ju, worktreeFanout as k, CorpusReadbackOptions as ka, Outcome as kc, DelegateUiAuditConfig as kd, PublishOptions as kf, recoverRetainedInteractiveRun as ki, bestSoFar as kl, CoordinationMcpHandle as kn, supervisorAgent as ko, ChampionPolicy as kr, inProcessSandboxClient as ks, workerCancellationFile as kt, createDelegateHandler as ku, createVerifierEnvironment as l, registryScopeAnalyst as la, RenderCorpusToInstructions as lc, DelegationArgs as ld, FileDelegationStoreOptions as lf, openSandboxRun as li, PairwiseOptions as ll, delegatesWorkerBriefPrompt as ln, supervise as lo, controlProfileMaterialization as lp, RepairStop as lr, pickBestDelivered as ls, RunCancellation as lt, SpawnPreflightContext as lu, SurfaceReadOutcome as m, BenchmarkCell as ma, SteerContext as mc, DelegationRunContext as md, ConfigError as mf, SandboxLineageHandle as mi, pairwiseSignificance as ml, naiveContinuationPrompt as mn, DriveHarness as mo, promptModelProfileMaterialization as mp, VisibleCheck as mr, DriverProgressMark as ms, cancelWorker as mt, WorkerWatchOptions as mu, AnalystFinding$1 as n, verify as na, LoopUntilState as nc, DriveTurnTick as nd, capDelegationTrace as nf, Deliverable as ni, stopSentinel as nl, runGraph as nn, AuthorizedSpawnContext as no, CanonicalAgentProfileMaterializationAxis as np, supervisorInstructions as nr, createSupervisorSpanRecorder as ns, workerTraceAnalysisStore as nt, QuestionLevel as nu, computeFindingId$1 as o, assertTraceDerivedFindings as oa, PanelVerdict as oc, formatDetachedSessionRef as od, DelegationStateCorruptError as of, SandboxRun as oi, Leaderboard as ol, RegisteredPrompt as on, SuperviseRegistry as oo, ProfileMaterializationIssue as op, CheckRunner as or, SupervisorFinalizer as os, createScope as ot, QuestionUrgency as ou, SurfaceReadBox as p, sanitizeMcpToolSchema as pa, ScopeWidenGate as pc, DelegationResumeTick as pd, BackendTransportError as pf, SandboxLineage as pi, leaderboard as pl, kernelPromptRegistry as pn, CoordinationVerbs as po, promptControlProfileMaterialization as pp, StructuralRolloutResult as pr, DriverAttemptsExhaustedError as ps, cancelRun as pt, WorkerSpawnContext as pu, jjWorkspace as q, LoopCampaignDispatchOptions as qa, LeaderboardSpec as qc, UiAuditLensFilter as qd, SpawnForestTree as qf, FileCorpus as qi, CoordinationToolsOptions as ql, createBudgetPool as qn, anyOf as qo, strategyAuthorSystemPrompt as qr, EqualKOnCostOptions as qs, EdgeTraversal as qt, FleetHandle as qu, CreateSandboxOptions$1 as r, widen as ra, Panel as rc, RunDetachedTurnOptions as rd, composeLoopTraceEmitters as rf, OpenSandboxRunBeforeStartContext as ri, AxisScoresOf as rl, runGraphWithTestBrain as rn, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as ro, DefineProfileMaterializationContractOptions as rp, CheckExecChannel as rr, DeliveredOutput as rs, createRootHandle as rt, QuestionOption as ru, makeFinding$1 as s, buildSteerContext as sa, Pipeline as sc, parseDetachedSessionRef as sd, DelegationStore as sf, SandboxRunAbortError as si, LeaderboardOptions as sl, analyzesFindingsReportPrompt as sn, SuperviseRegistryTable as so, ValidateProfileMaterializationOptions as sp, CheckSource as sr, bestDelivered as ss, settledToIteration as st, SettledWorker as su, AgentProfile$2 as t, selectValidWinner as ta, LoopUntilSpec as tc, DriveTurnCapableBox as td, buildDelegationTraceSpans as tf, materializeLocalMcp as ti, sentinelCompletion as tl, defaultEdgeTraversalCap as tn, AuthorizedSpawn as to, AssertProfileMaterializationOptions as tp, profileRichnessFinding as tr, SupervisorSpanRecorder as ts, parseWorkerToolTraceArtifact as tt, QuestionDecision as tu, BoxSurfaceReaderOptions as u, McpEndpoint as ua, RenderCorpusToInstructionsOptions as uc, DelegationRecord as ud, InMemoryDelegationStore as uf, BranchCapableBox as ui, PairwiseVerdict as ul, dumbContinuationFailPrompt as un, superviseWithTestBrain as uo, defineProfileMaterializationContract as up, StructuralRolloutConfig as ur, runFinalizer as us, WorkerCancelRequest as ut, SpawnRefusal as uu, fsSurfaceReader as v, BenchmarkStrategySummary as va, TrajectoryReportOptions as vc, SubmitOutput as vd, RetainedInteractiveAdmissionError as vf, SandboxCapabilities as vi, renderPairwiseMarkdown as vl, DispatchReport as vn, ResolveSupervisorTools as vo, sandboxActProfileMaterialization as vp, defaultExtractCandidate as vr, TERMINAL_DECISIONS as vs, readRunCancellation as vt, McpServer as vu, analystsFromRegistry as w, AgenticRunResult as wa, WidenSpec as wc, DelegateFeedbackResult as wd, CoderOutput as wf, startRetainedRun as wi, AnytimeReport as wl, queueOf as wn, SupervisorProfile as wo, sandboxCheckRunner as wr, localSandboxClient as ws, safeWorkerFile as wt, DELEGATE_TOOL_NAME as wu, SuperviseSurfaceResult as x, printBenchmarkReport as xa, Widen as xc, DelegateCodeConfig as xd, RetainedRunDispatchBindingError as xf, acquireSandbox as xi, IntentAudit as xl, RollingDispatchOptions as xn, SupervisorAgentTestDeps as xo, modelAuthoredChecks as xr, isTerminalDecision as xs, readWorkerSteerRequests as xt, createMcpServer as xu, harvestSurfaceDiffs as y, BenchmarkTaskRow as ya, Verify as yc, hashIdempotencyInput as yd, RetainedInteractiveBindingError as yf, probeSandboxCapabilities as yi, AuditIntentInput as yl, DispatchStopReason as yn, ResolvedSupervisorProfile as yo, validateProfileMaterialization as yp, defaultStructuralRolloutPolicy as yr, TerminalDecision as ys, readWorkerCancelRequests as yt, McpServerOptions as yu, copyUntrackedIntoClone as z, adaptiveRefine as za, LeaderboardBenchScore as zc, DelegationResultPayload as zd, FileSpawnJournal as zf, assertProfileModelsAllowed as zi, AnalyzeOnSettleRoute as zl, chatTransportExecutor as zn, ProgressSample as zo, pickChampion as zr, renderReport as zs, createInMemoryRunContext as zt, DetachedSessionDelegateOptions as zu };
+//# sourceMappingURL=index-DLn9WI-f.d.ts.map