@tangle-network/agent-runtime 0.142.3 → 0.153.1

package/dist/{index-D_aH0F4C.d.ts → index-Dlz7ejRx.d.ts}

@@ -1,17 +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-DZrBoBpN.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-_7w24mMg.js";
-import { At as JsonRpcResponse, M as WorktreeCheckRunner, Mt as McpTransport, P as WorktreeHarnessResult, St as PeerMailbox, T as KeyProvider, Z as GitRunner, _t as PeerMailLimits, ct as ToolLoopCompactionOptions, ht as PeerMailEvent, it as ToolSpec, jt as McpToolDescriptor$1, kt as JsonRpcMessage, l as RouterToolsSeam, o as ExecutorConfig, ot as ToolLoopChat, q as runLocalHarness, rt as RouterTransportConfig, x as Inbox } from "./runtime-htqI3fKL.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-BicwCDK5.js";
-import "./stream-agent-turn-Dfy12OjG.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. */
@@ -415,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
 /**
  *
@@ -2198,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 {
@@ -2518,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 {
@@ -2554,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. */
@@ -4558,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
@@ -4670,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;
@@ -4700,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. */
@@ -4795,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
@@ -4880,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. */
@@ -4967,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
@@ -4977,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:
@@ -5052,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;
 } | {
@@ -5062,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;
 } | {
@@ -5073,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;
@@ -5088,6 +4976,7 @@ declare function superviseWithTestBrain(profile: SupervisorProfile, task: unknow
   downCount: number;
   spentTotal: Spend;
   providerModel?: ProviderModelExecutionEvidence;
+  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
   spendGaps?: ReadonlyArray<SpendGap>;
   error?: never;
 } | {
@@ -5098,6 +4987,7 @@ declare function superviseWithTestBrain(profile: SupervisorProfile, task: unknow
   downCount: number;
   spentTotal: Spend;
   providerModel?: ProviderModelExecutionEvidence;
+  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
   spendGaps?: ReadonlyArray<SpendGap>;
   error: NoWinnerError;
 } | {
@@ -5109,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;
@@ -5834,7 +5725,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
@@ -5947,54 +5843,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.
@@ -6141,181 +5989,6 @@ interface CriuCapableClient {
   }>;
 }
 //#endregion
-//#region src/runtime/sandbox-events.d.ts
-/**
- * Return the terminal failure carried by one Sandbox event.
- *
- * Sandbox transports report execution failure in-band: commonly an `error`
- * event followed by a synthetic `done`. Treating the iterable as successfully
- * drained therefore turns a provider/configuration failure into a completed
- * empty artifact.
- *
- * The decoder reads a failure from exactly two places, so that a mid-stream
- * event describing its OWN failure cannot fail the execution: an `error`-typed
- * event, and a terminal event (`done`/`result`/`final`) whose `success` is
- * `false` or whose status is a failed one. A failing tool part therefore stays
- * a tool result, which is what {@link mapSandboxToolEvent} already projects it
- * to.
- */
-declare function sandboxEventFailure(event: SandboxEvent): string | undefined;
-/** Fail the live execution instead of allowing an in-band failure to become an empty success. */
-declare function assertSandboxEventSucceeded(event: SandboxEvent): void;
-/** 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 {@link assertSandboxEventSucceeded}, applied by the two paths
- * that SETTLE an execution. 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
@@ -6467,6 +6140,8 @@ type Deliverable<Out> = {
 interface TurnResult<Out> {
   out: Out;
   events: SandboxEvent[];
+  /** Outcome settled by the public Sandbox tracker after the stream drained. */
+  outcome: AgentRunOutcome;
   readError?: string;
 }
 /**
@@ -7335,6 +7010,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);
@@ -7414,10 +7092,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
@@ -7532,6 +7235,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
@@ -8112,7 +7823,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;
 }
@@ -8123,11 +7836,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;
@@ -8146,12 +7866,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. */
@@ -8217,9 +7978,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
@@ -8232,6 +7994,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,
@@ -8601,6 +8396,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. */
@@ -8787,5 +8608,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 $, refine as $a, LeaderboardRunContext as $c, DELEGATION_TRACE_MAX_BYTES as $d, BusEvent as $f, createShapeRegistry as $i, CoordinationTools as $l, CheckSource as $n, StopRule as $o, SandboxRunAbortError as $r, CorpusRecord as $s, analyzesFindingsReportPrompt as $t, createFleetWorkspaceExecutor as $u, NOTE_MAX_CHARS as A, Environment as Aa, Widen as Ac, DelegateResearchResult as Ad, RecoverRetainedRunIntentOptions as Af, claimRetainedInteractiveControl as Ai, IntentAudit as Al, ChatWorkerSeamOptions as An, SupervisorAgentTestDeps as Ao, CanonicalAgentProfileMaterializationAxis as Ap, discriminatingMeans as Ar, isTerminalDecision as As, createFileRunContext as At, DelegateHandlerOptions as Au, GitWorkspaceOptions as B, RunAgenticOptions as Ba, PersonaContext as Bc, DelegationProfile as Bd, RetainedRunCancellation as Bf, StartRetainedInteractiveRunOptions as Bi, renderAnytimeTable as Bl, spendFromUsageEvents as Bn, CoordinationDeliveryEvidence as Bo, profileMaterializationAxes$1 as Bp, LocalMcpMaterialization as Br, HarvestFailure as Bs, GraphEdge as Bt, CoderReviewer as Bu, SurfaceWorkerOut as C, sanitizeMcpToolSchema as Ca, SteerContext as Cc, DelegateCodeArgs as Cd, RetainedRunAdmissionError as Cf, AcquireOptions as Ci, pairwiseSignificance as Cl, DriverAgentOptions as Cn, DriveHarness as Co, materializeTreeView as Cp, EvolutionAuthor as Cr, DriverProgressMark as Cs, workerControlLogFile as Ct, createInProcessTransport as Cu, WorktreeFanoutOptions as D, BenchmarkReport as Da, TrajectoryReportOptions as Dc, DelegateFeedbackResult as Dd, NativeContextContinuationExecution as Df, startRetainedRun as Di, renderPairwiseMarkdown as Dl, ChatSessionStore as Dn, ResolveSupervisorTools as Do, AGENT_PROFILE_MATERIALIZATION_AXES as Dp, EvolutionReport as Dr, TERMINAL_DECISIONS as Ds, InMemoryRunContext as Dt, DELEGATE_TOOL_NAME as Du, AuthoredHarness as E, BenchmarkLift as Ea, TrajectoryReportFn as Ec, DelegateFeedbackArgs as Ed, ValidationError as Ef, recoverRetainedRun as Ei, renderLeaderboardSvg as El, ChatCompletionsTransport as En, ResolveDriveHarness as Eo, contentAddress as Ep, EvolutionGeneration as Er, RunAgentRoundsOptions as Es, writeWorkerSteer as Et, DELEGATE_INPUT_SCHEMA as Eu, settledWorkerOut as F, AgenticSurface as Fa, DefinePersona as Fc, DelegationError as Fd, RetainedInteractiveIntentAdmission as Ff, RecoverRetainedInteractiveRunOptions as Fi, AnytimeTaskCurve as Fl, BudgetPoolRestore as Fn, SupervisorToolInvocationContext as Fo, ValidateProfileMaterializationOptions as Fp, AuthoredStrategy as Fr, InProcessOnPrompt as Fs, WorktreePatchArtifact as Ft, FeedbackStore as Fu, gitWorkspace as G, StrategyMessage as Ga, ShapeContext as Gc, DelegationStatusResult as Gd, RetainedRunHandle as Gf, promotionGate as Gi, AnalystFindingEvent as Gl, assessAuthoredProfile as Gn, AllWorkersStalledOptions as Go, renderProfileMaterializationIssues as Gp, StdioMcpServerSpec as Gr, ObserveOptions as Gs, RunGraphTestOptions as Gt, UiAuditorDelegate as Gu, Workspace as H, Strategy as Ha, RunPersonified as Hc, DelegationResultPayload as Hd, RetainedRunEffect as Hf, resolveSandboxClient as Hi, WaterfallReport as Hl, ProfileRichness as Hn, CoordinationOwnerId as Ho, promptModelProfileMaterialization as Hp, McpSpawnFault as Hr, harvestCorpus as Hs, GraphNode as Ht, DetachedSessionDelegateOptions as Hu, CopyOptions as I, AgenticTask as Ia, DefinePersonaInput as Ic, DelegationFeedbackSnapshot as Id, RetainedInteractiveStartedAdmission as If, RetainedInteractiveAdmissionHook as Ii, anytimeReport as Il, BudgetReadout as In, assertCoordinationBinding as Io, assertProfileMaterialization as Ip, assertStrategyContract as Ir, InProcessPromptCtx as Is, createWorktreeCliExecutor as It, InMemoryFeedbackStore as Iu, runInWorkspace as J, SurfaceScore as Ja, LeaderboardBenchScore as Jc, ResearchOutputShape as Jd, RetainedRunSnapshot as Jf, assertModelAllowed as Ji, AuthorizeDownMessage as Jl, supervisorInstructions as Jn, ProgressSample as Jo, worktreeCliProfileMaterialization as Jp, Deliverable as Jr, renderReport as Js, runGraph as Jt, settleDetachedCoderTurn as Ju, jjWorkspace as K, StrategyResult as Ka, ShapeRegistry as Kc, FeedbackRating as Kd, RetainedRunIntentAdmission as Kf, profileChatClient as Ki, AnalystRegistry as Kl, defaultProfileRichnessThresholds as Kn, NoProgressForOptions as Ko, sandboxActProfileMaterialization as Kp, connectStdioMcp as Kr, defaultAnalystInstruction as Ks, TraversalContinuity as Kt, coderTaskFromArgs as Ku, UntrackedCopyStats as L, AgenticTool as La, LoopShape as Lc, DelegationHistoryArgs as Ld, RetainedRunAdmission as Lf, RetainedInteractiveEnvironmentInput as Li, areaUnderCurve as Ll, ReservationRejection as Ln, resolveSupervisorProfile as Lo, controlProfileMaterialization as Lp, authorStrategy as Lr, InProcessSandboxClientOptions as Ls, AgentGraph as Lt, eventToSnapshot as Lu, WorkerEvidenceInput as M, runBenchmark as Ma, WidenLineage as Mc, DelegateUiAuditConfig as Md, RecoverRetainedRunResult as Mf, recoverRetainedInteractiveRun as Mi, defaultAuditorInstruction as Ml, chatWorkerSeam as Mn, SupervisorNodeContextSeed as Mo, KnownAgentProfileMaterializationAxis as Mp, runStrategyEvolution as Mr, LocalSandboxClientOptions as Ms, PatchDeliverableOptions as Mt, createDelegateHandler as Mu, closingWorkerNote as N, AgenticOptions as Na, WidenSpec as Nc, DelegateUiAuditResult as Nd, RetainedInteractiveAdmission as Nf, startRetainedInteractiveRun as Ni, AnytimeReport as Nl, createChatSessionStore as Nn, SupervisorProfile as No, ProfileMaterializationContract as Np, selectChampion as Nr, localSandboxClient as Ns, patchDelivered as Nt, validateDelegateArgs as Nu, worktreeFanout as O, BenchmarkStrategySummary as Oa, Verify as Oc, DelegateResearchArgs as Od, NativeContextContinuationInput as Of, startRetainedRunInEnvironment as Oi, AuditIntentInput as Ol, ChatTransportExecutorOptions as On, ResolvedSupervisorProfile as Oo, AgentProfileMaterializationAxis as Op, ReproductionCheck as Or, TerminalDecision as Os, InMemoryRunContextOptions as Ot, DelegateArgs as Ou, composeWorkerEvidence as P, AgenticRunResult as Pa, WinnerStrategy as Pc, DelegateUiAuditRoute as Pd, RetainedInteractiveEnvironmentAdmission as Pf, ReconnectRetainedInteractiveRunOptions as Pi, AnytimeStrategySummary as Pl, BudgetPool as Pn, SupervisorToolDescriptor as Po, ProfileMaterializationIssue as Pp, AuthorStrategyOptions as Pr, inlineSandboxClient as Ps, WorktreeCliExecutorOptions as Pt, FeedbackEvent as Pu, WorkerToolTraceArtifact as Q, depthStrategy as Qa, LeaderboardIterationInfo as Qc, CappedDelegationTrace as Qd, CoderOutput as Qf, builtinShapes as Qi, CoordinationEvent as Ql, CheckRunner as Qn, StopDecision as Qo, SandboxRun as Qr, CorpusFilter as Qs, RegisteredPrompt as Qt, SiblingSandboxExecutorOptions as Qu, copyUntrackedIntoClone as R, ArtifactHandle as Ra, Outcome as Rc, DelegationHistoryEntry as Rd, RetainedRunAdmissionHook as Rf, RetainedInteractiveRunHandle as Ri, bestSoFar as Rl, ReservationTicket as Rn, supervisorAgent as Ro, defineProfileMaterializationContract as Rp, strategyAuthorContract as Rr, inProcessSandboxClient as Rs, EdgeDeliveryOutcome as Rt, CoderDelegate as Ru, SurfaceWorkerConfig as S, createMcpEnvironment as Sa, ScopeWidenGate as Sc, hashIdempotencyInput as Sd, RetainedInteractiveBindingError as Sf, probeSandboxCapabilities as Si, leaderboard as Sl, serveCoordinationMcp as Sn, CoordinationBinding as So, loadSpawnForest as Sp, EvolutionArchiveNode as Sr, DriverAttemptsExhaustedError as Ss, workerCancellationsDir as St, McpServerOptions as Su, superviseSurface as T, BenchmarkConfig as Ta, TrajectoryReport as Tc, DelegateCodeResult as Td, RuntimeRunStateError as Tf, reconnectRetainedRun as Ti, renderLeaderboardMarkdown as Tl, finalizeBestDelivered as Tn, ObserveSupervisorNodeEvent as To, replaySpawnTree as Tp, EvolutionCandidate as Tr, classifyDriverFailure as Ts, workerInboxFileFromEventDir as Tt, DELEGATE_DESCRIPTION as Tu, WorkspaceCommit as U, StrategyArtifacts as Ua, RunPersonifiedOptions as Uc, DelegationStatus as Ud, RetainedRunEnvironmentAdmission as Uf, PromotionGateOptions as Ui, WaterfallSpan as Ul, ProfileRichnessThresholds as Un, FileCoordinationLog as Uo, promptOnlyProfileMaterialization as Up, McpToolDescriptor as Ur, Observation as Us, GraphResult as Ut, DetachedWinnerSelection as Uu, Shell as V, ShotSpec as Va, PersonaExecutors as Vc, DelegationProgress as Vd, RetainedRunDispatchedAdmission as Vf, ResolveSandboxClientOptions as Vi, WaterfallCollector as Vl, AuthoredProfile as Vn, CoordinationLog as Vo, promptControlProfileMaterialization as Vp, MaterializeLocalMcpOptions as Vr, HarvestReport as Vs, GraphEdgeCapError as Vt, DelegateRunCtx as Vu, WorkspaceRun as W, StrategyCtx as Wa, ShapeBudget as Wc, DelegationStatusArgs as Wd, RetainedRunEventOptions as Wf, PromotionVerdict as Wi, createWaterfallCollector as Wl, asAuthoredProfile as Wn, PriorCoordination as Wo, promptResourceProfileMaterialization as Wp, StdioMcpConnection as Wr, ObserveInput as Ws, RunGraphOptions as Wt, SettleDetachedCoderTurnOptions as Wu, analyzeTrace as X, breadthStrategy as Xa, LeaderboardBenchmarkAdapter as Xc, UiAuditLensFilter as Xd, StartRetainedRunInEnvironmentOptions as Xf, equalKOnCost as Xi, ContinuationInstruction as Xl, CheckOutcome as Xn, ProgressTrackerOptions as Xo, OpenSandboxRunOptions as Xr, CombinatorShape as Xs, PromptHandle as Xt, FleetHandle as Xu, TrajectoryAnalysis as Y, adaptiveRefine as Ya, LeaderboardBenchTask as Yc, ResearchSource as Yd, RetainedRunStartMaterial as Yf, assertProfileModelsAllowed as Yi, AuthorizedDownMessage as Yl, CheckExecChannel as Yn, ProgressTracker as Yo, OpenSandboxRunBeforeStartContext as Yr, AssertTraceDerivedFindings as Ys, runGraphWithTestBrain as Yt, DelegationExecutor as Yu, WORKER_TOOL_TRACE_SCHEMA_VERSION as Z, defineStrategy as Za, LeaderboardFlagSpec as Zc, UiAuditorDelegationOutput as Zd, StartRetainedRunOptions as Zf, trajectoryReport as Zi, ContinuityMode as Zl, CheckRunContext as Zn, ProgressView as Zo, OpenSandboxRunPromptOptions as Zr, Corpus as Zs, PromptRegistry as Zt, FleetWorkspaceExecutorOptions as Zu, boxSurfaceReader as _, buildSteerContext as _a, PipelineStage as _c, DelegationRunContext as _d, ConfigError as _f, sandboxEventFailure as _i, LeaderboardRow as _l, rollingDispatch as _n, SuperviseRegistryTable as _o, SpawnForestEvent as _p, selectBestIndex as _r, collectDelivered as _s, supervisorRunDir as _t, WorkerWatchOptions as _u, SandboxInstance$1 as a, renderCorpusToInstructions as aa, FanoutOptions as ac, DriveTurnTick as ad, capDelegationTrace as af, SandboxLineage as ai, CompletionEvidence as al, kernelPromptRegistry as an, LoopOptionsForDispatch as ao, WatchTraceOptions as ap, StructuralRolloutResult as ar, plateau as as, createScope as at, DownMessageEvent as au, SuperviseSurfaceOptions as b, McpEndpoint as ba, ScopeAnalyst as bc, SubmitInput as bd, PlannerError as bf, CriuCapableClient as bi, ProfileKeyOf as bl, delegate as bn, superviseWithTestBrain as bo, SpawnForestNode as bp, ChampionPick as br, DriverAttemptRecord as bs, workerCancelRequestsFile as bt, normalizeAnalyzeOnSettle as bu, VerifierEnvironmentOptions as c, loopUntil as ca, FlatWidenGate as cc, detachedTurnEvents as cd, DelegationPersistenceError as cf, createSandboxLineage as ci, completionAuthorizes as cl, supervisorPolicyPrompt as cn, loopCampaignDispatch as co, DeliverableSpec as cp, compareCheckOutcomes as cr, SupervisorSpanOptions as cs, WorkerCancellation as ct, QuestionDecision as cu, HarvestSurfaceDiffsOptions as d, selectValidWinner as da, LoopUntilState as dc, runDetachedTurn as dd, FileDelegationStore as df, assertSandboxEventSucceeded as di, stopSentinel as dl, DispatchStopReason as dn, AuthorizedSpawn as do, mapExecutorResult as dp, defaultStructuralRolloutPolicy as dr, createSupervisorSpanRecorder as ds, legacySupervisorRunDir as dt, QuestionPolicy as du, registerShape as ea, EqualKArm as ec, createSiblingSandboxExecutor as ed, DELEGATION_TRACE_MAX_SPANS as ef, TurnResult as ei, LeaderboardScenario as el, createPromptRegistry as en, runAgentic as eo, BusRecord as ep, CheckSourceCtx as er, allOf as es, parseWorkerToolTraceArtifact as et, CoordinationToolsOptions as eu, SurfaceDiff as f, verify as fa, Panel as fc, DelegationArgs as fd, FileDelegationStoreOptions as ff, assertSandboxServedModel as fi, AxisScoresOf as fl, DispatchUnit as fn, AuthorizedSpawnContext as fo, FileResultBlobStore as fp, filterAuthoredAsserts as fr, DeliveredOutput as fs, legacySupervisorRunsRoot as ft, QuestionRecord as fu, WatchedSurface as g, assertTraceDerivedFindings as ga, Pipeline as gc, DelegationResumeTick as gd, BackendTransportError as gf, mapSandboxToolEvent as gi, LeaderboardOptions as gl, queueOf as gn, SuperviseRegistry as go, SpawnForest as gp, sandboxCheckRunner as gr, bestDelivered as gs, safeWorkerFile as gt, WorkerSpawnContext as gu, SurfaceReader as h, RegistryAnalyzeProjection as ha, PanelVerdict as hc, DelegationResumeDriver as hd, AgentEvalErrorCode as hf, mapSandboxEvent as hi, Leaderboard as hl, freeSlots as hn, SuperviseOptions as ho, InMemorySpawnJournal as hp, resolveEntrySymbol as hr, SupervisorFinalizer as hs, readWorkerSteerRequests as ht, WorkerResumeContext as hu, SandboxEvent$1 as i, InMemoryCorpus as ia, Fanout as ic, DriveTurnCapableBox as id, buildDelegationTraceSpans as if, ForkCapableBox as ii, CompletionAnalyst as il, formatPromptHandle as in, LoopDispatchOptions as io, createEventBus as ip, StructuralRolloutPolicy as ir, noProgressFor as is, ScopeArgs as it, DownMessageDeliveryOutcome as iu, VERIFY_TAIL_CHARS as j, printBenchmarkReport as ja, WidenDecision as jc, DelegateUiAuditArgs as jd, RecoverRetainedRunOptions as jf, reconnectRetainedInteractiveRun as ji, auditIntent as jl, chatTransportExecutor as jn, SupervisorNodeContext as jo, DefineProfileMaterializationContractOptions as jp, pickChampion as jr, runAgentRounds as js, createInMemoryRunContext as jt, DelegateResult as ju, EVIDENCE_MAX_CHARS as k, BenchmarkTaskRow as ka, VerifySpec as kc, DelegateResearchConfig as kd, ReconnectRetainedRunOptions as kf, ClaimRetainedInteractiveControlOptions as ki, AuditIntentOptions as kl, ChatTransportTool as kn, SupervisorAgentDeps as ko, AssertProfileMaterializationOptions as kp, StrategyEvolutionConfig as kr, defaultSelectWinner as ks, RunContext as kt, DelegateError as ku, createVerifierEnvironment as l, panel as la, LoopUntil as lc, formatDetachedSessionRef as ld, DelegationStateCorruptError as lf, SandboxServedBackend as li, deterministicCompletion as ll, ConcurrencyCaps as ln, loopDispatch as lo, ExecutorResultMapping as lp, composeCheckSources as lr, SupervisorSpanOutcome as ls, WorkerSteerRequest as lt, QuestionLevel as lu, SurfaceReadOutcome as m, CreateScopeAnalystOptions as ma, PanelSpec as mc, DelegationResumeContext as md, AgentEvalError$1 as mf, extractLlmCallEvent as mi, Interval as ml, effectiveConcurrency as mn, DeliverableResolutionInput as mo, InMemoryResultBlobStore as mp, officialChecksFromMeta as mr, FinalizerSettled as ms, readWorkerCancellation as mt, SettledWorker as mu, AnalystFinding$1 as n, runPersonified as na, EqualKOnCostOptions as nc, DetachedTurn as nd, DelegationTraceCollector as nf, BranchCapableBox as ni, LeaderboardSpec as nl, dumbContinuationFailPrompt as nn, sampleThenRefine as no, EventBus as np, StructuralRolloutConfig as nr, anyOf as ns, createRootHandle as nt, DownMessageAuthorizationInput as nu, computeFindingId$1 as o, fanout as oa, FanoutSynthesis as oc, RunDetachedTurnOptions as od, composeLoopTraceEmitters as of, SandboxLineageHandle as oi, CompletionPolicy as ol, naiveContinuationPrompt as on, SuperviseDispatchOptions as oo, defaultToolDetectors as op, VisibleCheck as or, sampleFromSettled as os, settledToIteration as ot, MakeWorkerAgent as ou, SurfaceReadBox as p, widen as pa, PanelJudge as pc, DelegationRecord as pd, InMemoryDelegationStore as pf, createSandboxToolPartState as pi, GroupOf as pl, RollingDispatchOptions as pn, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as po, FileSpawnJournal as pp, modelAuthoredChecks as pr, FinalizeContext as ps, readWorkerCancelRequests as pt, QuestionUrgency as pu, localShell as q, StrategyShotResult as qa, DefinedLeaderboard as qc, FeedbackRefersTo as qd, RetainedRunReplayPoint as qf, profileOptimizerModelCall as qi, AnalyzeOnSettleRoute as ql, profileRichnessFinding as qn, PlateauOptions as qo, validateProfileMaterialization as qp, materializeLocalMcp as qr, observe as qs, defaultEdgeTraversalCap as qt, detachedSessionDelegate as qu, CreateSandboxOptions$1 as r, FileCorpus as ra, EqualKVerdict as rc, DetachedTurnResumeDriverOptions as rd, DelegationTraceSpan as rf, CheckpointCapableBox as ri, defineLeaderboard as rl, dumbContinuationPassPrompt as rn, LoopCampaignDispatchOptions as ro, PublishOptions as rp, StructuralRolloutMessage as rr, createProgressTracker as rs, createSupervisor as rt, DownMessageDeliveryAttempt as ru, makeFinding$1 as s, flatWidenGate as sa, FanoutWinnerSelector as sc, createDetachedTurnResumeDriver as sd, createDelegationTraceCollector as sf, SessionCapableBox as si, CompletionVerdict as sl, promptHandle as sn, SuperviseOptionsForDispatch as so, watchTrace as sp, canDisplace as sr, SupervisorSpanAttributes as ss, WorkerCancelRequest as st, Question as su, AgentProfile$2 as t, definePersona as ta, EqualKOnCost as tc, DetachedSessionRefParts as td, DelegationTraceCaps as tf, openSandboxRun as ti, LeaderboardScore as tl, delegatesWorkerBriefPrompt as tn, sample as to, BusStats as tp, RepairStop as tr, allWorkersStalled as ts, workerTraceAnalysisStore as tt, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as tu, BoxSurfaceReaderOptions as u, pipeline as ua, LoopUntilSpec as uc, parseDetachedSessionRef as ud, DelegationStore as uf, SandboxToolPartState as ui, sentinelCompletion as ul, DispatchReport as un, superviseDispatch as uo, gateOnDeliverable as up, defaultExtractCandidate as ur, SupervisorSpanRecorder as us, cancelWorker as ut, QuestionOption as uu, fsSurfaceReader as v, createScopeAnalyst as va, RenderCorpusToInstructions as vc, DelegationTaskQueue as vd, JudgeError as vf, sandboxEventServedBackend as vi, PairwiseOptions as vl, DelegateOptions as vn, SuperviseTestOptions as vo, SpawnForestInDoubtNode as vp, structuralRollout as vr, pickBestDelivered as vs, supervisorRunsRoot as vt, canonicalFindingEvent as vu, failuresAnalyst as w, BenchmarkCell as wa, TrajectoryNode as wc, DelegateCodeConfig as wd, RetainedRunDispatchBindingError as wf, acquireSandbox as wi, renderLeaderboardHtml as wl, driverAgent as wn, DriveHarnessOwnerContext as wo, pendingWaits as wp, EvolutionBandInfo as wr, DriverRetryPolicy as ws, workerInboxFile as wt, createMcpServer as wu, SuperviseSurfaceResult as x, McpEnvironmentOptions as xa, ScopeAnalyzeInput as xc, SubmitOutput as xd, RetainedInteractiveAdmissionError as xf, SandboxCapabilities as xi, ScoreOf as xl, CoordinationMcpHandle as xn, workerFromBackend as xo, SpawnForestTree as xp, ChampionPolicy as xr, DriverAttemptStop as xs, workerCancellationFile as xt, McpServer as xu, harvestSurfaceDiffs as y, registryScopeAnalyst as ya, RenderCorpusToInstructionsOptions as yc, DelegationTaskQueueOptions as yd, NotFoundError as yf, sumSandboxUsage as yi, PairwiseVerdict as yl, defaultDelegateBudget as yn, supervise as yo, SpawnForestMissingTree as yp, visibleCheckScore as yr, runFinalizer as ys, supervisorWorkersDir as yt, createCoordinationTools as yu, withUntrackedArtifacts as z, CorpusReadbackOptions as za, Persona as zc, DelegationHistoryResult as zd, RetainedRunCancelOptions as zf, RetainedInteractiveStartMaterial as zi, plateauLength as zl, createBudgetPool as zn, supervisorAgentWithTestBrain as zo, fullProfileMaterialization as zp, strategyAuthorSystemPrompt as zr, HarvestCorpusOptions as zs, EdgeTraversal as zt, CoderReview as zu };
-//# sourceMappingURL=index-D_aH0F4C.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-Dlz7ejRx.d.ts.map