@tangle-network/agent-runtime 0.320.1 → 0.322.1

package/dist/{index-t672ISFX.d.ts → index-CGNQWpge.d.ts}

@@ -2,7 +2,7 @@ import { n as AnalystRegistryLike } from "./types-zWfqDjeL.js";
 import { s as ProfileMaterializationContract } from "./profile-materialization-C5-t3HJ7.js";
 import { l as RuntimeHooks, o as RuntimeHookEvent, r as RuntimeDecisionPoint } from "./runtime-hooks-Bj6wJHlH.js";
 import { P as AgentCandidateOutputArtifactPort, g as AgentCandidateArtifactPort, l as AgentCandidateWorkspaceArchiveLimits, n as AgentCandidateWorkspaceTree } from "./workspace-streams-U6_UfOXu.js";
-import { AgentCandidateArtifactRef, AgentCandidateWorkspaceManifestMaterial, AgentCandidateWorkspaceSnapshotEvidence, AgentExactRunControlRef, AgentInteractiveSession, AgentInteractiveSessionControlClaim, AgentInteractiveSessionPromptAcknowledgement, AgentInteractiveSessionPromptCommand, AgentInteractiveSessionRef, AgentInteractiveSessionStart, AgentInteractiveSessionStatus, AgentNativeContextContinuationOptions, AgentNativeContextContinuationResult, AgentProfile, AgentProfile as AgentProfile$2, AgentProfile as AgentProfile$3, AgentProfileDiff, AgentProfileMcpServer, AgentProfilePrompt, AgentProfileSecurityPolicy, AgentSessionStatus, AgentTurnResult, ChildTaskEvent, ContextTransferReceipt, ContextTransferRequest, HarnessType, InputPart, InteractionAcknowledgement, InteractionRequest, InteractionResponseCommand, NativeContextBoundaryProof, NativeContextContinuationRequest, NativeContextContinuationTurn, ReasoningEffort, RequestedInteractions, RuntimeEventEnvelope, Sha256Digest, StreamEvent, WorkspaceCheckpointRef, WorkspaceCheckpointRequest } from "@tangle-network/agent-interface";
+import { AgentCandidateArtifactRef, AgentCandidateWorkspaceManifestMaterial, AgentCandidateWorkspaceSnapshotEvidence, AgentExactRunControlRef, AgentInteractiveSession, AgentInteractiveSessionControlClaim, AgentInteractiveSessionPromptAcknowledgement, AgentInteractiveSessionPromptCommand, AgentInteractiveSessionRef, AgentInteractiveSessionStart, AgentInteractiveSessionStatus, AgentNativeContextContinuationOptions, AgentNativeContextContinuationResult, AgentProfile, AgentProfile as AgentProfile$2, AgentProfile as AgentProfile$3, AgentProfileDiff, AgentProfileMcpServer, AgentProfilePrompt, AgentProfileSecurityPolicy, AgentSessionStatus, AgentTurnResult, ChildTaskEvent, ContextTransferReceipt, ContextTransferRequest, HarnessType, InputPart, InteractionAcknowledgement, InteractionRequest, InteractionResponseCommand, NativeContextBoundaryProof, NativeContextContinuationRequest, NativeContextContinuationTurn, ReasoningEffort, RequestedInteractions, RuntimeEventEnvelope, Sha256Digest, StreamEvent, TokenUsage, WorkspaceCheckpointRef, WorkspaceCheckpointRequest } 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, ControlBudget, ControlDecision, ControlEvalResult, ControlRunResult, ControlStep, CustomTokenPricing, DataAcquisitionPlan, DefaultVerdict, DefaultVerdict as DefaultVerdict$1, DetectorSignal, HarnessType as HarnessType$1, JudgeError, KnowledgeReadinessReport, KnowledgeRequirement, MaximumCharge, NotFoundError, PairedPromotionDecision, ProposalFinding, RankTestMethod, RegistryRunOpts, RunRecord, StreamingDetector, ToolSpan, TraceAnalysisEngine, TraceAnalysisStore, TraceStore, UserQuestion, ValidationError, buildTrajectory, computeFindingId as computeFindingId$1, makeFinding as makeFinding$1 } from "@tangle-network/agent-eval";
 import { AgentRunOutcome } from "@tangle-network/sandbox/runtime";
 import { ChildProcess } from "node:child_process";
@@ -542,6 +542,30 @@ interface KnowledgeReadinessDecision {
   nonBlockingGapIds: string[];
 }
 //#endregion
+//#region src/runtime/supervise/worker-events.d.ts
+/** Live observation is bounded and process-local. A reconnect explicitly reports expired history. */
+interface WorkerEventCursor {
+  readonly epoch: string;
+  readonly next: number;
+}
+interface WorkerEventEntry {
+  readonly sequence: number;
+  readonly at: number;
+  readonly event: unknown;
+  readonly omitted?: 'event-too-large' | 'event-not-serializable';
+}
+type WorkerEventPage = {
+  readonly status: 'unavailable';
+  readonly reason: 'unknown-worker' | 'not-captured';
+} | {
+  readonly status: 'available';
+  readonly entries: readonly WorkerEventEntry[];
+  readonly cursor: WorkerEventCursor;
+  readonly reset: boolean;
+  readonly historyExpired: boolean;
+  readonly remaining: number;
+};
+//#endregion
 //#region src/runtime-usage.d.ts
 /** Observed subtotals, with missing measurements kept separate from measured zeroes. */
 interface RuntimeUsageTotals {
@@ -2183,6 +2207,19 @@ interface ContinuationPolicy {
   readonly runPanel?: ContinuationPanel;
   /** A play's own section, appended after Runtime's sections. It cannot remove or rewrite one. */
   readonly append?: ContinuationAppend;
+  /**
+   * What a re-entered manager's harness session is. `native` (the default) sends the next turn
+   * into the same harness session wherever the backend proves it, with the unmet items and what
+   * changed. `fresh` starts a new harness session on every re-entry (a continuation, a wake, a
+   * failure retry, a pause) whose only input is the full re-entry task: the original task, the
+   * check's description and the coordinator's run state. The environment and its files are kept
+   * while the provider holds them; only the conversation is new, so whatever the next turn needs
+   * must be in the journal, the workspace or Knowledge, never in an earlier turn.
+   *
+   * Runtime's own drive harnesses (bridge and provider) honor it; a caller's `driveHarness`
+   * receives it as `session` and must start a new session on each drive that carries `reentry`.
+   */
+  readonly session?: 'native' | 'fresh';
 }
 /** Resolve and check a policy before any compute. Returns the deadline in epoch ms. */
 declare function admitContinuationPolicy(policy: ContinuationPolicy, context: string): number;
@@ -5639,6 +5676,8 @@ interface ProviderAsSandboxClientOptions {
   };
   /** Called after verification and before deletion so the run result can retain the exact join. */
   onWorkspaceCaptured?: (receipt: ProviderWorkspaceCaptureReceipt) => void | Promise<void>;
+  /** Translate Sandbox-specific controls that have no neutral representation. Without this
+   * callback, unsupported fields are refused before any environment is created. */
   mapCreateOptions?: (options: CreateSandboxOptions | undefined) => Partial<CreateAgentEnvironmentInput>;
 }
 /** Adapt a neutral environment provider to the `SandboxClient` interface used by existing loop paths.
@@ -5840,6 +5879,10 @@ declare function extractLlmCallEvent(event: SandboxEvent, agentRunName: string):
 interface SandboxUsageLedger {
   /** Cumulative worker tokens, including cache classifications reported after the prompt total. */
   tokenUsage(): LoopTokenUsage;
+  /** Read a detached snapshot of the latest settled turn, without settling the active turn.
+   *  Absent/incomplete usage stays absent; cost is the reported number, not a billing-completeness
+   *  claim or a catalog estimate. A later empty settlement replaces the snapshot with undefined. */
+  settledUsage(): TokenUsage | undefined;
   /** Account one event. Returns the canonical usage receipt to credit now, if the event is one. */
   observe(event: SandboxEvent, agentRunName: string): (RuntimeStreamEvent & {
     type: 'llm_call';
@@ -5926,6 +5969,10 @@ declare function createSandboxToolPartState(): SandboxToolPartState;
  *     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`.
+ *   - codex `raw` events whose inner `item.started` / `item.updated` /
+ *     `item.completed` carries a command, MCP, collaboration, web search or
+ *     file change item — stateful on the item id, like a tool part. Other raw
+ *     events, including opencode's raw `tool_use` echoes, project nothing.
  *
  * Returns `[]` for every non-tool event.
  *
@@ -8309,6 +8356,31 @@ interface BlockedToolReport {
 /** Build the driver's MCP tools over a live scope. */
 declare function createCoordinationTools(opts: CoordinationToolsOptions): CoordinationTools;
 //#endregion
+//#region src/runtime/supervise/trace-root.d.ts
+/** Schema identifier of a stored {@link TraceRootArtifact}. */
+declare const TRACE_ROOT_SCHEMA = "agent-runtime.trace-root.v1";
+/** Schema identifier of the {@link TraceSummary} carried by a trace root's last leaf. */
+declare const TRACE_SUMMARY_SCHEMA = "agent-runtime.trace-summary.v1";
+/** The last leaf of a trace root: how many events the archive holds and the tool calls among them,
+ *  one per distinct call id, by tool name. An absence or count claim is checked against it. */
+interface TraceSummary {
+  readonly schema: typeof TRACE_SUMMARY_SCHEMA;
+  readonly events: number;
+  readonly toolCalls: Readonly<Record<string, number>>;
+}
+/** The stored trace-root artifact. `leaves[i]` and `salts[i]` belong to `events[i]` of the
+ *  `outRef` blob for `i < summary.events`; the final entry belongs to `summary`. */
+interface TraceRootArtifact {
+  readonly schema: typeof TRACE_ROOT_SCHEMA;
+  readonly nodeId: string;
+  readonly outRef: string;
+  readonly root: string;
+  readonly leafCount: number;
+  readonly salts: readonly string[];
+  readonly leaves: readonly string[];
+  readonly summary: TraceSummary;
+}
+//#endregion
 //#region src/runtime/supervise/retained-executor.d.ts
 /**
  * Why a retained execution has no accepted terminal result, classified where the cause is still
@@ -8330,7 +8402,8 @@ declare function createCoordinationTools(opts: CoordinationToolsOptions): Coordi
  * - `'request-rejected'`: the request itself was refused BEFORE it ran — a schema violation
  *   (`ZodError`), an HTTP 4xx at admission, a capacity refusal at admission that carries an
  *   upstream capacity `code` and no HTTP status (the account owner's credential command refused a
- *   fresh dispatch before the dispatch request existed), or a dispatch that Sandbox did not admit
+ *   fresh dispatch before the dispatch request existed), an unsupported credential route, or a
+ *   dispatch that Sandbox did not admit
  *   because another execution owns the session or turn. Never named after admission.
  * - `'transport'`: the provider or a gateway in front of it failed — an HTTP 5xx, a socket
  *   error, a platform service answering with a server error. Status is in doubt only because
@@ -9971,6 +10044,10 @@ interface Scope<Out> {
     now?: number;
     stallAfterMs?: number;
   }): WorkerProgress | undefined;
+  /** The complete owned tree, including nested managers and resumed nodes. */
+  observeTree?(): TreeView;
+  /** Bounded live output; unavailable or expired history is reported explicitly. */
+  observeEvents?(nodeId: NodeId, cursor?: WorkerEventCursor): WorkerEventPage;
   /** The live tool-call trace of one child when its executor exposes one (`Executor.traceSource`),
    *  for running the online detector panel over a RUNNING worker. `undefined` otherwise. */
   traceSource(nodeId: NodeId): TraceSource | undefined;
@@ -10170,6 +10247,17 @@ interface WorkspaceCheckpointMarker {
   readonly path: string;
   readonly content: string;
 }
+/**
+ * The Merkle root over the events an output archived, as a journal record carries it beside that
+ * output's `outRef`. `ref` is the content address of the stored `TraceRootArtifact`; `leafCount` is
+ * the archived event count plus the summary leaf. Absent where the output archived no events, and
+ * on records written before trace roots existed.
+ */
+interface TraceRootReceipt {
+  readonly root: string;
+  readonly ref: string;
+  readonly leafCount: number;
+}
 type SpawnEvent = {
   kind: 'spawned';
   id: NodeId;
@@ -10228,6 +10316,7 @@ type SpawnEvent = {
   };
   id: NodeId;
   outRef: string;
+  traceRoot?: TraceRootReceipt;
   spent: Spend;
   verdict?: DefaultVerdict;
   seq: number;
@@ -10270,6 +10359,7 @@ type SpawnEvent = {
   kind: 'execution-evidence';
   id: NodeId;
   outRef: string;
+  traceRoot?: TraceRootReceipt;
   seq: number;
   at: string;
 } | {
@@ -10293,6 +10383,8 @@ type SpawnEvent = {
   status: 'done' | 'down';
   /** Content-addressed result pointer; rehydrates `out` from `ResultBlobStore`. */
   outRef?: string;
+  /** The trace root of the output at `outRef`, when this process stored it. */
+  traceRoot?: TraceRootReceipt;
   verdict?: DefaultVerdict;
   spent: Spend;
   /** Provider model evidence is independent from the planned materialization receipt. */
@@ -10345,6 +10437,7 @@ type SpawnEvent = {
    *  cancel. The settle path writes it on this record exactly as on `settled`. */
   harnessTranscript?: HarnessTranscriptEvidence;
   outRef?: string;
+  traceRoot?: TraceRootReceipt;
   budgetViolation?: BudgetViolation;
   /** As on `settled`: a retained child that was cancelled settles `cancelled`, and the one
    *  builder writes whichever kind the settlement had. */
@@ -10460,6 +10553,7 @@ type SpawnEvent = {
   infra?: boolean;
   trace?: WorkerTraceEvidence;
   outRef?: string;
+  traceRoot?: TraceRootReceipt;
   providerModel?: ProviderModelExecutionEvidence;
   /** The overspend the RETAINED reconcile returned, which the open-slot surfaces withhold
    *  (`materializeTreeView` folds only `spent` from this record); journaled so the released
@@ -11209,6 +11303,9 @@ type SupervisedResult<Out> = {
    *  environment replacements, why the loop ended, and how the root closed the run. Absent for
    *  a router-brained root, which runs no driver loop. */
   readonly continuation?: DriverContinuationRecord;
+  /** The root's caller-supplied attribution as it registered (`SuperviseOptions.execution`):
+   *  a fork's lineage keys, a SearchSpec's `searchSpecDigest`. Absent when the caller set none. */
+  readonly execution?: AgentExecutionRef;
   /** Runtime-owned provider evidence reduced across the complete journal forest. */
   readonly providerModel?: ProviderModelExecutionEvidence;
   /** Settled children whose teardown stayed unconfirmed after the settlement retry window
@@ -11260,6 +11357,9 @@ type SupervisedResult<Out> = {
    *  environment replacements, why the loop ended, and how the root closed the run. Absent for
    *  a router-brained root, which runs no driver loop. */
   readonly continuation?: DriverContinuationRecord;
+  /** The root's caller-supplied attribution as it registered (`SuperviseOptions.execution`):
+   *  a fork's lineage keys, a SearchSpec's `searchSpecDigest`. Absent when the caller set none. */
+  readonly execution?: AgentExecutionRef;
   /** Runtime-owned provider evidence reduced across the complete journal forest. */
   readonly providerModel?: ProviderModelExecutionEvidence;
   /** Settled children whose teardown stayed unconfirmed after the settlement retry window
@@ -11334,6 +11434,9 @@ type SupervisedResult<Out> = {
    *  environment replacements, why the loop ended, and how the root closed the run. Absent for
    *  a router-brained root, which runs no driver loop. */
   readonly continuation?: DriverContinuationRecord;
+  /** The root's caller-supplied attribution as it registered (`SuperviseOptions.execution`):
+   *  a fork's lineage keys, a SearchSpec's `searchSpecDigest`. Absent when the caller set none. */
+  readonly execution?: AgentExecutionRef;
   /** Runtime-owned provider evidence reduced across the complete journal forest. */
   readonly providerModel?: ProviderModelExecutionEvidence;
   /** Settled children whose teardown stayed unconfirmed after the settlement retry window
@@ -12337,6 +12440,11 @@ interface CoordinationMcpHandle {
   /** The URL an in-box harness mounts as `mcp.mcpServers.coordination.url`. */
   readonly url: string;
   readonly port: number;
+  /** A separately authenticated read-only endpoint. Never persist its protected headers. */
+  readonly readOnly: {
+    readonly url: string;
+    readonly headers: Readonly<Record<string, string>>;
+  };
   /** Runtime-only credentials. Never put these headers in canonical profiles or journals. */
   readonly headers: Readonly<Record<string, string>>;
   /** The current credential's expiry under `authentication.ttlMs`; undefined when it lives as long
@@ -12384,7 +12492,17 @@ interface CoordinationPublicAddress {
   /** Listener lifetime: aborts on close, failed setup, manager cancellation, or deadline. */
   readonly signal: AbortSignal;
 }
+/** Runtime-only read capability delivered to an operator client, never to the canonical profile. */
+interface CoordinationReadAccess {
+  readonly url: string;
+  readonly headers: Readonly<Record<string, string>>;
+}
 interface CoordinationTransportOptions extends CoordinationHttpOptions {
+  /** Publish the read capability before dispatch, so a remote client can observe the first worker. */
+  readonly onReadReady?: (access: CoordinationReadAccess & {
+    readonly runId: string;
+    readonly actorId: string;
+  }) => void | Promise<void>;
   readonly host?: string;
   readonly port?: number;
   /** Required for remote binds. Each server mints a distinct run/actor credential. */
@@ -12457,11 +12575,9 @@ declare function serveCoordinationMcp(opts: CoordinationTransportOptions & {
    * (`runtime/supervise/peer-mail`). Each spawn receives a capability URL on
    * `WorkerSpawnContext.peerMailUrl`.
    *
-   * It is a SEPARATE listener on its own port, not another tool on this server, and that is the
-   * whole point: this server grants spawn_worker / steer_agent / stop to its manager, so a
-   * worker handed its URL could send a REAL `[SUPERVISOR]` instruction to a sibling and the peer
-   * channel's authority marking would mean nothing. The mail listener serves `send_mail` and
-   * `read_mail` and no other verb, on a per-worker secret path bound to that worker's identity.
+   * It uses a separate capability path on the coordination listener. The manager endpoint
+   * grants spawn, steer and stop; the mail path serves only `send_mail` and `read_mail`,
+   * bound to one worker identity. A mail capability cannot authorize a manager request.
    *
    * The residual, stated plainly: the boundary is between AGENTS, not between processes. A worker
    * that can read another worker's environment or process memory still holds that worker's
@@ -12877,6 +12993,11 @@ interface DriveHarness {
     /** Data-only product tool surface mounted on the coordination MCP. Runtime-owned drivers include
      *  this in their materialization evidence without persisting executable handlers. */
     readonly coordinationTools: ReadonlyArray<Omit<McpToolDescriptor$1, 'handler'>>;
+    /** The manager's `continuation.session` on every drive, re-entered or not. `fresh`: each drive
+     *  that carries `reentry` starts a new harness session, keeping the environment and its files;
+     *  `compose` then always writes the full re-entry task. Absent or `native`: today's
+     *  same-session continuation where the backend proves it. */
+    readonly session?: 'native' | 'fresh';
     /** Present when this drive re-enters the run. `task` then carries the original objective and
      *  the coordinator's run state, which is right for any backend. A harness that can prove what
      *  the next turn continues composes the task from that proof instead, and reports it. */
@@ -13497,7 +13618,7 @@ interface SuperviseOptions {
    *  receives its coordination MCP: out of band on the bridge's `runtime_attachments`, so the
    *  authored profile digest never moves, and inside the leaf factory, so `authorizeSpawn` has
    *  already decided the profile. A `bridge` worker therefore calls `send_mail` / `read_mail` as
-   *  native tools. `router`, `router-tools` and `provider` workers run no MCP client, so the URL
+   *  native tools. `provider` workers mount it through their runtime MCP attachment capability. `router` and `router-tools` workers run no MCP client, so the URL
    *  stays the caller's to use; every other backend refuses the spawn rather than mint a
    *  capability it can never reach. A caller-owned `makeWorkerAgent` owns its own mount.
    *
@@ -13948,6 +14069,7 @@ interface SuperviseTestOptions extends SuperviseOptions {
 }
 /** One-call supervisor: build + run a supervisor from its exact profile. @stable */
 declare function supervise(profile: SupervisorProfile, task: unknown, opts: SuperviseOptions): Promise<{
+  execution?: AgentExecutionRef;
   continuation?: DriverContinuationRecord;
   rootHarnessTranscript?: HarnessTranscriptEvidence;
   rootStream?: RootStreamReceipt;
@@ -13964,6 +14086,7 @@ declare function supervise(profile: SupervisorProfile, task: unknown, opts: Supe
   error?: never;
   reason: "all-children-down" | "no-children-spawned" | "no-result-selected" | "budget-exhausted" | "aborted";
 } | {
+  execution?: AgentExecutionRef;
   continuation?: DriverContinuationRecord;
   rootHarnessTranscript?: HarnessTranscriptEvidence;
   rootStream?: RootStreamReceipt;
@@ -13983,6 +14106,7 @@ declare function supervise(profile: SupervisorProfile, task: unknown, opts: Supe
   cancellationReason: string;
   operationId?: string;
 } | {
+  execution?: AgentExecutionRef;
   continuation?: DriverContinuationRecord;
   rootHarnessTranscript?: HarnessTranscriptEvidence;
   rootStream?: RootStreamReceipt;
@@ -13999,6 +14123,7 @@ declare function supervise(profile: SupervisorProfile, task: unknown, opts: Supe
   fleetYield: FleetYield;
   error: NoWinnerError;
 } | {
+  execution?: AgentExecutionRef;
   continuation?: DriverContinuationRecord;
   rootHarnessTranscript?: HarnessTranscriptEvidence;
   rootStream?: RootStreamReceipt;
@@ -14020,6 +14145,7 @@ declare function supervise(profile: SupervisorProfile, task: unknown, opts: Supe
 }>;
 /** Deterministic scripted-brain path for tests. Not exported from Runtime's main entry. */
 declare function superviseWithTestBrain(profile: SupervisorProfile, task: unknown, opts: SuperviseTestOptions): Promise<{
+  execution?: AgentExecutionRef;
   continuation?: DriverContinuationRecord;
   rootHarnessTranscript?: HarnessTranscriptEvidence;
   rootStream?: RootStreamReceipt;
@@ -14036,6 +14162,7 @@ declare function superviseWithTestBrain(profile: SupervisorProfile, task: unknow
   error?: never;
   reason: "all-children-down" | "no-children-spawned" | "no-result-selected" | "budget-exhausted" | "aborted";
 } | {
+  execution?: AgentExecutionRef;
   continuation?: DriverContinuationRecord;
   rootHarnessTranscript?: HarnessTranscriptEvidence;
   rootStream?: RootStreamReceipt;
@@ -14055,6 +14182,7 @@ declare function superviseWithTestBrain(profile: SupervisorProfile, task: unknow
   cancellationReason: string;
   operationId?: string;
 } | {
+  execution?: AgentExecutionRef;
   continuation?: DriverContinuationRecord;
   rootHarnessTranscript?: HarnessTranscriptEvidence;
   rootStream?: RootStreamReceipt;
@@ -14071,6 +14199,7 @@ declare function superviseWithTestBrain(profile: SupervisorProfile, task: unknow
   fleetYield: FleetYield;
   error: NoWinnerError;
 } | {
+  execution?: AgentExecutionRef;
   continuation?: DriverContinuationRecord;
   rootHarnessTranscript?: HarnessTranscriptEvidence;
   rootStream?: RootStreamReceipt;
@@ -15880,176 +16009,489 @@ declare class HarvestError extends Error {
 /** Batch the selected observation implementation over completed runs and retain its findings. */
 declare function harvestCorpus(opts: HarvestCorpusOptions): Promise<HarvestReport>;
 //#endregion
-//#region src/runtime/in-process-sandbox-client.d.ts
-/** Context handed to each `onPrompt` call. */
-interface InProcessPromptCtx {
-  /** 0-based round index — increments per `streamPrompt` on the same box.
-   *  Fresh boxes start at 0. */
-  round: number;
-  /** Absolute path of this box's workspace, when a `workdir` was configured.
-   *  Write the deliverable / fixtures here; `fs.read`/`fs.write`/`exec` operate
-   *  over it. `undefined` for pure event-only boxes. */
-  workdir?: string;
-  /** Cooperative cancellation channel for this turn. */
-  signal: AbortSignal;
-  /** The verbatim per-call options the caller passed to the box verb (minus
-   *  `signal`, surfaced above) — lets an offline test assert an options
-   *  passthrough (`model`, `sessionId`, …) actually arrived. */
-  options?: Record<string, unknown>;
+//#region src/runtime/strategy.d.ts
+interface AgenticTask {
+  readonly id: string;
+  readonly userPrompt: string;
+  /** Opaque domain payload the surface reads (EOPS: servers/verifiers/tools). Drivers never read it. */
+  readonly meta?: Record<string, unknown>;
 }
-/**
- * The user callback: given a prompt and its round, produce the box's event
- * stream for that turn. Return a plain `SandboxEvent[]` (the common case) or an
- * async iterable for streaming. The callback may also write files into
- * `ctx.workdir` (read back via `fs.read` or graded by `exec`).
- */
-type InProcessOnPrompt = (prompt: string, ctx: InProcessPromptCtx) => SandboxEvent[] | AsyncIterable<SandboxEvent> | Promise<SandboxEvent[]>;
-/** @experimental */
-interface InProcessSandboxClientOptions {
-  /** The per-turn behavior — see {@link InProcessOnPrompt}. */
-  onPrompt: InProcessOnPrompt;
-  /**
-   * Opt in to a REAL filesystem-backed box. When set, each `create()` mints a
-   * fresh temp directory (prefixed `<workdir>-`) and the box exposes
-   * `fs.read`/`fs.write` and `exec` over it; `delete()` removes the dir. Omit
-   * for a pure event-only box (no `fs`/`exec` members), which is all a driver
-   * or fanout loop needs.
-   */
-  workdir?: string;
-  /**
-   * Override the box `id`. A string is used verbatim; a function receives the
-   * 0-based create-sequence and returns the id (e.g. machine-keyed placement
-   * demos). Default `in-process-<seq>`. The id is the value `describePlacement`
-   * tags, so set it when a demo's output reads on a meaningful sandbox id.
-   */
-  id?: string | ((seq: number) => string);
+interface ArtifactHandle {
+  readonly id: string;
+  readonly surface: string;
+  /** Opaque per-artifact context the surface stashes (EOPS: the seeded gym server + db id). */
+  readonly ctx?: unknown;
 }
-/**
- * Adapt a single `onPrompt(prompt, ctx)` callback into a `SandboxClient` for
- * `runAgentRounds` / `openSandboxRun`. Returns a PROPERLY-TYPED `SandboxClient`: the
- * lone `SandboxInstance` cast (object literal → `declare class`) lives inside
- * this function, so call sites stay cast-free.
- *
- * There is no box, so a per-prompt `backend` override is refused rather than dropped. A per-turn
- * `model` IS delivered, because `onPrompt` receives the verbatim options and is free to honor it.
- * Other per-prompt options (`timeoutMs`, `context`) are accepted and ignored.
- *
- * @experimental
- */
-declare function inProcessSandboxClient(options: InProcessSandboxClientOptions): SandboxClient;
-//#endregion
-//#region src/runtime/inline-sandbox-client.d.ts
-/**
- * Adapt an `ExecutorFactory` into a `SandboxClient` for `runAgentRounds`. The factory is
- * instantiated fresh per `streamPrompt` (mirrors the per-spawn executor lifecycle):
- * run once on the prompt, emit the terminal result event, tear down.
- *
- * There is no box, so a per-prompt `backend` or `model` override is refused rather than dropped;
- * other per-prompt options (`timeoutMs`, `context`) are accepted and ignored.
- */
-declare function inlineSandboxClient(factory: ExecutorFactory<unknown>, defaults?: {
-  profile?: AgentProfile;
-}): SandboxClient;
-//#endregion
-//#region src/runtime/local-sandbox-client.d.ts
-interface LocalSandboxClientOptions {
-  /** Optional code-mode presentation over the same explicitly trusted MCP tools. */
-  codeMode?: true | CodeModeToolsOptions;
-  /** Router endpoint/auth. The exact per-create profile owns model and loop behavior. */
-  router: {
-    baseUrl: string;
-    key: string;
+interface AgenticTool {
+  readonly type: 'function';
+  readonly function: {
+    name: string;
+    description?: string;
+    parameters: Record<string, unknown>;
   };
-  /** Fallback profile when `create(options)` carries none on `backend.profile`. */
-  profile?: AgentProfile;
-  /** Resolves profile-declared MCP secret names at child-process spawn time. */
-  keys?: KeyProvider;
-  /** Explicit trust decision for the exact `profile` bytes supplied here.
-   * Omit to refuse local processes. A permissive policy never transfers to a
-   * different per-create profile and provides no host isolation. */
-  profileSecurityPolicy?: AgentProfileSecurityPolicy;
 }
-/** A same-host `SandboxClient` adapter with no process isolation. Local MCP is
- * refused unless the caller explicitly supplies a policy that allows it.
- *
- * There is no box, so a per-prompt `backend` or `model` override is refused rather than dropped;
- * other per-prompt options (`timeoutMs`, `context`) are accepted and ignored. */
-declare function localSandboxClient(opts: LocalSandboxClientOptions): SandboxClient;
-//#endregion
-//#region src/runtime/sandbox-evidence-retention.d.ts
-/** One durable capture before a Sandbox box is removed. */
-interface SandboxEvidenceRetentionPort {
-  readonly timeoutMs: number;
-  readonly limits?: Partial<AgentCandidateWorkspaceArchiveLimits>;
-  readonly artifacts: AgentCandidateArtifactPort;
-  capture(context: SandboxEvidenceContext & {
-    readonly signal: AbortSignal;
-  }): Promise<{
-    readonly snapshot: AgentCandidateWorkspaceSnapshotEvidence;
-    readonly provenance: ProviderWorkspaceCaptureProvenance;
-  }>;
-  /** Must durably record this exact verified receipt before returning. */
-  record(receipt: SandboxEvidenceReceipt): Promise<void>;
+interface SurfaceScore {
+  passes: number;
+  total: number;
+  /** Checks excluded as malformed (data defect, not the agent). `total === 0` ⇒ unscoreable. */
+  errored: number;
 }
-interface SandboxEvidenceContext {
-  readonly box: SandboxInstance;
-  readonly executionId: string;
-  readonly profile: AgentProfile;
-  readonly sandboxSessionIds: ReadonlyArray<string>;
-  readonly nativeSessionIds?: ReadonlyArray<string>;
-  readonly sessionExecutionIds: Readonly<Record<string, ReadonlyArray<string>>>;
+/** A stateful, checkable environment an agent operates over with tools. Open behind one interface. */
+interface AgenticSurface {
+  readonly name: string;
+  open(task: AgenticTask): Promise<ArtifactHandle>;
+  tools(task: AgenticTask, handle: ArtifactHandle): Promise<AgenticTool[]>;
+  call(handle: ArtifactHandle, name: string, args: Record<string, unknown>): Promise<string>;
+  score(task: AgenticTask, handle: ArtifactHandle): Promise<SurfaceScore>;
+  close(handle: ArtifactHandle): Promise<void>;
 }
-interface SandboxEvidenceReceipt {
-  readonly boxId: string;
-  readonly executionId: string;
-  /** Exact authored profile identity without copying credentials into the receipt. */
-  readonly profileDigest: string;
-  readonly scope: 'box';
-  readonly sandboxSessionIds: ReadonlyArray<string>;
-  readonly nativeSessionIds?: ReadonlyArray<string>;
-  readonly sessionExecutionIds: Readonly<Record<string, ReadonlyArray<string>>>;
-  readonly snapshot: AgentCandidateWorkspaceSnapshotEvidence;
-  readonly provenance: ProviderWorkspaceCaptureProvenance;
-  readonly coverageComplete: boolean;
-  readonly incompleteReason?: string;
+interface AgenticOptions {
+  routerBaseUrl: string;
+  routerKey: string;
+  /** Exact worker identity. Model and standing instructions are read only from this profile. */
+  workerProfile: AgentProfile;
+  /** Optional completion transport (see `RouterConfig.complete`): when set, BOTH legs of an
+   *  offline run use it instead of `fetch`-ing the router — the worker's tool loop (threaded into
+   *  its `routerToolLoop` cfg) AND the analyst's critic (its `ChatClient` is bound to this same
+   *  transport). One injected responder serves both, as a localhost mock endpoint would. Absent ⇒
+   *  the live router fetch path (the default). */
+  complete?: (body: Record<string, unknown>) => Promise<unknown>;
+  /** Exact critic identity. Omitted means the exact worker profile also runs the critic. */
+  analystProfile?: AgentProfile;
+  /** Across-run learning: when set, the analyst's observe() pass appends trace-derived
+   *  facts here (the flywheel write side). Read-back is opt-in via `corpusReadback`
+   *  because unconditional priming can pollute context on some domains. */
+  corpus?: Corpus;
+  /** Tags written onto learned facts (and used by the caller's priming query). */
+  corpusTags?: string[];
+  /** In-context learning: when set, query `corpus` before each depth shot and inject
+   *  the top trace-derived facts as guidance for the active run. No corpus means no read-back. */
+  corpusReadback?: CorpusReadbackOptions;
 }
-/** A failed capture keeps the live source handle available for an explicit retry. */
-declare class SandboxEvidenceRetentionError extends Error {
-  readonly box: SandboxInstance;
-  constructor(box: SandboxInstance, cause: unknown);
+interface CorpusReadbackOptions {
+  /** Minimum confidence for a fact to be injected. Default 0.7. */
+  minConfidence?: number;
+  /** Extra tags a fact must carry, in addition to `corpusTags`. */
+  tags?: ReadonlyArray<string>;
+  /** Max facts injected per shot. Default 3. */
+  maxFacts?: number;
+  /** Default false: only facts tagged `audience:agent` are injected into the worker. */
+  includeOperatorFacts?: boolean;
 }
-/** Capture, verify, durably record, then destroy. A failure leaves the source intact. */
-declare function captureBeforeDestroy(port: SandboxEvidenceRetentionPort, context: SandboxEvidenceContext, destroy: () => Promise<void>): Promise<SandboxEvidenceReceipt>;
-//#endregion
-//#region src/runtime/run-loop.d.ts
-/** @stable */
-interface RunAgentRoundsOptions<Task, Output, Decision> {
-  driver: Driver<Task, Output, Decision>;
-  /**
-   * Single agent spec — every iteration uses this profile. Mutually
-   * exclusive with `agentRuns`.
-   */
-  agentRun?: AgentRunSpec<Task>;
-  /**
-   * Multiple specs for heterogeneous fanout. The kernel round-robins
-   * through them when the driver plans N tasks. Mutually exclusive with
-   * `agentRun`.
-   */
-  agentRuns?: AgentRunSpec<Task>[];
-  output: OutputAdapter<Output>;
-  validator?: Validator<Output>;
-  task: Task;
-  ctx: ExecCtx;
-  /** Durable Sandbox evidence capture required before any worker box cleanup. */
-  evidenceRetention?: SandboxEvidenceRetentionPort;
-  /** Default 10. Hard cap on total iterations across all `plan()` rounds. */
-  maxIterations?: number;
-  /** Default 4. In-flight worker cap within a single `plan()` batch. */
-  maxConcurrency?: number;
-  /**
-   * Pre-allocated id for trace correlation. Default = `loop-${random}`.
-   * Surfaces as `runId` on every emitted `LoopTraceEvent`.
-   */
+/** One provider-neutral conversation record carried between strategy shots. */
+type StrategyMessage = Record<string, unknown>;
+/** Measured result of one strategy shot. */
+interface StrategyShotResult {
+  messages: StrategyMessage[];
+  score: number;
+  passes: number;
+  total: number;
+  completions: number;
+  toolErrors: number;
+}
+interface AgenticRunResult {
+  /** The strategy name (built-in 'depth'/'breadth' or a custom strategy's name). */
+  mode: string;
+  score: number;
+  resolved: boolean;
+  completions: number;
+  /** DEPTH: score after each shot — the progress-over-rounds curve. BREADTH: best-so-far per rollout. */
+  progression: number[];
+  shots: number;
+  /** Observed billed subtotal. `usdKnown:false` means it is incomplete, never a measured zero. */
+  usd: number;
+  usdKnown: boolean;
+  ms: number;
+  tokens: {
+    input: number;
+    output: number;
+  };
+  tokensKnown: boolean;
+}
+/** DEPTH: one persistent artifact, carried across analyst-steered shots. */
+declare function depthStrategy(surface: AgenticSurface, task: AgenticTask, opts: AgenticOptions, cfg: {
+  maxShots: number;
+}): Agent<unknown, Outcome<unknown>>;
+/** BREADTH: K independent rollouts (each own artifact), verifier picks the best. */
+declare function breadthStrategy(_surface: AgenticSurface, task: AgenticTask, opts: AgenticOptions, cfg: {
+  width: number;
+}): Agent<unknown, Outcome<unknown>>;
+/**
+ * A Strategy is HOW you spend the compute budget to beat the Environment's check — it
+ * builds the driver `Agent` the Supervisor runs. This is the OPEN extension point: a dev
+ * authors their own by implementing `driver()` to return an Agent whose `act()` spawns
+ * shots/analysts via `scope.spawn` / `scope.next` / `scope.send`. The two built-ins are
+ * the reference implementations to copy:
+ *   sample — K INDEPENDENT attempts, keep the best-verifying (best-of-N / resample).
+ *   refine — attempt → observe() reads the trace → steer the next → repeat (iterate).
+ * (A multi-agent "team" is just a Strategy whose driver spawns several different agents.)
+ */
+declare const strategyResult: unique symbol;
+interface Strategy<Result extends StrategyResult = StrategyResult> {
+  readonly name: string;
+  /** @internal Associates a strategy with its typed result without adding a runtime field. */
+  readonly [strategyResult]?: Result;
+  driver(surface: AgenticSurface, task: AgenticTask, opts: AgenticOptions, budget: number): Agent<unknown, Outcome<unknown>>;
+}
+/** Built-in `Strategy`: K independent attempts, keep the best-verifying (best-of-N / resample). */
+declare const sample: Strategy;
+/** Built-in `Strategy`: attempt → `observe()` reads the trace → steer the next attempt → repeat (deepen one lineage). */
+declare const refine: Strategy;
+interface ShotSpec {
+  /** present ⇒ continue this artifact (depth); absent ⇒ the shot opens a fresh one (sample/restart). */
+  handle?: ArtifactHandle;
+  messages?: StrategyMessage[];
+  steer?: string;
+  /** Exact profile for this shot. Omitted means `AgenticOptions.workerProfile`. */
+  profile?: AgentProfile;
+  /** Restrict THIS shot to a subset of the domain's tools (by name) — focus a shot on
+   *  the relevant capabilities. Restriction-only; unknown names throw. Omitted ⇒ all. */
+  tools?: string[];
+}
+interface StrategyResult {
+  score: number;
+  resolved: boolean;
+  completions: number;
+  progression: number[];
+  shots: number;
+}
+/** Artifact lifecycle a strategy may manage itself — open/close ONLY. Raw `call`/`score`
+ *  are withheld: scores reach the body solely through `shot()`'s StrategyShotResult (the
+ *  harness-verified channel), so a body cannot peek the check or fabricate around it. */
+interface StrategyArtifacts {
+  readonly name: string;
+  open(task: AgenticTask): Promise<ArtifactHandle>;
+  close(handle: ArtifactHandle): Promise<void>;
+}
+/** What a strategy body composes with: the artifact lifecycle, the budget, and the two steps. */
+interface StrategyCtx {
+  /** Open/close artifacts the body manages itself (e.g. one persistent handle for depth). */
+  readonly surface: StrategyArtifacts;
+  readonly task: AgenticTask;
+  readonly opts: AgenticOptions;
+  readonly budget: number;
+  readonly scope: Scope<Outcome<unknown>>;
+  /** Run ONE worker shot; its harness-scored result, or null if it went down. */
+  shot(spec?: ShotSpec): Promise<StrategyShotResult | null>;
+  /** The firewalled critic reads the trajectory → a steer string, or null on COMPLETE/down. */
+  critique(messages: StrategyMessage[]): Promise<string | null>;
+  /** The RAW analyst channel: the firewalled critic answers `instruction` over the
+   *  trajectory verbatim — no findings extraction, so verdict-shaped formats
+   *  (CONTINUE/STOP decisions, calibrated predictions) survive. Same firewall:
+   *  trajectory in, never scores. Null when the analyst went down. */
+  consult(messages: StrategyMessage[], instruction: string): Promise<string | null>;
+  /** The tools THIS artifact's task actually offers (names + descriptions only — never
+   *  the implementations). Tool sets vary per task on heterogeneous domains; a strategy
+   *  that restricts shots MUST select from this list, never from hardcoded names. */
+  listTools(handle: ArtifactHandle): Promise<Array<{
+    name: string;
+    description?: string;
+  }>>;
+}
+/** Author a Strategy from the composable steps — the open, compact way. */
+declare function defineStrategy<Result extends StrategyResult>(name: string, run: (ctx: StrategyCtx) => Promise<Result>): Strategy<Result>;
+/** A NEW strategy, authored from the steps (~20 lines): refine, but when a steered shot
+ *  fails to improve the score it ABANDONS that line and restarts fresh (branch-when-stuck)
+ *  — the widen/MCTS idea the depth-stuck failure motivated. Scored keep-best (the best
+ *  checkpoint across all lines), the deployable metric. This is the "experts build BETTER
+ *  optimizations" path: a new technique, compact, with zero Supervisor ceremony. */
+declare const adaptiveRefine: Strategy<{
+  score: number;
+  resolved: boolean;
+  completions: number;
+  progression: number[];
+  shots: number;
+}>;
+/** The explore-then-exploit MIX: spend ⌈budget/2⌉ on independent samples (kept open),
+ *  then refine the best-verifying line with the remaining budget. Sample's basin escape +
+ *  refine's accumulation — the third built-in, authored from the public steps. */
+declare const sampleThenRefine: Strategy<{
+  score: number;
+  resolved: boolean;
+  completions: number;
+  progression: number[];
+  shots: number;
+}>;
+interface RunAgenticOptions<Result extends StrategyResult = StrategyResult> extends AgenticOptions {
+  surface: AgenticSurface;
+  task: AgenticTask;
+  /** Lifecycle observability — every spawn/settle (shots, analysts) streams here live.
+   *  The seam online watchdogs/route-auditors subscribe to. */
+  hooks?: RuntimeHooks;
+  /** A Strategy (the open way) — author/pass your own. Overrides `mode` when present. */
+  strategy?: Strategy<Result>;
+  /** Built-in shorthand: 'depth'→refine, 'breadth'→sample. Default 'depth'. */
+  mode?: 'depth' | 'breadth';
+  /** budget: refine→max shots; sample→rollout width. */
+  budget: number;
+  rootBudget?: Budget;
+  /** Forwarded to `SupervisorOpts.teardownConfirmMs`: how long settlement keeps retrying a child
+   *  teardown the executor has not confirmed. `0` makes one attempt only. Default: 300000. */
+  teardownConfirmMs?: number;
+}
+/** Run a Strategy through the keystone Supervisor — `Agent.act` over a conserved-budget Scope. */
+declare function runAgentic<Result extends StrategyResult = StrategyResult>(opts: RunAgenticOptions<Result>): Promise<AgenticRunResult & Result>;
+//#endregion
+//#region src/runtime/stdio-mcp-client.d.ts
+interface StdioMcpServerSpec {
+  /** Command that starts the MCP server (stdio transport). */
+  command: string;
+  args?: string[];
+  /** Working directory the server starts in (a built candidate's worktree, typically). */
+  cwd?: string;
+  /** Declared public env for the server process. Only a minimal non-sensitive
+   * subset of the parent env is inherited. */
+  env?: Record<string, string>;
+  /** Sensitive env for the server process. These values override `env` and are
+   * redacted from child-supplied errors, tool metadata, and tool results. */
+  protectedEnv?: Record<string, string>;
+  /** Handshake AND per-request timeout (ms). Default 30s. */
+  timeoutMs?: number;
+}
+/** A missing start binary / spawn fault: a SETUP bug, never a failed candidate.
+ *  Graders (the serve verifier) must rethrow this instead of scoring it. */
+declare class McpSpawnFault extends Error {}
+interface McpToolDescriptor {
+  name: string;
+  description?: string;
+  inputSchema?: unknown;
+}
+interface StdioMcpConnection {
+  /** The tools the server exposed at connect time (`tools/list`). */
+  readonly tools: readonly McpToolDescriptor[];
+  /** `tools/call` → the result's text content. A JSON-RPC error / `isError`
+   *  result becomes an `ERROR: …` string (the agent's outcome); a dead
+   *  transport or timeout throws (an infra fault). */
+  callTool(name: string, args: Record<string, unknown>): Promise<string>;
+  /** Kill the server child. Idempotent. */
+  close(): Promise<void>;
+}
+/** Spawn a trusted host command, complete the stdio MCP handshake, and return
+ * the live connection. This low-level function provides no process isolation. */
+declare function connectStdioMcp(spec: StdioMcpServerSpec): Promise<StdioMcpConnection>;
+interface MaterializeLocalMcpOptions {
+  /** Handshake / per-request timeout per server (ms). Default 30s. */
+  timeoutMs?: number;
+  /** Cap on a tool result's text fed back to the worker. Default 2000 chars. */
+  maxResultChars?: number;
+  /** Resolves a server's DECLARED secrets at spawn time — env entries of kind
+   *  `secret-ref` (interface ≥0.40) and the legacy `metadata.secretEnv` map
+   *  (env var name → provider key name). The resolved values reach ONLY the
+   *  child process env — never the profile, the logs, or an error message.
+   *  Fail-closed: a server declaring secrets without a provider (or with a
+   *  missing key) throws instead of booting keyless. */
+  keys?: KeyProvider;
+  /** Required trust decision for profiles that declare local MCP processes.
+   * Omit to refuse all profile-controlled host execution. Passing
+   * `allowLocalMcp: true` is only safe for an author-controlled profile: the
+   * process receives this Runtime's filesystem and network privileges. */
+  profileSecurityPolicy?: AgentProfileSecurityPolicy;
+}
+/** The live same-host materialization of a profile's `mcp` surface. */
+interface LocalMcpMaterialization {
+  /** Worker-facing tool specs: namespaced `<server>__<tool>`, provider-safe schemas. */
+  tools: AgenticTool[];
+  /** Whether `name` is one of this materialization's namespaced tools. */
+  owns(name: string): boolean;
+  /** Route a namespaced call to its server's live stdio child. */
+  call(name: string, args: Record<string, unknown>): Promise<string>;
+  /** Kill every spawned server. Idempotent. */
+  close(): Promise<void>;
+}
+/**
+ * Spawn every enabled stdio server in `profile.mcp` and expose their tools as
+ * `<server>__<tool>` behind one route and close facade.
+ *
+ * Fails closed: a declared server that cannot boot throws, so a profile is never
+ * scored as if it had no MCP surface.
+ */
+declare function materializeLocalMcp(profile: AgentProfile, opts?: MaterializeLocalMcpOptions): Promise<LocalMcpMaterialization>;
+//#endregion
+//#region src/runtime/http-mcp-client.d.ts
+interface HttpMcpServerSpec {
+  /** The MCP endpoint URL, e.g. `https://host/mcp`. */
+  url: string;
+  /** Public request headers (e.g. `{'x-client': 'agent-runtime'}`). */
+  headers?: Record<string, string>;
+  /** Sensitive request headers (e.g. `authorization`). Sent, never surfaced:
+   *  errors and tool results are redacted against these exact values. */
+  protectedHeaders?: Record<string, string>;
+  /** Per-request timeout (ms). Default 30s. */
+  timeoutMs?: number;
+  /** Override fetch (tests + constrained runtimes). */
+  fetchImpl?: typeof fetch;
+}
+//#endregion
+//#region src/runtime/in-process-sandbox-client.d.ts
+/** Context handed to each `onPrompt` call. */
+interface InProcessPromptCtx {
+  /** 0-based round index — increments per `streamPrompt` on the same box.
+   *  Fresh boxes start at 0. */
+  round: number;
+  /** Absolute path of this box's workspace, when a `workdir` was configured.
+   *  Write the deliverable / fixtures here; `fs.read`/`fs.write`/`exec` operate
+   *  over it. `undefined` for pure event-only boxes. */
+  workdir?: string;
+  /** Cooperative cancellation channel for this turn. */
+  signal: AbortSignal;
+  /** The verbatim per-call options the caller passed to the box verb (minus
+   *  `signal`, surfaced above) — lets an offline test assert an options
+   *  passthrough (`model`, `sessionId`, …) actually arrived. */
+  options?: Record<string, unknown>;
+}
+/**
+ * The user callback: given a prompt and its round, produce the box's event
+ * stream for that turn. Return a plain `SandboxEvent[]` (the common case) or an
+ * async iterable for streaming. The callback may also write files into
+ * `ctx.workdir` (read back via `fs.read` or graded by `exec`).
+ */
+type InProcessOnPrompt = (prompt: string, ctx: InProcessPromptCtx) => SandboxEvent[] | AsyncIterable<SandboxEvent> | Promise<SandboxEvent[]>;
+/** @experimental */
+interface InProcessSandboxClientOptions {
+  /** The per-turn behavior — see {@link InProcessOnPrompt}. */
+  onPrompt: InProcessOnPrompt;
+  /**
+   * Opt in to a REAL filesystem-backed box. When set, each `create()` mints a
+   * fresh temp directory (prefixed `<workdir>-`) and the box exposes
+   * `fs.read`/`fs.write` and `exec` over it; `delete()` removes the dir. Omit
+   * for a pure event-only box (no `fs`/`exec` members), which is all a driver
+   * or fanout loop needs.
+   */
+  workdir?: string;
+  /**
+   * Override the box `id`. A string is used verbatim; a function receives the
+   * 0-based create-sequence and returns the id (e.g. machine-keyed placement
+   * demos). Default `in-process-<seq>`. The id is the value `describePlacement`
+   * tags, so set it when a demo's output reads on a meaningful sandbox id.
+   */
+  id?: string | ((seq: number) => string);
+}
+/**
+ * Adapt a single `onPrompt(prompt, ctx)` callback into a `SandboxClient` for
+ * `runAgentRounds` / `openSandboxRun`. Returns a PROPERLY-TYPED `SandboxClient`: the
+ * lone `SandboxInstance` cast (object literal → `declare class`) lives inside
+ * this function, so call sites stay cast-free.
+ *
+ * There is no box, so a per-prompt `backend` override is refused rather than dropped. A per-turn
+ * `model` IS delivered, because `onPrompt` receives the verbatim options and is free to honor it.
+ * Other per-prompt options (`timeoutMs`, `context`) are accepted and ignored.
+ *
+ * @experimental
+ */
+declare function inProcessSandboxClient(options: InProcessSandboxClientOptions): SandboxClient;
+//#endregion
+//#region src/runtime/inline-sandbox-client.d.ts
+/**
+ * Adapt an `ExecutorFactory` into a `SandboxClient` for `runAgentRounds`. The factory is
+ * instantiated fresh per `streamPrompt` (mirrors the per-spawn executor lifecycle):
+ * run once on the prompt, emit the terminal result event, tear down.
+ *
+ * There is no box, so a per-prompt `backend` or `model` override is refused rather than dropped;
+ * other per-prompt options (`timeoutMs`, `context`) are accepted and ignored.
+ */
+declare function inlineSandboxClient(factory: ExecutorFactory<unknown>, defaults?: {
+  profile?: AgentProfile;
+}): SandboxClient;
+//#endregion
+//#region src/runtime/local-sandbox-client.d.ts
+interface LocalSandboxClientOptions {
+  /** Optional code-mode presentation over the same explicitly trusted MCP tools. */
+  codeMode?: true | CodeModeToolsOptions;
+  /** Router endpoint/auth. The exact per-create profile owns model and loop behavior. */
+  router: {
+    baseUrl: string;
+    key: string;
+  };
+  /** Fallback profile when `create(options)` carries none on `backend.profile`. */
+  profile?: AgentProfile;
+  /** Resolves profile-declared MCP secret names at child-process spawn time. */
+  keys?: KeyProvider;
+  /** Explicit trust decision for the exact `profile` bytes supplied here.
+   * Omit to refuse local processes. A permissive policy never transfers to a
+   * different per-create profile and provides no host isolation. */
+  profileSecurityPolicy?: AgentProfileSecurityPolicy;
+}
+/** A same-host `SandboxClient` adapter with no process isolation. Local MCP is
+ * refused unless the caller explicitly supplies a policy that allows it.
+ *
+ * There is no box, so a per-prompt `backend` or `model` override is refused rather than dropped;
+ * other per-prompt options (`timeoutMs`, `context`) are accepted and ignored. */
+declare function localSandboxClient(opts: LocalSandboxClientOptions): SandboxClient;
+//#endregion
+//#region src/runtime/sandbox-evidence-retention.d.ts
+/** One durable capture before a Sandbox box is removed. */
+interface SandboxEvidenceRetentionPort {
+  readonly timeoutMs: number;
+  readonly limits?: Partial<AgentCandidateWorkspaceArchiveLimits>;
+  readonly artifacts: AgentCandidateArtifactPort;
+  capture(context: SandboxEvidenceContext & {
+    readonly signal: AbortSignal;
+  }): Promise<{
+    readonly snapshot: AgentCandidateWorkspaceSnapshotEvidence;
+    readonly provenance: ProviderWorkspaceCaptureProvenance;
+  }>;
+  /** Must durably record this exact verified receipt before returning. */
+  record(receipt: SandboxEvidenceReceipt): Promise<void>;
+}
+interface SandboxEvidenceContext {
+  readonly box: SandboxInstance;
+  readonly executionId: string;
+  readonly profile: AgentProfile;
+  readonly sandboxSessionIds: ReadonlyArray<string>;
+  readonly nativeSessionIds?: ReadonlyArray<string>;
+  readonly sessionExecutionIds: Readonly<Record<string, ReadonlyArray<string>>>;
+}
+interface SandboxEvidenceReceipt {
+  readonly boxId: string;
+  readonly executionId: string;
+  /** Exact authored profile identity without copying credentials into the receipt. */
+  readonly profileDigest: string;
+  readonly scope: 'box';
+  readonly sandboxSessionIds: ReadonlyArray<string>;
+  readonly nativeSessionIds?: ReadonlyArray<string>;
+  readonly sessionExecutionIds: Readonly<Record<string, ReadonlyArray<string>>>;
+  readonly snapshot: AgentCandidateWorkspaceSnapshotEvidence;
+  readonly provenance: ProviderWorkspaceCaptureProvenance;
+  readonly coverageComplete: boolean;
+  readonly incompleteReason?: string;
+}
+/** A failed capture keeps the live source handle available for an explicit retry. */
+declare class SandboxEvidenceRetentionError extends Error {
+  readonly box: SandboxInstance;
+  constructor(box: SandboxInstance, cause: unknown);
+}
+/** Capture, verify, durably record, then destroy. A failure leaves the source intact. */
+declare function captureBeforeDestroy(port: SandboxEvidenceRetentionPort, context: SandboxEvidenceContext, destroy: () => Promise<void>): Promise<SandboxEvidenceReceipt>;
+//#endregion
+//#region src/runtime/run-loop.d.ts
+/** @stable */
+interface RunAgentRoundsOptions<Task, Output, Decision> {
+  driver: Driver<Task, Output, Decision>;
+  /**
+   * Single agent spec — every iteration uses this profile. Mutually
+   * exclusive with `agentRuns`.
+   */
+  agentRun?: AgentRunSpec<Task>;
+  /**
+   * Multiple specs for heterogeneous fanout. The kernel round-robins
+   * through them when the driver plans N tasks. Mutually exclusive with
+   * `agentRun`.
+   */
+  agentRuns?: AgentRunSpec<Task>[];
+  output: OutputAdapter<Output>;
+  validator?: Validator<Output>;
+  task: Task;
+  ctx: ExecCtx;
+  /** Durable Sandbox evidence capture required before any worker box cleanup. */
+  evidenceRetention?: SandboxEvidenceRetentionPort;
+  /** Default 10. Hard cap on total iterations across all `plan()` rounds. */
+  maxIterations?: number;
+  /** Default 4. In-flight worker cap within a single `plan()` batch. */
+  maxConcurrency?: number;
+  /**
+   * Pre-allocated id for trace correlation. Default = `loop-${random}`.
+   * Surfaces as `runId` on every emitted `LoopTraceEvent`.
+   */
   runId?: string;
   /**
    * Clock override; default `Date.now`. Deterministic tests pass a
@@ -16136,313 +16578,90 @@ interface LoopDispatchOptions<Task, Output, Decision, TScenario extends Scenario
    * of every iteration the dispatch runs. The kernel owns `sessionId` and `signal`: both are
    * removed from the supplied value and applied last. A value that is present but is not an
    * object is a `ValidationError`, raised before any box is created.
-   *
-   * Typical use: `backend.model` credentials (`authMode` / `authFiles`) so every cell runs on a
-   * caller-supplied subscription credential, `timeoutMs`, and `context`.
-   */
-  promptOptions?: Omit<PromptOptions, 'signal' | 'sessionId'>;
-  /** Build the per-cell runAgentRounds options from the scenario (+ profile, when
-   *  used with `runProfileMatrix`). */
-  toLoopOptions: (scenario: TScenario, profile: AgentProfile$1) => LoopOptionsForDispatch<Task, Output, Decision>;
-  /** Map the finished loop to the artifact the judges score. Default:
-   *  `result.winner?.output`. A loop with no winner yields `undefined` (judges
-   *  skip the cell) — but the loop's token usage is STILL reported, so the
-   *  integrity guard sees real activity. */
-  toArtifact?: (result: LoopResult<Task, Output, Decision>) => TArtifact;
-  /** Forward `loop.*` trace events into the campaign's scoped trace so loop
-   *  spans correlate with the cell. Default true. */
-  forwardTrace?: boolean;
-  /** Cost-meter source label for the loop's spend. Default `'loop'`. */
-  costSource?: string;
-  /** Provider- or executor-enforced maximum for this whole cell dispatch.
-   * Required by agent-eval before execution when the campaign is cost-capped. */
-  maximumCharge?: MaximumCharge | ((scenario: TScenario, profile: AgentProfile$1) => MaximumCharge | undefined);
-  /** Resolve the model actually served from the completed loop. */
-  resolveCostModel?: (result: LoopResult<Task, Output, Decision>, scenario: TScenario, profile: AgentProfile$1) => string | undefined;
-}
-/** `supervise` options minus Eval-owned cancellation. */
-type SuperviseOptionsForDispatch = Omit<SuperviseOptions, 'signal'>;
-/**
- * Adapt a recursive Runtime `supervise()` tree to one Agent Eval profile-matrix cell.
- *
- * The adapter starts Eval's paid-call record before the tree starts. Runtime remains the sole
- * owner of recursive execution, budgets, and the journal; Eval remains the sole owner of the
- * paid-call admission and resulting receipt.
- */
-interface SuperviseDispatchOptions<TScenario extends Scenario, TArtifact> {
-  /** Build the task passed to the root supervisor for this profile/scenario cell. */
-  toTask: (scenario: TScenario, profile: AgentProfile$1) => unknown;
-  /** Build the Runtime-owned recursive-run options for this profile/scenario cell. */
-  toSuperviseOptions: (scenario: TScenario, profile: AgentProfile$1) => SuperviseOptionsForDispatch;
-  /** Map the terminal tree result to the artifact judges score. Default: winner output. */
-  toArtifact?: (result: SupervisedResult<unknown>) => TArtifact;
-  /** Cost-meter source label. Default `'supervise'`. */
-  costSource?: string;
-  /** Provider- or executor-enforced maximum for the complete supervised tree. */
-  maximumCharge?: MaximumCharge | ((scenario: TScenario, profile: AgentProfile$1) => MaximumCharge | undefined);
-}
-/** Run one recursive supervised tree inside Eval's pre-execution paid-call lifecycle. */
-declare function superviseDispatch<TScenario extends Scenario, TArtifact>(opts: SuperviseDispatchOptions<TScenario, TArtifact>): ProfileDispatchFn<TScenario, TArtifact>;
-/** Options for adapting plain agent-eval campaign scenarios into Runtime cells. */
-interface LoopCampaignDispatchOptions<Task, Output, Decision, TScenario extends Scenario, TArtifact> {
-  /** Sandbox client used for every campaign cell's `runAgentRounds`. */
-  sandboxClient: SandboxClient;
-  /**
-   * Per-prompt sandbox SDK options for every cell, forwarded verbatim into EVERY `streamPrompt`
-   * of every iteration the dispatch runs. The kernel owns `sessionId` and `signal`: both are
-   * removed from the supplied value and applied last. A value that is present but is not an
-   * object is a `ValidationError`, raised before any box is created.
-   */
-  promptOptions?: Omit<PromptOptions, 'signal' | 'sessionId'>;
-  /** Build the per-cell runAgentRounds options from the campaign scenario. */
-  toLoopOptions: (scenario: TScenario) => LoopOptionsForDispatch<Task, Output, Decision>;
-  /** Map the finished loop to the artifact the campaign judges score. */
-  toArtifact?: (result: LoopResult<Task, Output, Decision>) => TArtifact;
-  /** Forward `loop.*` trace events into the campaign's scoped trace. Default true. */
-  forwardTrace?: boolean;
-  /** Cost-meter source label for the loop's spend. Default `'loop'`. */
-  costSource?: string;
-  /** Provider- or executor-enforced maximum for this whole cell dispatch. */
-  maximumCharge?: MaximumCharge | ((scenario: TScenario) => MaximumCharge | undefined);
-  /** Resolve the model actually served from the completed loop. */
-  resolveCostModel?: (result: LoopResult<Task, Output, Decision>, scenario: TScenario) => string | undefined;
-}
-/**
- * Adapter for plain `runCampaign` scenarios. This is the Runtime-side pair for
- * agent-eval fixture scenarios: load fixtures in `agent-eval/campaign`, build
- * the Runtime cell here, and keep paid-call admission, receipts, and traces
- * automatic.
- */
-declare function loopCampaignDispatch<Task, Output, Decision, TScenario extends Scenario, TArtifact>(opts: LoopCampaignDispatchOptions<Task, Output, Decision, TScenario, TArtifact>): DispatchFn<TScenario, TArtifact>;
-/**
- * Adapter for `runProfileMatrix` (profile is an axis). Returns a
- * `ProfileDispatchFn` that runs `runAgentRounds` per (profile, scenario) cell
- * inside Eval's paid-call lifecycle.
- */
-declare function loopDispatch<Task, Output, Decision, TScenario extends Scenario, TArtifact>(opts: LoopDispatchOptions<Task, Output, Decision, TScenario, TArtifact>): ProfileDispatchFn<TScenario, TArtifact>;
-//#endregion
-//#region src/runtime/strategy.d.ts
-interface AgenticTask {
-  readonly id: string;
-  readonly userPrompt: string;
-  /** Opaque domain payload the surface reads (EOPS: servers/verifiers/tools). Drivers never read it. */
-  readonly meta?: Record<string, unknown>;
-}
-interface ArtifactHandle {
-  readonly id: string;
-  readonly surface: string;
-  /** Opaque per-artifact context the surface stashes (EOPS: the seeded gym server + db id). */
-  readonly ctx?: unknown;
-}
-interface AgenticTool {
-  readonly type: 'function';
-  readonly function: {
-    name: string;
-    description?: string;
-    parameters: Record<string, unknown>;
-  };
-}
-interface SurfaceScore {
-  passes: number;
-  total: number;
-  /** Checks excluded as malformed (data defect, not the agent). `total === 0` ⇒ unscoreable. */
-  errored: number;
-}
-/** A stateful, checkable environment an agent operates over with tools. Open behind one interface. */
-interface AgenticSurface {
-  readonly name: string;
-  open(task: AgenticTask): Promise<ArtifactHandle>;
-  tools(task: AgenticTask, handle: ArtifactHandle): Promise<AgenticTool[]>;
-  call(handle: ArtifactHandle, name: string, args: Record<string, unknown>): Promise<string>;
-  score(task: AgenticTask, handle: ArtifactHandle): Promise<SurfaceScore>;
-  close(handle: ArtifactHandle): Promise<void>;
-}
-interface AgenticOptions {
-  routerBaseUrl: string;
-  routerKey: string;
-  /** Exact worker identity. Model and standing instructions are read only from this profile. */
-  workerProfile: AgentProfile;
-  /** Optional completion transport (see `RouterConfig.complete`): when set, BOTH legs of an
-   *  offline run use it instead of `fetch`-ing the router — the worker's tool loop (threaded into
-   *  its `routerToolLoop` cfg) AND the analyst's critic (its `ChatClient` is bound to this same
-   *  transport). One injected responder serves both, as a localhost mock endpoint would. Absent ⇒
-   *  the live router fetch path (the default). */
-  complete?: (body: Record<string, unknown>) => Promise<unknown>;
-  /** Exact critic identity. Omitted means the exact worker profile also runs the critic. */
-  analystProfile?: AgentProfile;
-  /** Across-run learning: when set, the analyst's observe() pass appends trace-derived
-   *  facts here (the flywheel write side). Read-back is opt-in via `corpusReadback`
-   *  because unconditional priming can pollute context on some domains. */
-  corpus?: Corpus;
-  /** Tags written onto learned facts (and used by the caller's priming query). */
-  corpusTags?: string[];
-  /** In-context learning: when set, query `corpus` before each depth shot and inject
-   *  the top trace-derived facts as guidance for the active run. No corpus means no read-back. */
-  corpusReadback?: CorpusReadbackOptions;
-}
-interface CorpusReadbackOptions {
-  /** Minimum confidence for a fact to be injected. Default 0.7. */
-  minConfidence?: number;
-  /** Extra tags a fact must carry, in addition to `corpusTags`. */
-  tags?: ReadonlyArray<string>;
-  /** Max facts injected per shot. Default 3. */
-  maxFacts?: number;
-  /** Default false: only facts tagged `audience:agent` are injected into the worker. */
-  includeOperatorFacts?: boolean;
-}
-/** One provider-neutral conversation record carried between strategy shots. */
-type StrategyMessage = Record<string, unknown>;
-/** Measured result of one strategy shot. */
-interface StrategyShotResult {
-  messages: StrategyMessage[];
-  score: number;
-  passes: number;
-  total: number;
-  completions: number;
-  toolErrors: number;
-}
-interface AgenticRunResult {
-  /** The strategy name (built-in 'depth'/'breadth' or a custom strategy's name). */
-  mode: string;
-  score: number;
-  resolved: boolean;
-  completions: number;
-  /** DEPTH: score after each shot — the progress-over-rounds curve. BREADTH: best-so-far per rollout. */
-  progression: number[];
-  shots: number;
-  /** Observed billed subtotal. `usdKnown:false` means it is incomplete, never a measured zero. */
-  usd: number;
-  usdKnown: boolean;
-  ms: number;
-  tokens: {
-    input: number;
-    output: number;
-  };
-  tokensKnown: boolean;
-}
-/** DEPTH: one persistent artifact, carried across analyst-steered shots. */
-declare function depthStrategy(surface: AgenticSurface, task: AgenticTask, opts: AgenticOptions, cfg: {
-  maxShots: number;
-}): Agent<unknown, Outcome<unknown>>;
-/** BREADTH: K independent rollouts (each own artifact), verifier picks the best. */
-declare function breadthStrategy(_surface: AgenticSurface, task: AgenticTask, opts: AgenticOptions, cfg: {
-  width: number;
-}): Agent<unknown, Outcome<unknown>>;
-/**
- * A Strategy is HOW you spend the compute budget to beat the Environment's check — it
- * builds the driver `Agent` the Supervisor runs. This is the OPEN extension point: a dev
- * authors their own by implementing `driver()` to return an Agent whose `act()` spawns
- * shots/analysts via `scope.spawn` / `scope.next` / `scope.send`. The two built-ins are
- * the reference implementations to copy:
- *   sample — K INDEPENDENT attempts, keep the best-verifying (best-of-N / resample).
- *   refine — attempt → observe() reads the trace → steer the next → repeat (iterate).
- * (A multi-agent "team" is just a Strategy whose driver spawns several different agents.)
- */
-declare const strategyResult: unique symbol;
-interface Strategy<Result extends StrategyResult = StrategyResult> {
-  readonly name: string;
-  /** @internal Associates a strategy with its typed result without adding a runtime field. */
-  readonly [strategyResult]?: Result;
-  driver(surface: AgenticSurface, task: AgenticTask, opts: AgenticOptions, budget: number): Agent<unknown, Outcome<unknown>>;
-}
-/** Built-in `Strategy`: K independent attempts, keep the best-verifying (best-of-N / resample). */
-declare const sample: Strategy;
-/** Built-in `Strategy`: attempt → `observe()` reads the trace → steer the next attempt → repeat (deepen one lineage). */
-declare const refine: Strategy;
-interface ShotSpec {
-  /** present ⇒ continue this artifact (depth); absent ⇒ the shot opens a fresh one (sample/restart). */
-  handle?: ArtifactHandle;
-  messages?: StrategyMessage[];
-  steer?: string;
-  /** Exact profile for this shot. Omitted means `AgenticOptions.workerProfile`. */
-  profile?: AgentProfile;
-  /** Restrict THIS shot to a subset of the domain's tools (by name) — focus a shot on
-   *  the relevant capabilities. Restriction-only; unknown names throw. Omitted ⇒ all. */
-  tools?: string[];
-}
-interface StrategyResult {
-  score: number;
-  resolved: boolean;
-  completions: number;
-  progression: number[];
-  shots: number;
-}
-/** Artifact lifecycle a strategy may manage itself — open/close ONLY. Raw `call`/`score`
- *  are withheld: scores reach the body solely through `shot()`'s StrategyShotResult (the
- *  harness-verified channel), so a body cannot peek the check or fabricate around it. */
-interface StrategyArtifacts {
-  readonly name: string;
-  open(task: AgenticTask): Promise<ArtifactHandle>;
-  close(handle: ArtifactHandle): Promise<void>;
+   *
+   * Typical use: `backend.model` credentials (`authMode` / `authFiles`) so every cell runs on a
+   * caller-supplied subscription credential, `timeoutMs`, and `context`.
+   */
+  promptOptions?: Omit<PromptOptions, 'signal' | 'sessionId'>;
+  /** Build the per-cell runAgentRounds options from the scenario (+ profile, when
+   *  used with `runProfileMatrix`). */
+  toLoopOptions: (scenario: TScenario, profile: AgentProfile$1) => LoopOptionsForDispatch<Task, Output, Decision>;
+  /** Map the finished loop to the artifact the judges score. Default:
+   *  `result.winner?.output`. A loop with no winner yields `undefined` (judges
+   *  skip the cell) — but the loop's token usage is STILL reported, so the
+   *  integrity guard sees real activity. */
+  toArtifact?: (result: LoopResult<Task, Output, Decision>) => TArtifact;
+  /** Forward `loop.*` trace events into the campaign's scoped trace so loop
+   *  spans correlate with the cell. Default true. */
+  forwardTrace?: boolean;
+  /** Cost-meter source label for the loop's spend. Default `'loop'`. */
+  costSource?: string;
+  /** Provider- or executor-enforced maximum for this whole cell dispatch.
+   * Required by agent-eval before execution when the campaign is cost-capped. */
+  maximumCharge?: MaximumCharge | ((scenario: TScenario, profile: AgentProfile$1) => MaximumCharge | undefined);
+  /** Resolve the model actually served from the completed loop. */
+  resolveCostModel?: (result: LoopResult<Task, Output, Decision>, scenario: TScenario, profile: AgentProfile$1) => string | undefined;
 }
-/** What a strategy body composes with: the artifact lifecycle, the budget, and the two steps. */
-interface StrategyCtx {
-  /** Open/close artifacts the body manages itself (e.g. one persistent handle for depth). */
-  readonly surface: StrategyArtifacts;
-  readonly task: AgenticTask;
-  readonly opts: AgenticOptions;
-  readonly budget: number;
-  readonly scope: Scope<Outcome<unknown>>;
-  /** Run ONE worker shot; its harness-scored result, or null if it went down. */
-  shot(spec?: ShotSpec): Promise<StrategyShotResult | null>;
-  /** The firewalled critic reads the trajectory → a steer string, or null on COMPLETE/down. */
-  critique(messages: StrategyMessage[]): Promise<string | null>;
-  /** The RAW analyst channel: the firewalled critic answers `instruction` over the
-   *  trajectory verbatim — no findings extraction, so verdict-shaped formats
-   *  (CONTINUE/STOP decisions, calibrated predictions) survive. Same firewall:
-   *  trajectory in, never scores. Null when the analyst went down. */
-  consult(messages: StrategyMessage[], instruction: string): Promise<string | null>;
-  /** The tools THIS artifact's task actually offers (names + descriptions only — never
-   *  the implementations). Tool sets vary per task on heterogeneous domains; a strategy
-   *  that restricts shots MUST select from this list, never from hardcoded names. */
-  listTools(handle: ArtifactHandle): Promise<Array<{
-    name: string;
-    description?: string;
-  }>>;
+/** `supervise` options minus Eval-owned cancellation. */
+type SuperviseOptionsForDispatch = Omit<SuperviseOptions, 'signal'>;
+/**
+ * Adapt a recursive Runtime `supervise()` tree to one Agent Eval profile-matrix cell.
+ *
+ * The adapter starts Eval's paid-call record before the tree starts. Runtime remains the sole
+ * owner of recursive execution, budgets, and the journal; Eval remains the sole owner of the
+ * paid-call admission and resulting receipt.
+ */
+interface SuperviseDispatchOptions<TScenario extends Scenario, TArtifact> {
+  /** Build the task passed to the root supervisor for this profile/scenario cell. */
+  toTask: (scenario: TScenario, profile: AgentProfile$1) => unknown;
+  /** Build the Runtime-owned recursive-run options for this profile/scenario cell. */
+  toSuperviseOptions: (scenario: TScenario, profile: AgentProfile$1) => SuperviseOptionsForDispatch;
+  /** Map the terminal tree result to the artifact judges score. Default: winner output. */
+  toArtifact?: (result: SupervisedResult<unknown>) => TArtifact;
+  /** Cost-meter source label. Default `'supervise'`. */
+  costSource?: string;
+  /** Provider- or executor-enforced maximum for the complete supervised tree. */
+  maximumCharge?: MaximumCharge | ((scenario: TScenario, profile: AgentProfile$1) => MaximumCharge | undefined);
 }
-/** Author a Strategy from the composable steps — the open, compact way. */
-declare function defineStrategy<Result extends StrategyResult>(name: string, run: (ctx: StrategyCtx) => Promise<Result>): Strategy<Result>;
-/** A NEW strategy, authored from the steps (~20 lines): refine, but when a steered shot
- *  fails to improve the score it ABANDONS that line and restarts fresh (branch-when-stuck)
- *  — the widen/MCTS idea the depth-stuck failure motivated. Scored keep-best (the best
- *  checkpoint across all lines), the deployable metric. This is the "experts build BETTER
- *  optimizations" path: a new technique, compact, with zero Supervisor ceremony. */
-declare const adaptiveRefine: Strategy<{
-  score: number;
-  resolved: boolean;
-  completions: number;
-  progression: number[];
-  shots: number;
-}>;
-/** The explore-then-exploit MIX: spend ⌈budget/2⌉ on independent samples (kept open),
- *  then refine the best-verifying line with the remaining budget. Sample's basin escape +
- *  refine's accumulation — the third built-in, authored from the public steps. */
-declare const sampleThenRefine: Strategy<{
-  score: number;
-  resolved: boolean;
-  completions: number;
-  progression: number[];
-  shots: number;
-}>;
-interface RunAgenticOptions<Result extends StrategyResult = StrategyResult> extends AgenticOptions {
-  surface: AgenticSurface;
-  task: AgenticTask;
-  /** Lifecycle observability — every spawn/settle (shots, analysts) streams here live.
-   *  The seam online watchdogs/route-auditors subscribe to. */
-  hooks?: RuntimeHooks;
-  /** A Strategy (the open way) — author/pass your own. Overrides `mode` when present. */
-  strategy?: Strategy<Result>;
-  /** Built-in shorthand: 'depth'→refine, 'breadth'→sample. Default 'depth'. */
-  mode?: 'depth' | 'breadth';
-  /** budget: refine→max shots; sample→rollout width. */
-  budget: number;
-  rootBudget?: Budget;
-  /** Forwarded to `SupervisorOpts.teardownConfirmMs`: how long settlement keeps retrying a child
-   *  teardown the executor has not confirmed. `0` makes one attempt only. Default: 300000. */
-  teardownConfirmMs?: number;
+/** Run one recursive supervised tree inside Eval's pre-execution paid-call lifecycle. */
+declare function superviseDispatch<TScenario extends Scenario, TArtifact>(opts: SuperviseDispatchOptions<TScenario, TArtifact>): ProfileDispatchFn<TScenario, TArtifact>;
+/** Options for adapting plain agent-eval campaign scenarios into Runtime cells. */
+interface LoopCampaignDispatchOptions<Task, Output, Decision, TScenario extends Scenario, TArtifact> {
+  /** Sandbox client used for every campaign cell's `runAgentRounds`. */
+  sandboxClient: SandboxClient;
+  /**
+   * Per-prompt sandbox SDK options for every cell, forwarded verbatim into EVERY `streamPrompt`
+   * of every iteration the dispatch runs. The kernel owns `sessionId` and `signal`: both are
+   * removed from the supplied value and applied last. A value that is present but is not an
+   * object is a `ValidationError`, raised before any box is created.
+   */
+  promptOptions?: Omit<PromptOptions, 'signal' | 'sessionId'>;
+  /** Build the per-cell runAgentRounds options from the campaign scenario. */
+  toLoopOptions: (scenario: TScenario) => LoopOptionsForDispatch<Task, Output, Decision>;
+  /** Map the finished loop to the artifact the campaign judges score. */
+  toArtifact?: (result: LoopResult<Task, Output, Decision>) => TArtifact;
+  /** Forward `loop.*` trace events into the campaign's scoped trace. Default true. */
+  forwardTrace?: boolean;
+  /** Cost-meter source label for the loop's spend. Default `'loop'`. */
+  costSource?: string;
+  /** Provider- or executor-enforced maximum for this whole cell dispatch. */
+  maximumCharge?: MaximumCharge | ((scenario: TScenario) => MaximumCharge | undefined);
+  /** Resolve the model actually served from the completed loop. */
+  resolveCostModel?: (result: LoopResult<Task, Output, Decision>, scenario: TScenario) => string | undefined;
 }
-/** Run a Strategy through the keystone Supervisor — `Agent.act` over a conserved-budget Scope. */
-declare function runAgentic<Result extends StrategyResult = StrategyResult>(opts: RunAgenticOptions<Result>): Promise<AgenticRunResult & Result>;
+/**
+ * Adapter for plain `runCampaign` scenarios. This is the Runtime-side pair for
+ * agent-eval fixture scenarios: load fixtures in `agent-eval/campaign`, build
+ * the Runtime cell here, and keep paid-call admission, receipts, and traces
+ * automatic.
+ */
+declare function loopCampaignDispatch<Task, Output, Decision, TScenario extends Scenario, TArtifact>(opts: LoopCampaignDispatchOptions<Task, Output, Decision, TScenario, TArtifact>): DispatchFn<TScenario, TArtifact>;
+/**
+ * Adapter for `runProfileMatrix` (profile is an axis). Returns a
+ * `ProfileDispatchFn` that runs `runAgentRounds` per (profile, scenario) cell
+ * inside Eval's paid-call lifecycle.
+ */
+declare function loopDispatch<Task, Output, Decision, TScenario extends Scenario, TArtifact>(opts: LoopDispatchOptions<Task, Output, Decision, TScenario, TArtifact>): ProfileDispatchFn<TScenario, TArtifact>;
 //#endregion
 //#region src/runtime/run-benchmark.d.ts
 /** A checkable task domain — implement these 5 hooks and the suite does the rest. The
@@ -17524,81 +17743,6 @@ interface OpenSandboxRunOptions {
  */
 declare function openSandboxRun<Out>(client: SandboxClient, options: OpenSandboxRunOptions, deliverable: Deliverable<Out>): Promise<SandboxRun<Out>>;
 //#endregion
-//#region src/runtime/stdio-mcp-client.d.ts
-interface StdioMcpServerSpec {
-  /** Command that starts the MCP server (stdio transport). */
-  command: string;
-  args?: string[];
-  /** Working directory the server starts in (a built candidate's worktree, typically). */
-  cwd?: string;
-  /** Declared public env for the server process. Only a minimal non-sensitive
-   * subset of the parent env is inherited. */
-  env?: Record<string, string>;
-  /** Sensitive env for the server process. These values override `env` and are
-   * redacted from child-supplied errors, tool metadata, and tool results. */
-  protectedEnv?: Record<string, string>;
-  /** Handshake AND per-request timeout (ms). Default 30s. */
-  timeoutMs?: number;
-}
-/** A missing start binary / spawn fault: a SETUP bug, never a failed candidate.
- *  Graders (the serve verifier) must rethrow this instead of scoring it. */
-declare class McpSpawnFault extends Error {}
-interface McpToolDescriptor {
-  name: string;
-  description?: string;
-  inputSchema?: unknown;
-}
-interface StdioMcpConnection {
-  /** The tools the server exposed at connect time (`tools/list`). */
-  readonly tools: readonly McpToolDescriptor[];
-  /** `tools/call` → the result's text content. A JSON-RPC error / `isError`
-   *  result becomes an `ERROR: …` string (the agent's outcome); a dead
-   *  transport or timeout throws (an infra fault). */
-  callTool(name: string, args: Record<string, unknown>): Promise<string>;
-  /** Kill the server child. Idempotent. */
-  close(): Promise<void>;
-}
-/** Spawn a trusted host command, complete the stdio MCP handshake, and return
- * the live connection. This low-level function provides no process isolation. */
-declare function connectStdioMcp(spec: StdioMcpServerSpec): Promise<StdioMcpConnection>;
-interface MaterializeLocalMcpOptions {
-  /** Handshake / per-request timeout per server (ms). Default 30s. */
-  timeoutMs?: number;
-  /** Cap on a tool result's text fed back to the worker. Default 2000 chars. */
-  maxResultChars?: number;
-  /** Resolves a server's DECLARED secrets at spawn time — env entries of kind
-   *  `secret-ref` (interface ≥0.40) and the legacy `metadata.secretEnv` map
-   *  (env var name → provider key name). The resolved values reach ONLY the
-   *  child process env — never the profile, the logs, or an error message.
-   *  Fail-closed: a server declaring secrets without a provider (or with a
-   *  missing key) throws instead of booting keyless. */
-  keys?: KeyProvider;
-  /** Required trust decision for profiles that declare local MCP processes.
-   * Omit to refuse all profile-controlled host execution. Passing
-   * `allowLocalMcp: true` is only safe for an author-controlled profile: the
-   * process receives this Runtime's filesystem and network privileges. */
-  profileSecurityPolicy?: AgentProfileSecurityPolicy;
-}
-/** The live same-host materialization of a profile's `mcp` surface. */
-interface LocalMcpMaterialization {
-  /** Worker-facing tool specs: namespaced `<server>__<tool>`, provider-safe schemas. */
-  tools: AgenticTool[];
-  /** Whether `name` is one of this materialization's namespaced tools. */
-  owns(name: string): boolean;
-  /** Route a namespaced call to its server's live stdio child. */
-  call(name: string, args: Record<string, unknown>): Promise<string>;
-  /** Kill every spawned server. Idempotent. */
-  close(): Promise<void>;
-}
-/**
- * Spawn every enabled stdio server in `profile.mcp` and expose their tools as
- * `<server>__<tool>` behind one route and close facade.
- *
- * Fails closed: a declared server that cannot boot throws, so a profile is never
- * scored as if it had no MCP surface.
- */
-declare function materializeLocalMcp(profile: AgentProfile, opts?: MaterializeLocalMcpOptions): Promise<LocalMcpMaterialization>;
-//#endregion
 //#region src/runtime/strategy-author.d.ts
 /** The compressed consumable a skill carries: everything an author needs to emit a loop. */
 declare const strategyAuthorContract = "\nYou author an OPTIMIZATION STRATEGY for an agentic loop system. A strategy decides how to\nspend a compute budget to beat a task's deployable check. You compose exactly two steps:\n\n  shot(spec?: { handle?, messages?, steer?, profile?, tools? }): Promise<ShotResult | null>\n    Runs ONE worker attempt (a bounded tool loop) over an artifact.\n    - omit handle  => the shot opens its OWN fresh artifact and closes it after (a sample).\n    - pass handle  => the shot CONTINUES that artifact (state accumulates across shots).\n    - messages     => the carried conversation (pass the previous ShotResult.messages to continue).\n    - steer        => a corrective instruction injected before the shot.\n    - profile      => a complete AgentProfile — give THIS shot its own instructions,\n      model, skills, tools, hooks, and subagents. Include name, harness, and\n      model: { provider, default }; put standing instructions in prompt.systemPrompt.\n      For example: { ...opts.workerProfile, name: 'researcher',\n        prompt: { ...opts.workerProfile.prompt,\n          systemPrompt: 'Inspect the evidence before proposing a change.' } }.\n      Choose an available model from the current execution setup. Omit profile to use\n      the worker's exact profile. Every shot spends from the same conserved budget.\n    - tools        => string[] — restrict THIS shot to a subset of the task's tools by\n      name (focus an explore shot on read-only tools, an execute shot on write tools).\n      Restriction-only; unknown names make the shot fail. ALWAYS select from\n      await listTools(handle) — never hardcode. Omitted => the shot sees every tool.\n    ShotResult = { messages, score (0..1 on the task's check), passes, total, completions, toolErrors }\n    Returns null if the attempt failed infra-wise.\n\n  critique(messages): Promise<string | null>\n    A firewalled trace-analyst reads the attempt's trajectory and returns ONE corrective\n    instruction (or null when it judges the work complete). Costs ~1 completion.\n\n  consult(messages, instruction): Promise<string | null>\n    The RAW analyst channel: the same firewalled critic answers YOUR instruction over the\n    trajectory verbatim (no reformatting) — use it when you need a specific reply format\n    (a decision, a prediction). Costs ~1 completion.\n\n  surface.open(task) / surface.close(handle)\n    Open a persistent artifact you manage yourself (remember to close in a finally).\n    close is idempotent — closing an already-closed handle is a safe no-op.\n\n  listTools(handle): Promise<Array<{ name, description? }>>\n    The tools THIS task actually offers. TOOL SETS VARY PER TASK — if you restrict a\n    shot with `tools`, you MUST pick names from await listTools(handle); hardcoding\n    names from an example kills your shots on every task whose tools differ.\n\nRules:\n- ALWAYS await every shot/critique/surface call — a floating promise that rejects\n  crashes the whole benchmark run.\n- Stay within ~budget total shots; every shot/critique spends from a conserved pool.\n- For a FRESH attempt OMIT `messages` entirely (never pass `[]` — an empty array is a\n  fresh conversation too, but be explicit). To CONTINUE, pass the previous\n  ShotResult.messages unchanged.\n- Return { score, resolved, completions, progression, shots } — score = the BEST checkpoint\n  you reached (keep-best, never final-state), progression = score after each shot.\n- The module must be EXACTLY this shape (no other imports, no commentary outside code):\n\nimport { defineStrategy } from '@tangle-network/agent-runtime/kernel'\nexport default defineStrategy('your-strategy-name', async ({ surface, task, opts, budget, shot, critique, listTools }) => {\n  // your composition (listTools comes from the destructured context — it is NOT a global)\n})\n";
@@ -19119,6 +19263,35 @@ interface ProvisionedSupervisor {
  */
 declare function provisionSupervisor(request: ProvisionSupervisorRequest): Promise<ProvisionedSupervisor>;
 //#endregion
+//#region src/runtime/supervise/remote-supervisor.d.ts
+/** Minimal agent identity and topology returned by the protected reader. */
+interface RemoteSupervisorAgent {
+  readonly id: string;
+  readonly parent?: string;
+  readonly label: string;
+  readonly status: string;
+  readonly runtime: string;
+}
+/** Current owned tree, including nested managers and resumed nodes. */
+interface RemoteSupervisorTree {
+  readonly root: string;
+  readonly nodes: readonly RemoteSupervisorAgent[];
+  readonly inFlight: number;
+}
+/** The same bounded event page served by Scope's live observation owner. */
+type RemoteWorkerEvents = WorkerEventPage;
+/** The existing coordination transport, restricted to reading the owned tree and worker output. */
+interface RemoteSupervisorReader {
+  tree(): Promise<RemoteSupervisorTree>;
+  observe(workerId: string, cursor?: WorkerEventCursor): Promise<{
+    agent: Record<string, unknown>;
+    events: RemoteWorkerEvents;
+  }>;
+  close(): Promise<void>;
+}
+/** Connect with the server's readOnly URL and protected headers; credentials never enter a profile. */
+declare function connectRemoteSupervisor(spec: HttpMcpServerSpec): Promise<RemoteSupervisorReader>;
+//#endregion
 //#region src/runtime/supervise/scope.d.ts
 /** Construction args for `createScope`. The supervisor threads the shared pool, journal,
  *  blob store, and executor registry through; `depth`/`maxDepth` pair the runtime
@@ -19237,6 +19410,159 @@ declare function createScope<Out>(args: ScopeArgs): Scope<Out>;
  */
 declare function settledToIteration<Out>(settled: Settled<Out>): Iteration<unknown, Out>;
 //#endregion
+//#region src/runtime/supervise/search-spec.d.ts
+/**
+ * One multi-agent research configuration: seven orthogonal axes, all data.
+ *
+ * | Axis | Compiles to |
+ * |---|---|
+ * | `state` | always `harness`: the journal, Knowledge and checkpoints hold research state |
+ * | `context` | `continuation.session` |
+ * | `select` | the call: `lead`, `advisor`, `self` → `supervise`; `code` → `runGraph({ brain })`; `fixed` → `runGraph` |
+ * | `workers` | `workerSlots`, `allowedModels`, the worker backend's shared placement |
+ * | `comms` | `peerMail` for `messages` |
+ * | `evaluate` | `continuation.failures`, `continuation.bar`, `analysts` + `analyzeOnSettle` |
+ * | `stop` | `continuation.maxBarren`, `stopRule` |
+ */
+interface SearchSpec {
+  /** Where research state lives. `harness` is the only value: memory that lives only in a harness
+   *  conversation cannot be checkpointed, inspected or ablated. */
+  readonly state: 'harness';
+  /** What a re-entered root's harness session holds. `fresh`: a new session per re-entry whose only
+   *  input is Runtime's full re-entry task. `native`: the same session wherever the backend proves it. */
+  readonly context: 'fresh' | 'native';
+  /**
+   * Who decides the next work. `lead`: the root does work and may spawn. `advisor`: the root only
+   * assigns, sees each epoch fresh, and its workers are leaves. `self`: a convener starts the peers
+   * and the peers divide the work by messages. `code`: the caller's brain drives the root in
+   * process. `fixed`: a static graph.
+   */
+  readonly select: 'lead' | 'advisor' | 'code' | 'self' | 'fixed';
+  readonly workers: {
+    /** Agents working at once below the root (`workerSlots`); 0 runs the root alone. For `self`,
+     *  the number of peers. */
+    readonly count: number;
+    /** Model ids the run may use (`allowedModels`); the root's model must be among them. */
+    readonly models?: ReadonlyArray<string>;
+    /** `isolated`: every worker has its own environment. `shared`: workers may share boxes
+     *  through the provider backend's shared placement. */
+    readonly isolation: 'isolated' | 'shared';
+  };
+  /** Channels between agents. `none`: no workers. `assignments`: briefs down and results up.
+   *  `messages`: assignments plus worker-to-worker peer mail. */
+  readonly comms: 'none' | 'assignments' | 'messages';
+  readonly evaluate: {
+    /** Whether a continuation note carries the check's FAIL lines (`continuation.failures`). */
+    readonly feedback: 'verbatim' | 'off';
+    /** Whether a continuation note states the bar (`continuation.bar`). */
+    readonly bar: 'on' | 'off';
+    /** Analyst kinds run on every settled worker (`analyzeOnSettle`). */
+    readonly analysts?: ReadonlyArray<string>;
+  };
+  readonly stop: {
+    /** Re-entered turns in a row without progress before the run ends (`continuation.maxBarren`). */
+    readonly maxBarren: number;
+    /** End the run when a window of settlements lifts the best score by no more than `minDelta`. */
+    readonly plateau?: {
+      readonly window: number;
+      readonly minDelta: number;
+    };
+  };
+}
+/** The correlation key the compiled call records the spec's digest under. Runtime writes it; a
+ *  caller that supplies it is refused. */
+declare const SEARCH_SPEC_CORRELATION_KEY = "searchSpecDigest";
+/**
+ * Check a spec and return its canonical frozen form: every axis present, no unknown key, no
+ * contradictory pair of values. Lists are sorted, so two specs that mean the same digest the same.
+ */
+declare function assertSearchSpec(spec: unknown): SearchSpec;
+/** The canonical digest of a spec: equal for two specs that mean the same, different otherwise. */
+declare function searchSpecDigest(spec: SearchSpec): Sha256Digest;
+/**
+ * The five configurations Runtime ships, as specs. Each is an ordinary spec: its digest is its
+ * value's, and a consumer that changes any axis passes an inline spec with its own digest.
+ */
+declare const searchPresets: Readonly<{
+  /** One root alone in one session. */
+  solo: () => SearchSpec;
+  /** A doing lead with up to `width` workers at once, each in its own environment; any of them
+   *  may lead its own team within the same bound. */
+  tree: (width: number) => SearchSpec;
+  /** A doing lead with up to `width` workers at once that may share boxes. */
+  swarm: (width: number) => SearchSpec;
+  /** `count` peers started by a convener, dividing the work by peer mail. */
+  peers: (count: number) => SearchSpec;
+  /** Stateless Language Agents (arXiv 2610.07625): an assign-only advisor re-entered fresh every
+   *  epoch from the coordinator's projection, over `width` isolated leaf workers. */
+  sla: (width: number) => SearchSpec;
+}>;
+/** A `SuperviseOptions` key that an axis or a typed input decides. */
+type SearchSpecOwnedOption = 'budget' | 'deliverable' | 'continuation' | 'workerSlots' | 'allowedModels' | 'peerMail' | 'analysts' | 'analyzeOnSettle' | 'stopRule' | 'maxDepth' | 'inheritSpawnRights';
+/** Everything a compiled call needs besides the spec: the problem, its bounds, and the call's
+ *  other options. */
+interface SearchSpecInputs {
+  /** The root, for select `lead`, `advisor` and `self`: the lead, the advisor, or the convener
+   *  that starts the peers. A graph's root is its own node. */
+  readonly profile?: AgentProfile;
+  /** The root's task, for the same three selects. A graph's task is its deliverable's description. */
+  readonly task?: unknown;
+  /** select `code` and `fixed`: the graph's nodes and edges. The compiler adds the deliverable and
+   *  the budget. */
+  readonly graph?: Pick<AgentGraph, 'nodes' | 'edges'>;
+  /** select `code`: the caller's brain that makes every root call (`RunGraphOptions.brain`). */
+  readonly brain?: ToolLoopChat;
+  readonly budget: Budget;
+  /** The completion check. Every spec's run has one: the continuation is sent back by it. */
+  readonly deliverable: DeliverableSpec<unknown>;
+  /** No re-entry starts at or after this instant (epoch ms or ISO 8601). It is the run's time
+   *  bound, not design, so two runs of one spec share a digest. */
+  readonly deadline: number | string;
+  /** The continuation note's words, and the problem's reference result for `evaluate.bar: 'on'`. */
+  readonly continuation: Pick<ContinuationPolicy, 'profile' | 'reference' | 'append'>;
+  /** Profiles the root spawns by name (`registry.profiles`). For select `self`, the peers:
+   *  exactly `workers.count` of them. */
+  readonly workers?: ReadonlyArray<AgentProfile | SuperviseProfileEntry>;
+  /** The registry `evaluate.analysts` names kinds in; a graph's lens analysts resolve against it. */
+  readonly analysts?: AnalystRegistry$1;
+  /** `workers.isolation: 'shared'`: the shared-box pool the provider backend places workers in. */
+  readonly sharedPlacement?: SharedBoxPlacement;
+  /** select `code` and `fixed`: the directive registry the graph's edges name
+   *  (`RunGraphOptions.registry`). */
+  readonly directives?: PromptRegistry;
+  /** Every other option of the call, unchanged: `backend`, `driverBackend`, `coordination`,
+   *  `runDir`, `journal`, `runId`, `makeLeafAgent`, `driveHarness`, and the rest. */
+  readonly options?: Omit<SuperviseOptions, SearchSpecOwnedOption>;
+}
+/** The one call a spec compiles to, with every option inspectable before spend. */
+type CompiledSearchSpec = {
+  readonly call: 'supervise';
+  readonly spec: SearchSpec;
+  readonly digest: Sha256Digest;
+  readonly profile: AgentProfile;
+  readonly task: unknown;
+  readonly options: SuperviseOptions;
+} | {
+  readonly call: 'runGraph';
+  readonly spec: SearchSpec;
+  readonly digest: Sha256Digest;
+  readonly graph: AgentGraph;
+  readonly options: RunGraphOptions;
+};
+/**
+ * Compile a spec onto exactly one existing call. Every refusal names the axis or input and what
+ * would have gone wrong, and happens before any compute.
+ *
+ * ```ts
+ * const compiled = compileSearchSpec(searchPresets.sla(3), { profile, task, budget, deliverable,
+ *   deadline, continuation: { profile: words }, workers, options: { backend, coordination, runDir } })
+ * const result = compiled.call === 'supervise'
+ *   ? await supervise(compiled.profile, compiled.task, compiled.options)
+ *   : (await runGraph(compiled.graph, compiled.options)).result
+ * ```
+ */
+declare function compileSearchSpec(raw: SearchSpec, inputs: SearchSpecInputs): CompiledSearchSpec;
+//#endregion
 //#region src/runtime/supervise/sql-run-context.d.ts
 interface SqlRunContextOptions extends SqlRunStoreOptions, InMemoryRunContextOptions {}
 /** SQL stores are read-only outside an acquired ownership capability. runGraph acquires it. */
@@ -19724,5 +20050,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 { WORKER_TOOL_TRACE_SCHEMA_VERSION as $, RetainedRunStartMaterial as $C, PanelFinding as $S, ForkRequest as $_, LoopCampaignDispatchOptions as $a, mergeTraceEnv as $b, ResolvedWorkerSpawnRetry as $c, openSqlRunStore as $d, RecursiveReservationPolicy as $f, CodexRolloutTurn as $g, DELEGATE_TOOL_NAME as $h, InMemoryCorpus as $i, StopDecision as $l, CoordinationToolsOptions as $m, ProfileRichness as $n, LoopUntilSpec as $o, StartRetainedInteractiveRunOptions as $p, materializeLocalMcp as $r, declaredCheckDigest as $s, recordGraphRun as $t, supervisorRunDir as $u, ToolSpec as $v, RuntimeRunStatus as $w, PeerMailEnvelope as $x, DelegationResumeTick as $y, readWorkerInteractiveBinding as A, NativeContextContinuationExecution as AC, ToolStepInput as AS, mapSandboxToolEvent as A_, AgenticRunResult as Aa, FeedbackRefersTo as Ab, PursuitNodeUsage as Ac, ProfileKeyOf as Ad, ExecutorContext as Af, WorkerProgress as Ag, WorkerWatchOptions as Ah, profileOptimizerModelCall as Ai, ResolveDriveHarness as Al, summarizeDriverAttempts as Am, createPromptRegistry as An, Observation as Ao, TokenUsageProvenance as Ap, visibleCheckScore as Ar, PersonaExecutors as As, WorktreePatchArtifact as At, CoordinationOwnerId as Au, CreateWorktreeOptions as Av, LoopPlanPayload as Aw, sanitizeRuntimeStreamEvent as Ax, detachedSessionDelegate as Ay, copyUntrackedIntoClone as B, RetainedInteractiveStartedAdmission as BC, CONTINUATION_FACTS as BS, AgentEnvironmentQuery as B_, StrategyCtx as Ba, UiLens as Bb, observerRecordDigest as Bc, AnytimeTaskCurve as Bd, FleetYield as Bf, BridgeSeam as Bg, SPAWN_RESOURCE_PATH_MAX_BYTES as Bh, PrivateCasArtifactPort as Bi, assertCoordinationBinding as Bl, AnalystToolGroupName as Bm, delegate as Bn, Corpus as Bo, WorkspaceCheckpointMarker as Bp, AuthorStrategyOptions as Br, LeaderboardFlagSpec as Bs, GraphRegistryDir as Bt, cancelRun as Bu, CodexExecutionPolicy as Bv, MountRecorder as Bw, createDelegationTraceCollector as Bx, DetachedTurnResumeDriverOptions as By, AuthoredHarness as C, RuntimeRunStateError as CC, PublishOptions as CS, SandboxToolPartState as C_, BenchmarkReport as Ca, DelegationProfile as Cb, PursuitObserverDelivery as Cc, GroupOf as Cd, BudgetViolation as Cf, createSteerableSandboxSession as Cg, SpawnPreflightContext as Ch, claimRetainedInteractiveControl as Ci, createSupervisorSpanRecorder as Cl, DriverFailureClass as Cm, defaultEdgeTraversalCap as Cn, InProcessSandboxClientOptions as Co, SpendGap as Cp, filterAuthoredAsserts as Cr, WinnerStrategy as Cs, pickBestProfile as Ct, CoordinationTransportOptions as Cu, ProviderWorkspaceRetentionPort as Cv, LoopDecisionPayload as Cw, RuntimeTelemetryOptions as Cx, CoderReviewer as Cy, WorkerInteractiveBinding as D, DeadlineCheckIn as DC, watchTrace as DS, createSandboxUsageLedger as D_, printBenchmarkReport as Da, DelegationStatusArgs as Db, PursuitNodePlatform as Dc, LeaderboardRow as Dd, ExecutorAccounting as Df, ExecutorProgress as Dg, ToolOutcomeEvent as Dh, ResolveSandboxClientOptions as Di, DriveHarness as Dl, DriverRepromptRefusal as Dm, PromptRegistry as Dn, HarvestFailure as Do, SupervisedResult as Dp, sandboxCheckRunner as Dr, Outcome as Ds, PatchDeliverableOptions as Dt, CoordinationRejectReason as Du, WorktreeCommandResult as Dv, LoopIterationStartedPayload as Dw, createRuntimeStreamEventCollector as Dx, SettleDetachedCoderTurnOptions as Dy, AttachWorkerOptions as E, DEFAULT_CHECK_IN_IDLE_MS as EC, defaultToolDetectors as ES, createSandboxToolPartState as E_, Environment as Ea, DelegationStatus as Eb, PursuitNodePlacement as Ec, LeaderboardOptions as Ed, Executor as Ef, DEFAULT_STALL_AFTER_MS as Eg, SuperviseProfileEntry as Eh, startRetainedInteractiveRun as Ei, CoordinationVerbs as El, DriverReentry as Em, PromptHandle as En, HarvestError as Eo, SubtreeSummary as Ep, resolveEntrySymbol as Er, LoopShape as Es, recordProfileRun as Et, CoordinationHttpOptions as Eu, WorktreeCheckRunner as Ev, LoopIterationEndedPayload as Ew, createRuntimeEventCollector as Ex, DetachedWinnerSelection as Ey, closingWorkerNote as F, RecoverRetainedRunOptions as FC, DeliverableSpec as FS, AgentEnvironmentCapabilities$1 as F_, CorpusReadbackOptions as Fa, UI_FINDING_SEVERITIES as Fb, projectPursuit as Fc, renderLeaderboardMarkdown as Fd, ExecutorProgressEvent as Ff, InboxMessage as Fg, normalizeAnalyzeOnSettle as Fh, AgentTurnUsage as Fi, SupervisorNodeContext as Fl, AnalystDefinitionIssue as Fm, kernelPromptRegistry as Fn, defaultAnalystInstruction as Fo, WidenGate as Fp, StrategyTournament as Fr, ShapeRegistry as Fs, InteractiveWorkerResult as Ft, WorkerCancelRequest as Fu, WorktreeHandle as Fv, LoopTokenUsage as Fw, DelegationTraceCollector as Fx, SiblingSandboxExecutorOptions as Fy, WorkspaceCommit as G, RetainedRunDispatchedAdmission as GC, ContinuationContext as GS, AgentSessionRef as G_, adaptiveRefine as Ga, ResearchSource as Gb, DeliverableResolutionInput as Gc, renderAnytimeTable as Gd, NoWinnerError as Gf, resolveMcpServerLaunch as Gg, hostDirectoryReader as Gh, equalKOnCost as Gi, ManagerWakePolicy as Gl, AuthorizedDownMessage as Gm, ChatSessionStore as Gn, EqualKOnCostOptions as Go, workerTraceHeaders as Gp, strategyAuthorSystemPrompt as Gr, LeaderboardSpec as Gs, graphDigest as Gt, readRunCancellation as Gu, LocalHarnessResult as Gv, ValidationCtx as Gw, FileDelegationStoreOptions as Gx, detachedTurnEvents as Gy, GitWorkspaceOptions as H, RetainedRunAdmissionHook as HC, CheckUnavailableError as HS, AgentEnvironmentSummary as H_, StrategyResult as Ha, KnowledgeUpdate as Hb, AuthorizedSpawn as Hc, areaUnderCurve as Hd, HeldEnvironment as Hf, ResolvedMcpServerLaunch as Hg, SpawnResourceRead as Hh, PrivateCasOffloadReport as Hi, supervisorAgent as Hl, AuthoredAnalystDefinition as Hm, driverAgent as Hn, CorpusRecord as Ho, WorkerTraceSeamCarrier as Hp, assertStrategyContract as Hr, LeaderboardRunContext as Hs, GraphSelection as Ht, legacySupervisorRunDir as Hu, DEFAULT_LOCAL_HARNESS as Hv, RunProvenance as Hw, DelegationStateCorruptError as Hx, DriveTurnTick as Hy, composeWorkerEvidence as I, RecoverRetainedRunResult as IC, ExecutorResultMapping as IS, AgentEnvironmentEvent$1 as I_, RunAgenticOptions as Ia, UI_LENSES as Ib, FileObserverJournal as Ic, renderLeaderboardSvg as Id, ExecutorRegistry as If, PeerInboxMessage as Ig, parseAuthoredAnalystDefinition as Ih, CollectedAgentTurn as Ii, SupervisorNodeContextSeed as Il, AnalystFindingEvent as Im, naiveContinuationPrompt as In, observe as Io, WorkerInteractiveSession as Ip, TournamentCell as Ir, DefinedLeaderboard as Is, workerFromInteractiveProvider as It, WorkerCancellation as Iu, captureWorktreeDiff as Iv, LoopTraceEmitter as Iw, DelegationTraceSpan as Ix, createFleetWorkspaceExecutor as Iy, jjWorkspace as J, RetainedRunEventOptions as JC, ContinuationPanel as JS, CheckpointRef as J_, depthStrategy as Ja, createResearcherValidator as Jb, SuperviseRegistryTable as Jc, WaterfallSpan as Jd, NodeSnapshot as Jf, CodexForkBoundary as Jg, McpServerOptions as Jh, createShapeRegistry as Ji, PlateauOptions as Jl, ContinuationInstruction as Jm, ChatWorkerSeamOptions as Jn, FanoutOptions as Jo, RecoverRetainedInteractiveRunOptions as Jp, McpSpawnFault as Jr, DeclaredCheckPlacement as Js, graphRunsFor as Jt, readWorkerSteerAcknowledgement as Ju, localHarnessExecutable as Jv, RuntimeRunCost as Jw, CoderTask as Jx, runDetachedTurn as Jy, WorkspaceRun as K, RetainedRunEffect as KC, ContinuationEntry as KS, AgentSessionStatus$1 as K_, breadthStrategy as Ka, ResearchTask as Kb, SuperviseOptions as Kc, WaterfallCollector as Kd, NodeExecutionIdentity as Kf, resolveSecretEnv as Kg, resolveSpawnResourcePaths as Kh, trajectoryReport as Ki, AllWorkersStalledOptions as Kl, AwaitWakeInput as Km, ChatTransportExecutorOptions as Kn, EqualKVerdict as Ko, workerTraceSeamKey as Kp, LocalMcpMaterialization as Kr, defineLeaderboard as Ks, graphFromStored as Kt, readWorkerCancelRequests as Ku, RunLocalHarnessOptions as Kv, Validator as Kw, InMemoryDelegationStore as Kx, formatDetachedSessionRef as Ky, settledWorkerOut as L, RetainedInteractiveAdmission as LC, gateOnDeliverable as LS, AgentEnvironmentProvider$1 as L_, ShotSpec as La, UiFinding as Lb, ObserverJournal as Lc, renderPairwiseMarkdown as Ld, ExecutorResult as Lf, createInbox as Lg, questionEscalationTargets as Lh, StreamAgentTurnOptions as Li, SupervisorProfile as Ll, AnalystKind as Lm, promptHandle as Ln, renderReport as Lo, WorkerInteractiveUnavailableReason as Lp, TournamentRow as Lr, LeaderboardBenchScore as Ls, WorkerInteractiveAdmission as Lt, WorkerSteerAcknowledgement as Lu, createWorktree as Lv, LoopTraceEvent as Lw, buildDelegationTraceSpans as Lx, createSiblingSandboxExecutor as Ly, NOTE_MAX_CHARS as M, NativeContextContinuationInput as MC, createPushTraceSource as MS, sandboxProgressEvents as M_, AgenticTask as Ma, UiAuditLensFilter as Mb, PursuitRunProjection as Mc, leaderboard as Md, ExecutorFactory as Mf, readWorkerProgress as Mg, canonicalFindingEvent as Mh, assertProfileModelsAllowed as Mi, ResolvedSupervisorProfile as Ml, RetainedPendingCause as Mm, dumbContinuationFailPrompt as Mn, ObservationError as Mo, UnconfirmedTeardown as Mp, EvolutionReport as Mr, RunPersonifiedOptions as Ms, InteractiveWorkerEnvironment as Mt, PriorCoordination as Mu, DiffResult as Mv, LoopSandboxPlacement as Mw, DELEGATION_TRACE_MAX_BYTES as Mx, DelegationExecutor as My, VERIFY_TAIL_CHARS as N, ReconnectRetainedRunOptions as NC, decodeToolPart as NS, sumSandboxUsage as N_, AgenticTool as Na, UiAuditorDelegationOutput as Nb, PursuitRunTotals as Nc, pairwiseSignificance as Nd, ExecutorMaterialization as Nf, AuthorityInboxMessage as Ng, createCoordinationTools as Nh, AgentTurnBackend as Ni, SupervisorAgentDeps as Nl, ANALYST_DEFINITION_BOUNDS as Nm, dumbContinuationPassPrompt as Nn, ObserveInput as No, UnknownMaterializationReason as Np, EvolutionStrategy as Nr, ShapeBudget as Ns, InteractiveWorkerKeyInput as Nt, RunCancelRequest as Nu, GitRunner as Nv, LoopStartedPayload as Nw, DELEGATION_TRACE_MAX_SPANS as Nx, FleetHandle as Ny, WorkerInteractiveProviderSource as O, WorkerSlots as OC, SessionMessageLike as OS, extractLlmCallEvent as O_, runBenchmark as Oa, DelegationStatusResult as Ob, PursuitNodeProjection as Oc, PairwiseOptions as Od, ExecutorCancellation as Of, ScopeProgressInput as Og, WorkerResumeContext as Oh, resolveSandboxClient as Oi, DriveHarnessOwnerContext as Ol, DriverRetryPolicy as Om, RegisteredPrompt as On, HarvestReport as Oo, Supervisor as Op, selectBestIndex as Or, Persona as Os, patchDelivered as Ot, CoordinationDeliveryEvidence as Ou, WorktreeHarnessResult as Ov, LoopLineageOptions as Ow, sanitizeAgentRuntimeEvent as Ox, UiAuditorDelegate as Oy, WorkerEvidenceInput as P, RecoverRetainedRunIntentOptions as PC, sandboxSessionTraceSource as PS, AgentEnvironment$1 as P_, ArtifactHandle as Pa, delegationProfiles as Pb, PursuitStatus as Pc, renderLeaderboardHtml as Pd, ExecutorNodeContext as Pf, Inbox as Pg, downMessageRefusalReasons as Ph, AgentTurnInput$1 as Pi, SupervisorAgentTestDeps as Pl, AnalystAssignmentRecord as Pm, formatPromptHandle as Pn, ObserveOptions as Po, UsageEvent as Pp, StrategyEvolutionConfig as Pr, ShapeContext as Ps, InteractiveWorkerOptions as Pt, RunCancellation as Pu, RemoveWorktreeOptions as Pv, LoopTeardownFailedPayload as Pw, DelegationTraceCaps as Px, FleetWorkspaceExecutorOptions as Py, analyzeTrace as Q, RetainedRunSnapshot as QC, ContinuationProfile as QS, ExecResult as Q_, sampleThenRefine as Qa, createPropagatingTraceEmitter as Qb, workerFromBackend as Qc, SqlRunStoreOptions as Qd, ProviderModelExecutionEvidence as Qf, CodexRolloutStoreRef as Qg, DELEGATE_INPUT_SCHEMA as Qh, FileCorpus as Qi, ProgressView as Ql, CoordinationTools as Qm, AuthoredProfile as Qn, LoopUntil as Qo, RetainedInteractiveStartMaterial as Qp, connectStdioMcp as Qr, declaredCheckDeliverable as Qs, pickBestGraph as Qt, safeWorkerFile as Qu, RouterTransportConfig as Qv, RuntimeRunRow as Qw, PEER_MAIL_WIRE_KEY as Qx, DelegationResumeDriver as Qy, CopyOptions as R, RetainedInteractiveEnvironmentAdmission as RC, mapExecutorResult as RS, AgentEnvironmentProviderRef as R_, Strategy as Ra, UiFindingScreenshot as Rb, ObserverRecord as Rc, AnytimeReport as Rd, ExecutorTeardownWarning as Rf, BridgeHarnessStore as Rg, ResolveSpawnResourcePathsResult as Rh, collectAgentTurn as Ri, SupervisorToolDescriptor as Rl, AnalystLensOutput as Rm, DelegateOptions as Rn, AssertTraceDerivedFindings as Ro, WorkerTraceEvidence as Rp, runStrategyEvolution as Rr, LeaderboardBenchTask as Rs, InPlaceCliExecutorOptions as Rt, WorkerSteerRequest as Ru, removeWorktree as Rv, LoopWinner as Rw, capDelegationTrace as Rx, DetachedSessionRefParts as Ry, failuresAnalyst as S, RetainedRunDispatchBindingError as SC, EventBus as SS, RuntimeStreamEvent as ST, SandboxServedBackend as S_, BenchmarkLift as Sa, DelegationHistoryResult as Sb, RUN_FORK_CORRELATION_KEYS as Sc, AxisScoresOf as Sd, BudgetOverspend as Sf, SteerableSandboxSession as Sg, SpawnPreflight as Sh, ClaimRetainedInteractiveControlOptions as Si, SupervisorSpanRecorder as Sl, DriverContractState as Sm, TraversalContinuity as Sn, InProcessPromptCtx as So, SpendChannel as Sp, defaultStructuralRolloutPolicy as Sr, WidenSpec as Ss, loadProfile as St, CoordinationPublicAddress as Su, ProviderWorkspaceRetentionContext as Sv, Iteration as Sw, RuntimeStreamEventSummary as Sx, CoderReview as Sy, worktreeFanout as T, DEADLINE_CHECK_IN_MESSAGE as TC, WatchTraceOptions as TS, assertSandboxServedModel as T_, BenchmarkTaskRow as Ta, DelegationResultPayload as Tb, PursuitNodeCost as Tc, Leaderboard as Td, ExecutionBindingReceipt as Tf, ActivityNote as Tg, SpawnRefusalCause as Th, recoverRetainedInteractiveRun as Ti, CoordinationToolFace as Tl, DriverProgressMark as Tm, runGraphWithTestBrain as Tn, HarvestCorpusOptions as To, SubtreeResult as Tp, officialChecksFromMeta as Tr, DefinePersonaInput as Ts, profileRunsForName as Tt, CoordinationHttpAudit as Tu, InPlaceHarnessResult as Tv, LoopIterationDispatchPayload as Tw, SanitizedKnowledgeRequirement as Tx, DetachedSessionDelegateOptions as Ty, Shell as U, RetainedRunCancelOptions as UC, CheckVerdict as US, AgentProfileRef as U_, StrategyShotResult as Ua, MultiHarnessResearcherFanoutOptions as Ub, AuthorizedSpawnContext as Uc, bestSoFar as Ud, MaterializedExecutionIdentity as Uf, envKeyProvider as Ug, SpawnResourceReader as Uh, PrivateCasOptions as Ui, supervisorAgentWithTestBrain as Ul, AuthoredAnalystLimits as Um, finalizeBestDelivered as Un, EqualKArm as Uo, readWorkerTraceContext as Up, authorStrategy as Ur, LeaderboardScenario as Us, StoredGraph as Ut, legacySupervisorRunsRoot as Uu, LOCAL_HARNESSES as Uv, SandboxClient as Uw, DelegationStore as Ux, RunDetachedTurnOptions as Uy, withUntrackedArtifacts as V, RetainedRunAdmission as VC, CheckRead as VS, AgentEnvironmentStatus as V_, StrategyMessage as Va, KnowledgeItem as Vb, verifyObserverRecords as Vc, anytimeReport as Vd, Handle as Vf, KeyProvider as Vg, SpawnResourceBytes as Vh, PrivateCasDurableStore as Vi, resolveSupervisorProfile as Vl, AnalyzeOnSettleRoute as Vm, DriverAgentOptions as Vn, CorpusFilter as Vo, WorkerTraceResolver as Vp, AuthoredStrategy as Vr, LeaderboardIterationInfo as Vs, GraphRunRecord as Vt, cancelWorker as Vu, CodexTokenUsage as Vv, OutputAdapter as Vw, DelegationPersistenceError as Vx, DriveTurnCapableBox as Vy, Workspace as W, RetainedRunCancellation as WC, ContinuationAppend as WS, AgentSession as W_, SurfaceScore as Wa, ResearchOutput as Wb, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as Wc, plateauLength as Wd, MaterializedModelIdentity as Wf, mcpSecretEnvMetadataKey as Wg, environmentReader as Wh, createPrivateCasArtifactPort as Wi, DEFAULT_DEADLINE_WARNING_MS as Wl, AuthorizeDownMessage as Wm, ChatCompletionsTransport as Wn, EqualKOnCost as Wo, workerTraceEnv as Wp, strategyAuthorContract as Wr, LeaderboardScore as Ws, digestOfGraph as Wt, readRunCancelRequest as Wu, LocalHarness as Wv, SelectionReceipt as Ww, FileDelegationStore as Wx, createDetachedTurnResumeDriver as Wy, runInWorkspace as X, RetainedRunIntentAdmission as XC, ContinuationPanelResult as XS, CreateAgentEnvironmentInput$1 as X_, runAgentic as Xa, researcherProfile as Xb, supervise as Xc, SqlRunLease as Xd, ProfileMaterializationReceipt as Xf, CodexRolloutSession as Xg, createMcpServer as Xh, definePersona as Xi, ProgressTracker as Xl, CoordinationEvent as Xm, chatWorkerSeam as Xn, FanoutWinnerSelector as Xo, RetainedInteractiveEnvironmentInput as Xp, StdioMcpConnection as Xr, assertDeclaredCheck as Xs, loadGraph as Xt, runCancelRequestFile as Xu, runLocalHarness as Xv, RuntimeRunOptions as Xw, AUTHORITY_MARKERS as Xx, DelegationRecord as Xy, localShell as Y, RetainedRunHandle as YC, ContinuationPanelInput as YS, CheckpointRequest as Y_, refine as Ya, multiHarnessResearcherFanout as Yb, SuperviseTestOptions as Yc, createWaterfallCollector as Yd, NodeStatus as Yf, CodexRolloutIdentity as Yg, createInProcessTransport as Yh, registerShape as Yi, ProgressSample as Yl, ContinuityMode as Ym, chatTransportExecutor as Yn, FanoutSynthesis as Yo, RetainedInteractiveAdmissionHook as Yp, McpToolDescriptor as Yr, DeclaredCheckStateCapture as Ys, listGraphRuns as Yt, readWorkerSteerRequests as Yu, parseCodexTokenUsage as Yv, RuntimeRunHandle as Yw, coderTaskToPrompt as Yx, DelegationArgs as Yy, TrajectoryAnalysis as Z, RetainedRunReplayPoint as ZC, ContinuationPolicy as ZS, ExecRequest as Z_, sample as Za, TraceContext as Zb, superviseWithTestBrain as Zc, SqlRunOwnershipError as Zd, ProviderModelAttemptEvidence as Zf, CodexRolloutStoreReader as Zg, DELEGATE_DESCRIPTION as Zh, runPersonified as Zi, ProgressTrackerOptions as Zl, CoordinationStats as Zm, createChatSessionStore as Zn, FlatWidenGate as Zo, RetainedInteractiveRunHandle as Zp, StdioMcpServerSpec as Zr, checkProgramDigest as Zs, lookupGraph as Zt, runCancellationFile as Zu, RouterResponseReceipt as Zv, RuntimeRunPersistenceAdapter as Zw, DEFAULT_PEER_MAIL_LIMITS as Zx, DelegationResumeContext as Zy, boxSurfaceReader as _, NotFoundError as _C, McpToolDescriptor$1 as _S, RunAgentTaskOptions as _T, sharedBoxPlacement as __, McpEnvironmentOptions as _a, DelegateUiAuditRoute as _b, SupervisePursuitError as _c, CompletionVerdict as _d, contentAddress as _f, createExecutor as _g, QuestionOption as _h, createS3PrivateCasStore as _i, createInMemoryRunContext as _l, DriverAttemptRecord as _m, GraphEdgeCapError as _n, captureBeforeDestroy as _o, SpawnJournal as _p, VisibleCheck as _r, Verify as _s, SupervisorCleanupReceipt as _t, collectDelivered as _u, ProviderWorkspaceAttemptProvenance as _v, spendFromUsageEvents as _w, padTraceId as _x, FeedbackEvent as _y, SandboxInstance$1 as a, expandQuestions as aC, PeerMailRefusal as aS, AgentKnowledgeProvider as aT, HarnessUsage as a_, pipeline as aa, hashIdempotencyInput as ab, IsolatedCheckResult as ac, workerControlLogFile as ad, FileSpawnJournal as af, validateDelegateArgs as ag, EscalateQuestion as ah, SandboxRunAbortError as ai, retryPreSpawnRefusals as al, HarnessTranscriptUnavailableReason as am, RollingDispatchOptions as an, loopDispatch as ao, RetainedExecutionState as ap, supervisorInstructions as ar, Pipeline as as, createRootHandle as at, noProgressFor as au, ResourceRequest as av, BudgetReadout as aw, OtelExportStats as ax, ToolLoopToolCall as ay, AnalystAuthoring as b, RetainedInteractiveBindingError as bC, BusRecord as bS, RuntimeSession as bT, SandboxLeafOut as b_, BenchmarkCell as ba, DelegationHistoryArgs as bb, supervisePursuit as bc, sentinelCompletion as bd, AgentSpec as bf, SandboxSteeringOptions as bg, QuestionUrgency as bh, startRetainedRun as bi, SupervisorSpanOptions as bl, DriverBudgetReadout as bm, RunGraphOptions as bn, inlineSandboxClient as bo, SpawnRejection as bp, composeCheckSources as br, WidenDecision as bs, ProfileRunRecord as bt, CoordinationAuthentication as bu, ProviderWorkspaceCaptureResult as bv, Driver as bw, RuntimeStreamEventCollector as bx, eventToSnapshot as by, VerifierEnvironmentOptions as c, verdictFromJudgeScore as cC, PeerMailboxOptions as cS, AgentTaskContext as cT, DEFAULT_SHARED_BOX_WORKERS as c_, widen as ca, DelegateCodeResult as cb, NextPursuitVersion as cc, workerSteerAcknowledgementFile as cd, SpawnForest as cf, CliWorktreeBridgeSeam as cg, MakeWorkerAgent as ch, BranchCapableBox as ci, SeatSelection as cl, harnessTranscriptArtifact as cm, rollingDispatch as cn, TERMINAL_DECISIONS as co, RootProviderModelEvidence as cp, CheckRunContext as cr, RenderCorpusToInstructionsOptions as cs, SqlRunContextOptions as ct, ReentryContinuity as cu, providerAsExecutor as cv, ReservationFloor as cw, RuntimeEventOtelOptions as cx, CodeModeStore as cy, HarvestSurfaceDiffsOptions as d, resolveRedactor as dC, isPeerMailEnvelope as dS, AgentTaskStatus as dT, SharedBoxHandle as d_, assertTraceDerivedFindings as da, DelegateResearchArgs as db, PursuitVersionStop as dc, workerSteerRequestsDir as dd, SpawnForestMissingTree as df, ProviderSeam as dg, Question as dh, SessionCapableBox as di, SelectSeat as dl, HarnessTranscriptReadLimits as dm, GraphDesignerExtraTools as dn, isTerminalDecision as do, RootSignal as dp, CheckSourceCtx as dr, ScopeWidenGate as ds, ScopeArgs as dt, composeReentryTask as du, CreateTangleSandboxExactProcessProviderOptions as dv, ReservationShortfall as dw, buildRuntimeEventOtelSpans as dx, CodeModeToolsOptions as dy, VerdictSummary as eC, PeerMailEvent as eS, startRuntimeRun as eT, CodexStoreDelta as e_, renderCorpusToInstructions as ea, DelegationRunContext as eb, declaredCheckJudge as ec, supervisorRunsRoot as ed, D1DatabaseLike as ef, DelegateArgs as eg, DefinedAnalystRecord as eh, Deliverable as ei, WorkerSpawnRetryAttempt as el, HarnessTranscriptArtifact as em, storedGraphDigests as en, LoopDispatchOptions as eo, ResourceLimit as ep, ProfileRichnessThresholds as er, LoopUntilState as es, WorkerToolTraceArtifact as et, StopRule as eu, PlacementInfo as ev, RetainedRunTurnInput as ew, readTraceContextFromEnv as ex, ToolLoopCallContext as ey, SurfaceDiff as f, AgentEvalError$1 as fC, peerMailTools as fS, BackendErrorDetail as fT, SharedBoxPlacement as f_, buildSteerContext as fa, DelegateResearchConfig as fb, PursuitVersions as fc, workerSteersDir as fd, SpawnForestNode as ff, RouterSeam as fg, QuestionDecision as fh, createSandboxLineage as fi, InMemoryRunContext as fl, HarnessTranscriptReadOptions as fm, graphDesignerExtraTools as fn, runAgentRounds as fo, RootStreamReceipt as fp, RepairStop as fr, SteerContext as fs, createScope as ft, DeliveredOutput as fu, SandboxControlClient as fv, ReservationStage as fw, createOpenInferenceFileExporter as fx, CodeModeToolset as fy, WatchedSurface as g, JudgeError as gC, McpToolAnnotations as gS, OpenAIChatToolChoice as gT, SharedWorkerIdentity as g_, McpEndpoint as ga, DelegateUiAuditResult as gb, assertPursuitVersions as gc, CompletionPolicy as gd, replaySpawnTree as gf, cliWorktreeExecutor as gg, QuestionLevel as gh, S3PrivateCasStoreOptions as gi, createFileRunContext as gl, retainHarnessTranscript as gm, GraphEdge as gn, SandboxEvidenceRetentionPort as go, SpawnEvent as gp, StructuralRolloutResult as gr, TrajectoryReportOptions as gs, ProvisionedSupervisor as gt, bestDelivered as gu, ProviderNativeCapturePhase as gv, createBudgetPool as gw, padSpanId as gx, runCodeMode as gy, SurfaceReader as h, ConfigError as hC, JsonRpcResponse as hS, OpenAIChatTool as hT, SharedBoxStats as h_, observationFromRegistry as ha, DelegateUiAuditConfig as hb, VersionVerdict as hc, CompletionEvidence as hd, materializeTreeView as hf, cliInPlaceExecutor as hg, QuestionEscalationTarget as hh, S3PrivateCasStore as hi, RunContextLease as hl, resolveHarnessTranscriptCapture as hm, EdgeTraversal as hn, SandboxEvidenceRetentionError as ho, Settled as hp, StructuralRolloutPolicy as hr, TrajectoryReportFn as hs, ProvisionSupervisorRequest as ht, SupervisorFinalizer as hu, ProviderCheckpointCaptureContext as hv, ReserveOptions as hw, loopEventToOtelSpan as hx, describeCodeModeTools as hy, SandboxEvent$1 as i, distillFindings as iC, PeerMailReadout as iS, AgentExecutionBackend as iT, readCodexRolloutSession as i_, panel as ia, SubmitOutput as ib, IsolatedCheckOptions as ic, workerCancellationsDir as id, FileResultBlobStore as if, createDelegateHandler as ig, DownMessageEvent as ih, SandboxRun as ii, resolveWorkerSpawnRetry as il, HarnessTranscriptUnavailable as im, DispatchUnit as in, loopCampaignDispatch as io, ResumedWork as ip, profileRichnessFinding as ir, PanelVerdict as is, DEFAULT_MAX_DEPTH as it, createProgressTracker as iu, ProviderPromptOptions as iv, BudgetPoolRestore as iw, OtelExportConfig as ix, ToolLoopMessageRecord as iy, EVIDENCE_MAX_CHARS as j, NativeContextContinuationHandle as jC, TraceSource as jS, sandboxEventServedBackend as j_, AgenticSurface as ja, ResearchOutputShape as jb, PursuitProjection as jc, ScoreOf as jd, ExecutorExecutionBinding as jf, createActivityLog as jg, analystToolGroupNames as jh, assertModelAllowed as ji, ResolveSupervisorTools as jl, upstreamUnavailableSignal as jm, delegatesWorkerBriefPrompt as jn, ObservationAnalysis as jo, TreeView as jp, EvolutionAuthor as jr, RunPersonified as js, createWorktreeCliExecutor as jt, FileCoordinationLog as ju, DiffOptions as jv, LoopResult as jw, CappedDelegationTrace as jx, settleDetachedCoderTurn as jy, attachWorker as k, createWorkerSlots as kC, SessionTraceBox as kS, mapSandboxEvent as k_, AgenticOptions as ka, FeedbackRating as kb, PursuitNodeTiming as kc, PairwiseVerdict as kd, ExecutorCancellationRequest as kf, TeamProgress as kg, WorkerSpawnContext as kh, profileChatClient as ki, ObserveSupervisorNodeEvent as kl, classifyDriverFailure as km, analyzesFindingsReportPrompt as kn, harvestCorpus as ko, SupervisorOpts as kp, structuralRollout as kr, PersonaContext as ks, WorktreeCliExecutorOptions as kt, CoordinationLog as ku, WorktreeProfileMaterializationReceipt as kv, LoopPlanDescription as kw, sanitizeKnowledgeReadinessReport as kx, coderTaskFromArgs as ky, createVerifierEnvironment as l, Redactor as lC, claimsAuthority as lS, AgentTaskRunResult as lT, ROUTER_CLIENT_HEADER as l_, CreateScopeAnalystOptions as la, DelegateFeedbackArgs as lb, NextPursuitVersionInput as lc, workerSteerAcknowledgementsDir as ld, SpawnForestEvent as lf, CliWorktreeSeam as lg, ManagerReentryState as lh, SandboxLineage as li, SeatSelectionInput as ll, persistHarnessTranscript as lm, DesignerRunGraphEnv as ln, TerminalDecision as lo, RootSegment as lp, CheckRunner as lr, ScopeAnalyst as ls, createFencedSqlRunContext as lt, ReentryTaskInput as lu, providerAsSandboxClient as lv, ReservationHolder as lw, buildLoopOtelSpans as lx, CodeModeTool as ly, SurfaceReadOutcome as m, BackendTransportError as mC, JsonRpcMessage as mS, OpenAIChatResponseFormat as mT, SharedBoxProcess as m_, registryScopeAnalyst as ma, DelegateUiAuditArgs as mb, VersionJudge as mc, CompletionAnalyst as md, loadSpawnForest as mf, SandboxSeam as mg, QuestionEscalationRecord as mh, acquireSandbox as mi, RunContext as ml, RetainedHarnessTranscriptDescriptor as mm, EdgeDeliveryOutcome as mn, SandboxEvidenceReceipt as mo, Scope as mp, StructuralRolloutMessage as mr, TrajectoryReport as ms, ProvisionSupervisorConnection as mt, FinalizerSettled as mu, UnavailablePausePolicy as mv, ReservationWaitRefused as mw, generateSpanId as mx, createCodeModeTools as my, AnalystFinding$1 as n, admitFinding as nC, PeerMailLimits as nS, AgentBackendContext as nT, createCodexRolloutStoreReader as n_, flatWidenGate as na, DelegationTaskQueueOptions as nb, IsolatedCheckBox as nc, workerCancelRequestsFile as nd, SqlAdapter as nf, DelegateHandlerOptions as ng, DownMessageDeliveryAttempt as nh, OpenSandboxRunOptions as ni, WorkerSpawnRetryPolicy as nl, HarnessTranscriptEvidence as nm, DispatchReport as nn, SuperviseDispatchOptions as no, ResultBlobStore as np, assessAuthoredProfile as nr, PanelJudge as ns, parseWorkerToolTraceArtifact as nt, allWorkersStalled as nu, ProviderExecutorOptions as nv, StartRetainedRunOptions as nw, LoopSpanNode as nx, ToolLoopCompaction as ny, computeFindingId$1 as o, failedItems as oC, PeerMailSendInput as oS, AgentRuntimeEvent as oT, decodeHarnessUsage as o_, selectValidWinner as oa, DelegateCodeArgs as ob, runIsolatedCheck as oc, workerInboxFile as od, InMemoryResultBlobStore as of, CliInPlaceSeam as og, EventAcknowledgement as oh, TurnResult as oi, withWorkerSpawnRetry as ol, ReadableEnvironment as om, freeSlots as on, superviseDispatch as oo, RootHandle as op, CheckExecChannel as or, PipelineStage as os, createSupervisor as ot, plateau as ou, WorkspaceRequest as ov, BudgetReconcileFault as ow, OtelExporter as ox, CodeModeOptions as oy, SurfaceReadBox as p, AgentEvalErrorCode as pC, peerMailVerbNames as pS, KnowledgeReadinessDecision as pT, SharedBoxPlacementOptions as p_, createScopeAnalyst as pa, DelegateResearchResult as pb, SettledPursuitVersion as pc, writeWorkerSteer as pd, SpawnForestTree as pf, RouterToolsSeam as pg, QuestionEscalationOutcome as ph, AcquireOptions as pi, InMemoryRunContextOptions as pl, RetainedHarnessTranscriptCapture as pm, AgentGraph as pn, SandboxEvidenceContext as po, Runtime as pp, StructuralRolloutConfig as pr, TrajectoryNode as ps, settledToIteration as pt, FinalizeContext as pu, createTangleSandboxExactProcessProvider as pv, ReservationTicket as pw, createOtelExporter as px, RunCodeModeOptions as py, gitWorkspace as q, RetainedRunEnvironmentAdmission as qC, ContinuationNoteInput as qS, AgentTurnResult$2 as q_, defineStrategy as qa, ResearcherProfileOptions as qb, SuperviseRegistry as qc, WaterfallReport as qd, NodeId as qf, secretEnvOfMcpServer as qg, McpServer as qh, builtinShapes as qi, NoProgressForOptions as ql, BlockedToolReport as qm, ChatTransportTool as qn, Fanout as qo, ReconnectRetainedInteractiveRunOptions as qp, MaterializeLocalMcpOptions as qr, DeclaredCheck as qs, graphRegistry as qt, readWorkerCancellation as qu, harnessSupportsReasoningEffort as qv, RuntimeRunCompleteInput as qw, CoderOutput as qx, parseDetachedSessionRef as qy, CreateSandboxOptions$1 as r, checkVerdictOf as rC, PeerMailOutcome as rS, AgentBackendInput as rT, harnessUsageIsEmpty as r_, loopUntil as ra, SubmitInput as rb, IsolatedCheckBoxEvidence as rc, workerCancellationFile as rd, d1ToSqlAdapter as rf, DelegateResult as rg, DownMessageDeliveryOutcome as rh, OpenSandboxRunPromptOptions as ri, isPreSpawnExecutorFailure as rl, HarnessTranscriptFile as rm, DispatchStopReason as rn, SuperviseOptionsForDispatch as ro, ResumedKeyState as rp, defaultProfileRichnessThresholds as rr, PanelSpec as rs, workerTraceAnalysisStore as rt, anyOf as ru, ProviderLeafOut as rv, BudgetPool as rw, OtelAttribute as rx, ToolLoopCompactionOptions as ry, makeFinding$1 as s, passedItems as sC, PeerMailbox as sS, AgentRuntimeEventSink as sT, DEFAULT_SHARED_BOX_RESOURCES as s_, verify as sa, DelegateCodeConfig as sb, JudgedPursuitVersion as sc, workerInboxFileFromEventDir as sd, InMemorySpawnJournal as sf, CliSeam as sg, LeadMessage as sh, openSandboxRun as si, SeatSegment as sl, captureHarnessTranscript as sm, queueOf as sn, RunAgentRoundsOptions as so, RootMaterialization as sp, CheckOutcome as sr, RenderCorpusToInstructions as ss, FencedSqlRunContext as st, sampleFromSettled as su, createAgentEnvironmentProviderRegistry as sv, LeakedReservation as sw, OtelSpan as sx, CodeModeResult as sy, AgentProfile$2 as t, admitContinuationPolicy as tC, PeerMailKind as tS, AgentAdapter as tT, addHarnessUsage as t_, fanout as ta, DelegationTaskQueue as tb, readDeclaredCheck as tc, supervisorWorkersDir as td, D1StmtLike as tf, DelegateError as tg, DownMessageAuthorizationInput as th, OpenSandboxRunBeforeStartContext as ti, WorkerSpawnRetryHooks as tl, HarnessTranscriptCapture as tm, taskShapeDigest as tn, LoopOptionsForDispatch as to, ResourceSpend as tp, asAuthoredProfile as tr, Panel as ts, captureWorkerTraceEvidence as tt, allOf as tu, ProviderAsSandboxClientOptions as tv, StartRetainedRunInEnvironmentOptions as tw, traceContextToEnv as tx, ToolLoopChat as ty, BoxSurfaceReaderOptions as u, defaultRedactor as uC, createPeerMailbox as uS, AgentTaskSpec as uT, SharedBoxCloseReceipt as u_, RegistryAnalyzeProjection as ua, DelegateFeedbackResult as ub, PursuitVersionChain as uc, workerSteerRequestFile as ud, SpawnForestInDoubtNode as uf, ExecutorConfig as ug, ManagerWake as uh, SandboxLineageHandle as ui, SeatStage as ul, HarnessTranscriptMetadata as um, DesignerToolsEnv as un, defaultSelectWinner as uo, RootSegmentEntry as up, CheckSource as ur, ScopeAnalyzeInput as us, SUBTREE_RESULT_LIMIT as ut, UNPROVEN_CONTINUITY as uu, resolveAgentEnvironmentProvider as uv, ReservationRejection as uw, buildLoopSpanNodes as ux, CodeModeToolContext as uy, fsSurfaceReader as v, PlannerError as vC, McpTransport as vS, RunAgentTaskStreamOptions as vT, sharedBoxRefusal as v_, createMcpEnvironment as va, DelegationError as vb, SupervisePursuitOptions as vc, completionAuthorizes as vd, Agent as vf, createExecutorRegistry as vg, QuestionPolicy as vh, reconnectRetainedRun as vi, withRunContext as vl, DriverAttemptStop as vm, GraphNode as vn, LocalSandboxClientOptions as vo, SpawnOpts as vp, canDisplace as vr, VerifySpec as vs, provisionSupervisor as vt, pickBestDelivered as vu, ProviderWorkspaceCaptureProvenance as vv, AgentRunSpec as vw, toOtelAttributes as vx, FeedbackStore as vy, WorktreeFanoutOptions as w, ValidationError as wC, createEventBus as wS, SandboxUsageLedger as w_, BenchmarkStrategySummary as wa, DelegationProgress as wb, PursuitCostProvenance as wc, Interval as wd, EnvironmentTeardownReceipt as wf, ActivityLog as wg, SpawnRefusal as wh, reconnectRetainedInteractiveRun as wi, CoordinationBinding as wl, DriverLoopRecord as wm, runGraph as wn, inProcessSandboxClient as wo, SteerableRootHandle as wp, modelAuthoredChecks as wr, DefinePersona as ws, profileRegistry as wt, serveCoordinationMcp as wu, ProviderPlacement as wv, LoopEndedPayload as ww, SanitizedKnowledgeReadinessReport as wx, DelegateRunCtx as wy, analystsFromRegistry as x, RetainedRunAdmissionError as xC, BusStats as xS, RuntimeSessionStore as xT, SandboxOutputMarker as x_, BenchmarkConfig as xa, DelegationHistoryEntry as xb, PursuitFork as xc, stopSentinel as xd, Budget as xf, SteerableSandboxArgs as xg, SettledWorker as xh, startRetainedRunInEnvironment as xi, SupervisorSpanOutcome as xl, DriverContinuationRecord as xm, RunGraphTestOptions as xn, InProcessOnPrompt as xo, Spend as xp, defaultExtractCandidate as xr, WidenLineage as xs, bestProfileFor as xt, CoordinationMcpHandle as xu, ProviderWorkspaceEntryMetadata as xv, ExecCtx as xw, RuntimeStreamEventSink as xx, CoderDelegate as xy, harvestSurfaceDiffs as y, RetainedInteractiveAdmissionError as yC, BusEvent as yS, RuntimeCanonicalStreamEvent as yT, sharedWorkerClientName as y_, sanitizeMcpToolSchema as ya, DelegationFeedbackSnapshot as yb, SupervisedPursuitResult as yc, deterministicCompletion as yd, AgentExecutionRef as yf, DEFAULT_SANDBOX_STEERING_MAX_TURNS as yg, QuestionRecord as yh, recoverRetainedRun as yi, SupervisorSpanAttributes as yl, DriverAttemptsExhaustedError as ym, GraphResult as yn, localSandboxClient as yo, SpawnPrior as yp, compareCheckOutcomes as yr, Widen as ys, ProfileRegistryDir as yt, runFinalizer as yu, ProviderWorkspaceCaptureReceipt as yv, DefaultVerdict$1 as yw, RuntimeEventCollector as yx, InMemoryFeedbackStore as yy, UntrackedCopyStats as z, RetainedInteractiveIntentAdmission as zC, AdmittedFinding as zS, AgentEnvironmentProviderRegistry as z_, StrategyArtifacts as za, UiFindingSeverity as zb, ObserverRecordKind as zc, AnytimeStrategySummary as zd, ExecutorToolCall as zf, BridgeModelCredential as zg, ResolvedSpawnResourcePath as zh, streamAgentTurn as zi, SupervisorToolInvocationContext as zl, AnalystRegistry$1 as zm, defaultDelegateBudget as zn, CombinatorShape as zo, WorkerTraceUnavailableReason as zp, strategyTournament as zr, LeaderboardBenchmarkAdapter as zs, createInPlaceCliExecutor as zt, WriteWorkerSteerOptions as zu, CodexExecutionEvidence as zv, MountManifestEntry as zw, composeLoopTraceEmitters as zx, DetachedTurn as zy };
-//# sourceMappingURL=index-t672ISFX.d.ts.map
+export { WORKER_TOOL_TRACE_SCHEMA_VERSION as $, NativeContextContinuationInput as $C, createPushTraceSource as $S, sandboxProgressEvents as $_, captureBeforeDestroy as $a, UiAuditLensFilter as $b, ObserverRecord as $c, renderPairwiseMarkdown as $d, ExecutorResult as $f, readWorkerProgress as $g, canonicalFindingEvent as $h, builtinShapes as $i, SupervisorToolDescriptor as $l, TraceSummary as $m, defaultDelegateBudget as $n, AssertTraceDerivedFindings as $o, WorkerInteractiveSession as $p, strategyTournament as $r, LeaderboardBenchTask as $s, createInPlaceCliExecutor as $t, WorkerSteerAcknowledgement as $u, DiffResult as $v, LoopSandboxPlacement as $w, DELEGATION_TRACE_MAX_BYTES as $x, DelegationExecutor as $y, readWorkerInteractiveBinding as A, Redactor as AC, claimsAuthority as AS, AgentRuntimeEvent as AT, ROUTER_CLIENT_HEADER as A_, BenchmarkStrategySummary as Aa, DelegateFeedbackArgs as Ab, VersionVerdict as Ac, CompletionAnalyst as Ad, loadSpawnForest as Af, CliWorktreeSeam as Ag, ManagerReentryState as Ah, reconnectRetainedInteractiveRun as Ai, RunContextLease as Al, RetainedHarnessTranscriptCapture as Am, GraphEdge as An, StrategyShotResult as Ao, Scope as Ap, StructuralRolloutResult as Ar, TrajectoryReportFn as As, ProvisionedSupervisor as At, SupervisorFinalizer as Au, providerAsSandboxClient as Av, ReservationHolder as Aw, buildLoopOtelSpans as Ax, CodeModeTool as Ay, copyUntrackedIntoClone as B, RetainedInteractiveAdmissionError as BC, BusEvent as BS, OpenAIChatToolChoice as BT, sharedWorkerClientName as B_, loopCampaignDispatch as Ba, DelegationFeedbackSnapshot as Bb, PursuitNodeCost as Bc, Interval as Bd, EnvironmentTeardownReceipt as Bf, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Bg, QuestionRecord as Bh, AgentTurnInput$1 as Bi, CoordinationToolFace as Bl, DriverFailureClass as Bm, PromptHandle as Bn, HarvestCorpusOptions as Bo, SteerableRootHandle as Bp, resolveEntrySymbol as Br, DefinePersonaInput as Bs, recordProfileRun as Bt, serveCoordinationMcp as Bu, ProviderWorkspaceCaptureReceipt as Bv, DefaultVerdict$1 as Bw, RuntimeEventCollector as Bx, InMemoryFeedbackStore as By, AuthoredHarness as C, admitFinding as CC, PeerMailLimits as CS, WorkerEventEntry as CT, createCodexRolloutStoreReader as C_, McpEnvironmentOptions as Ca, DelegationTaskQueueOptions as Cb, NextPursuitVersion as Cc, workerInboxFileFromEventDir as Cd, InMemorySpawnJournal as Cf, DelegateHandlerOptions as Cg, DownMessageDeliveryAttempt as Ch, createS3PrivateCasStore as Ci, SeatSelection as Cl, ReadableEnvironment as Cm, DesignerRunGraphEnv as Cn, RunAgenticOptions as Co, RootMaterialization as Cp, CheckRunner as Cr, RenderCorpusToInstructionsOptions as Cs, RemoteSupervisorAgent as Ct, ReentryContinuity as Cu, ProviderExecutorOptions as Cv, StartRetainedRunOptions as Cw, LoopSpanNode as Cx, ToolLoopCompaction as Cy, WorkerInteractiveBinding as D, failedItems as DC, PeerMailSendInput as DS, AgentBackendInput as DT, decodeHarnessUsage as D_, BenchmarkConfig as Da, DelegateCodeArgs as Db, PursuitVersions as Dc, workerSteerRequestsDir as Dd, SpawnForestMissingTree as Df, CliInPlaceSeam as Dg, EventAcknowledgement as Dh, startRetainedRunInEnvironment as Di, InMemoryRunContext as Dl, HarnessTranscriptMetadata as Dm, AgentGraph as Dn, StrategyCtx as Do, RootSignal as Dp, StructuralRolloutConfig as Dr, SteerContext as Ds, connectRemoteSupervisor as Dt, DeliveredOutput as Du, WorkspaceRequest as Dv, BudgetReconcileFault as Dw, OtelExporter as Dx, CodeModeOptions as Dy, AttachWorkerOptions as E, expandQuestions as EC, PeerMailRefusal as ES, AgentBackendContext as ET, HarnessUsage as E_, BenchmarkCell as Ea, hashIdempotencyInput as Eb, PursuitVersionStop as Ec, workerSteerRequestFile as Ed, SpawnForestInDoubtNode as Ef, validateDelegateArgs as Eg, EscalateQuestion as Eh, startRetainedRun as Ei, SelectSeat as El, persistHarnessTranscript as Em, graphDesignerExtraTools as En, StrategyArtifacts as Eo, RootSegmentEntry as Ep, RepairStop as Er, ScopeWidenGate as Es, RemoteWorkerEvents as Et, composeReentryTask as Eu, ResourceRequest as Ev, BudgetReadout as Ew, OtelExportStats as Ex, ToolLoopToolCall as Ey, closingWorkerNote as F, BackendTransportError as FC, JsonRpcMessage as FS, AgentTaskStatus as FT, SharedBoxProcess as F_, LoopCampaignDispatchOptions as Fa, DelegateUiAuditArgs as Fb, supervisePursuit as Fc, deterministicCompletion as Fd, AgentExecutionRef as Ff, SandboxSeam as Fg, QuestionEscalationRecord as Fh, profileChatClient as Fi, SupervisorSpanOptions as Fl, DriverAttemptStop as Fm, RunGraphTestOptions as Fn, depthStrategy as Fo, SpawnPrior as Fp, defaultExtractCandidate as Fr, WidenDecision as Fs, bestProfileFor as Ft, CoordinationAuthentication as Fu, UnavailablePausePolicy as Fv, ReservationWaitRefused as Fw, generateSpanId as Fx, createCodeModeTools as Fy, WorkspaceCommit as G, ValidationError as GC, createEventBus as GS, RuntimeSessionStore as GT, SandboxUsageLedger as G_, TerminalDecision as Ga, DelegationProgress as Gb, PursuitNodeUsage as Gc, PairwiseVerdict as Gd, ExecutorCancellationRequest as Gf, ActivityLog as Gg, SpawnRefusal as Gh, streamAgentTurn as Gi, ResolveDriveHarness as Gl, DriverRetryPolicy as Gm, delegatesWorkerBriefPrompt as Gn, Observation as Go, SupervisorOpts as Gp, EvolutionAuthor as Gr, PersonaExecutors as Gs, createWorktreeCliExecutor as Gt, CoordinationLog as Gu, ProviderPlacement as Gv, LoopEndedPayload as Gw, SanitizedKnowledgeReadinessReport as Gx, DelegateRunCtx as Gy, GitWorkspaceOptions as H, RetainedRunAdmissionError as HC, BusStats as HS, RunAgentTaskStreamOptions as HT, SandboxOutputMarker as H_, superviseDispatch as Ha, DelegationHistoryEntry as Hb, PursuitNodePlatform as Hc, LeaderboardOptions as Hd, Executor as Hf, SteerableSandboxArgs as Hg, SettledWorker as Hh, CollectedAgentTurn as Hi, DriveHarness as Hl, DriverProgressMark as Hm, RegisteredPrompt as Hn, HarvestFailure as Ho, SubtreeSummary as Hp, selectBestIndex as Hr, Outcome as Hs, patchDelivered as Ht, CoordinationHttpOptions as Hu, ProviderWorkspaceEntryMetadata as Hv, ExecCtx as Hw, RuntimeStreamEventSink as Hx, CoderDelegate as Hy, composeWorkerEvidence as I, ConfigError as IC, JsonRpcResponse as IS, BackendErrorDetail as IT, SharedBoxStats as I_, LoopDispatchOptions as Ia, DelegateUiAuditConfig as Ib, PursuitFork as Ic, sentinelCompletion as Id, AgentSpec as If, cliInPlaceExecutor as Ig, QuestionEscalationTarget as Ih, profileOptimizerModelCall as Ii, SupervisorSpanOutcome as Il, DriverAttemptsExhaustedError as Im, TraversalContinuity as In, refine as Io, SpawnRejection as Ip, defaultStructuralRolloutPolicy as Ir, WidenLineage as Is, loadProfile as It, CoordinationMcpHandle as Iu, ProviderCheckpointCaptureContext as Iv, ReserveOptions as Iw, loopEventToOtelSpan as Ix, describeCodeModeTools as Iy, jjWorkspace as J, DeadlineCheckIn as JC, watchTrace as JS, createSandboxUsageLedger as J_, runAgentRounds as Ja, DelegationStatusArgs as Jb, PursuitRunTotals as Jc, leaderboard as Jd, ExecutorFactory as Jf, ExecutorProgress as Jg, ToolOutcomeEvent as Jh, PrivateCasOffloadReport as Ji, SupervisorAgentDeps as Jl, upstreamUnavailableSignal as Jm, formatPromptHandle as Jn, ObserveInput as Jo, TreeView as Jp, StrategyEvolutionConfig as Jr, ShapeBudget as Js, InteractiveWorkerOptions as Jt, PriorCoordination as Ju, WorktreeCommandResult as Jv, LoopIterationStartedPayload as Jw, createRuntimeStreamEventCollector as Jx, SettleDetachedCoderTurnOptions as Jy, WorkspaceRun as K, DEADLINE_CHECK_IN_MESSAGE as KC, WatchTraceOptions as KS, RuntimeStreamEvent as KT, assertSandboxServedModel as K_, defaultSelectWinner as Ka, DelegationResultPayload as Kb, PursuitProjection as Kc, ProfileKeyOf as Kd, ExecutorContext as Kf, ActivityNote as Kg, SpawnRefusalCause as Kh, PrivateCasArtifactPort as Ki, ResolveSupervisorTools as Kl, classifyDriverFailure as Km, dumbContinuationFailPrompt as Kn, ObservationAnalysis as Ko, TokenUsageProvenance as Kp, EvolutionReport as Kr, RunPersonified as Ks, InteractiveWorkerEnvironment as Kt, CoordinationOwnerId as Ku, InPlaceHarnessResult as Kv, LoopIterationDispatchPayload as Kw, SanitizedKnowledgeRequirement as Kx, DetachedSessionDelegateOptions as Ky, settledWorkerOut as L, JudgeError as LC, McpToolAnnotations as LS, KnowledgeReadinessDecision as LT, SharedWorkerIdentity as L_, LoopOptionsForDispatch as La, DelegateUiAuditResult as Lb, RUN_FORK_CORRELATION_KEYS as Lc, stopSentinel as Ld, Budget as Lf, cliWorktreeExecutor as Lg, QuestionLevel as Lh, assertModelAllowed as Li, SupervisorSpanRecorder as Ll, DriverBudgetReadout as Lm, defaultEdgeTraversalCap as Ln, runAgentic as Lo, Spend as Lp, filterAuthoredAsserts as Lr, WidenSpec as Ls, pickBestProfile as Lt, CoordinationPublicAddress as Lu, ProviderNativeCapturePhase as Lv, createBudgetPool as Lw, padSpanId as Lx, runCodeMode as Ly, NOTE_MAX_CHARS as M, resolveRedactor as MC, isPeerMailEnvelope as MS, AgentTaskContext as MT, SharedBoxHandle as M_, Environment as Ma, DelegateResearchArgs as Mb, SupervisePursuitError as Mc, CompletionPolicy as Md, replaySpawnTree as Mf, ProviderSeam as Mg, Question as Mh, startRetainedInteractiveRun as Mi, createInMemoryRunContext as Ml, resolveHarnessTranscriptCapture as Mm, GraphNode as Mn, adaptiveRefine as Mo, SpawnEvent as Mp, canDisplace as Mr, Verify as Ms, provisionSupervisor as Mt, collectDelivered as Mu, CreateTangleSandboxExactProcessProviderOptions as Mv, ReservationShortfall as Mw, buildRuntimeEventOtelSpans as Mx, CodeModeToolsOptions as My, VERIFY_TAIL_CHARS as N, AgentEvalError$1 as NC, peerMailTools as NS, AgentTaskRunResult as NT, SharedBoxPlacement as N_, printBenchmarkReport as Na, DelegateResearchConfig as Nb, SupervisePursuitOptions as Nc, CompletionVerdict as Nd, contentAddress as Nf, RouterSeam as Ng, QuestionDecision as Nh, ResolveSandboxClientOptions as Ni, withRunContext as Nl, retainHarnessTranscript as Nm, GraphResult as Nn, breadthStrategy as No, SpawnJournal as Np, compareCheckOutcomes as Nr, VerifySpec as Ns, ProfileRegistryDir as Nt, pickBestDelivered as Nu, SandboxControlClient as Nv, ReservationStage as Nw, createOpenInferenceFileExporter as Nx, CodeModeToolset as Ny, WorkerInteractiveProviderSource as O, passedItems as OC, PeerMailbox as OS, AgentExecutionBackend as OT, DEFAULT_SHARED_BOX_RESOURCES as O_, BenchmarkLift as Oa, DelegateCodeConfig as Ob, SettledPursuitVersion as Oc, workerSteersDir as Od, SpawnForestNode as Of, CliSeam as Og, LeadMessage as Oh, ClaimRetainedInteractiveControlOptions as Oi, InMemoryRunContextOptions as Ol, HarnessTranscriptReadLimits as Om, EdgeDeliveryOutcome as On, StrategyMessage as Oo, RootStreamReceipt as Op, StructuralRolloutMessage as Or, TrajectoryNode as Os, ProvisionSupervisorConnection as Ot, FinalizeContext as Ou, createAgentEnvironmentProviderRegistry as Ov, LeakedReservation as Ow, OtelSpan as Ox, CodeModeResult as Oy, WorkerEvidenceInput as P, AgentEvalErrorCode as PC, peerMailVerbNames as PS, AgentTaskSpec as PT, SharedBoxPlacementOptions as P_, runBenchmark as Pa, DelegateResearchResult as Pb, SupervisedPursuitResult as Pc, completionAuthorizes as Pd, Agent as Pf, RouterToolsSeam as Pg, QuestionEscalationOutcome as Ph, resolveSandboxClient as Pi, SupervisorSpanAttributes as Pl, DriverAttemptRecord as Pm, RunGraphOptions as Pn, defineStrategy as Po, SpawnOpts as Pp, composeCheckSources as Pr, Widen as Ps, ProfileRunRecord as Pt, runFinalizer as Pu, createTangleSandboxExactProcessProvider as Pv, ReservationTicket as Pw, createOtelExporter as Px, RunCodeModeOptions as Py, analyzeTrace as Q, NativeContextContinuationHandle as QC, TraceSource as QS, sandboxEventServedBackend as Q_, SandboxEvidenceRetentionPort as Qa, ResearchOutputShape as Qb, ObserverJournal as Qc, renderLeaderboardSvg as Qd, ExecutorRegistry as Qf, createActivityLog as Qg, analystToolGroupNames as Qh, trajectoryReport as Qi, SupervisorProfile as Ql, TraceRootArtifact as Qm, DelegateOptions as Qn, renderReport as Qo, WidenGate as Qp, runStrategyEvolution as Qr, LeaderboardBenchScore as Qs, InPlaceCliExecutorOptions as Qt, WorkerCancellation as Qu, DiffOptions as Qv, LoopResult as Qw, CappedDelegationTrace as Qx, settleDetachedCoderTurn as Qy, CopyOptions as R, NotFoundError as RC, McpToolDescriptor$1 as RS, OpenAIChatResponseFormat as RT, sharedBoxPlacement as R_, SuperviseDispatchOptions as Ra, DelegateUiAuditRoute as Rb, PursuitObserverDelivery as Rc, AxisScoresOf as Rd, BudgetOverspend as Rf, createExecutor as Rg, QuestionOption as Rh, assertProfileModelsAllowed as Ri, createSupervisorSpanRecorder as Rl, DriverContinuationRecord as Rm, runGraph as Rn, sample as Ro, SpendChannel as Rp, modelAuthoredChecks as Rr, WinnerStrategy as Rs, profileRegistry as Rt, CoordinationReadAccess as Ru, ProviderWorkspaceAttemptProvenance as Rv, spendFromUsageEvents as Rw, padTraceId as Rx, FeedbackEvent as Ry, failuresAnalyst as S, admitContinuationPolicy as SC, PeerMailKind as SS, WorkerEventCursor as ST, addHarnessUsage as S_, McpEndpoint as Sa, DelegationTaskQueue as Sb, JudgedPursuitVersion as Sc, workerInboxFile as Sd, InMemoryResultBlobStore as Sf, DelegateError as Sg, DownMessageAuthorizationInput as Sh, S3PrivateCasStoreOptions as Si, SeatSegment as Sl, HarnessTranscriptUnavailableReason as Sm, rollingDispatch as Sn, CorpusReadbackOptions as So, RootHandle as Sp, CheckRunContext as Sr, RenderCorpusToInstructions as Ss, settledToIteration as St, sampleFromSettled as Su, ProviderAsSandboxClientOptions as Sv, StartRetainedRunInEnvironmentOptions as Sw, traceContextToEnv as Sx, ToolLoopChat as Sy, worktreeFanout as T, distillFindings as TC, PeerMailReadout as TS, AgentAdapter as TT, readCodexRolloutSession as T_, sanitizeMcpToolSchema as Ta, SubmitOutput as Tb, PursuitVersionChain as Tc, workerSteerAcknowledgementsDir as Td, SpawnForestEvent as Tf, createDelegateHandler as Tg, DownMessageEvent as Th, recoverRetainedRun as Ti, SeatStage as Tl, harnessTranscriptArtifact as Tm, GraphDesignerExtraTools as Tn, Strategy as To, RootSegment as Tp, CheckSourceCtx as Tr, ScopeAnalyzeInput as Ts, RemoteSupervisorTree as Tt, UNPROVEN_CONTINUITY as Tu, ProviderPromptOptions as Tv, BudgetPoolRestore as Tw, OtelExportConfig as Tx, ToolLoopMessageRecord as Ty, Shell as U, RetainedRunDispatchBindingError as UC, EventBus as US, RuntimeCanonicalStreamEvent as UT, SandboxServedBackend as U_, RunAgentRoundsOptions as Ua, DelegationHistoryResult as Ub, PursuitNodeProjection as Uc, LeaderboardRow as Ud, ExecutorAccounting as Uf, SteerableSandboxSession as Ug, SpawnPreflight as Uh, StreamAgentTurnOptions as Ui, DriveHarnessOwnerContext as Ul, DriverReentry as Um, analyzesFindingsReportPrompt as Un, HarvestReport as Uo, SupervisedResult as Up, structuralRollout as Ur, Persona as Us, WorktreeCliExecutorOptions as Ut, CoordinationRejectReason as Uu, ProviderWorkspaceRetentionContext as Uv, Iteration as Uw, RuntimeStreamEventSummary as Ux, CoderReview as Uy, withUntrackedArtifacts as V, RetainedInteractiveBindingError as VC, BusRecord as VS, RunAgentTaskOptions as VT, SandboxLeafOut as V_, loopDispatch as Va, DelegationHistoryArgs as Vb, PursuitNodePlacement as Vc, Leaderboard as Vd, ExecutionBindingReceipt as Vf, SandboxSteeringOptions as Vg, QuestionUrgency as Vh, AgentTurnUsage as Vi, CoordinationVerbs as Vl, DriverLoopRecord as Vm, PromptRegistry as Vn, HarvestError as Vo, SubtreeResult as Vp, sandboxCheckRunner as Vr, LoopShape as Vs, PatchDeliverableOptions as Vt, CoordinationHttpAudit as Vu, ProviderWorkspaceCaptureResult as Vv, Driver as Vw, RuntimeStreamEventCollector as Vx, eventToSnapshot as Vy, Workspace as W, RuntimeRunStateError as WC, PublishOptions as WS, RuntimeSession as WT, SandboxToolPartState as W_, TERMINAL_DECISIONS as Wa, DelegationProfile as Wb, PursuitNodeTiming as Wc, PairwiseOptions as Wd, ExecutorCancellation as Wf, createSteerableSandboxSession as Wg, SpawnPreflightContext as Wh, collectAgentTurn as Wi, ObserveSupervisorNodeEvent as Wl, DriverRepromptRefusal as Wm, createPromptRegistry as Wn, harvestCorpus as Wo, Supervisor as Wp, visibleCheckScore as Wr, PersonaContext as Ws, WorktreePatchArtifact as Wt, CoordinationDeliveryEvidence as Wu, ProviderWorkspaceRetentionPort as Wv, LoopDecisionPayload as Ww, RuntimeTelemetryOptions as Wx, CoderReviewer as Wy, runInWorkspace as X, createWorkerSlots as XC, SessionTraceBox as XS, mapSandboxEvent as X_, SandboxEvidenceReceipt as Xa, FeedbackRating as Xb, projectPursuit as Xc, renderLeaderboardHtml as Xd, ExecutorNodeContext as Xf, TeamProgress as Xg, WorkerSpawnContext as Xh, createPrivateCasArtifactPort as Xi, SupervisorNodeContext as Xl, TRACE_ROOT_SCHEMA as Xm, naiveContinuationPrompt as Xn, defaultAnalystInstruction as Xo, UnknownMaterializationReason as Xp, TournamentCell as Xr, ShapeRegistry as Xs, workerFromInteractiveProvider as Xt, RunCancellation as Xu, WorktreeProfileMaterializationReceipt as Xv, LoopPlanDescription as Xw, sanitizeKnowledgeReadinessReport as Xx, coderTaskFromArgs as Xy, localShell as Y, WorkerSlots as YC, SessionMessageLike as YS, extractLlmCallEvent as Y_, SandboxEvidenceContext as Ya, DelegationStatusResult as Yb, PursuitStatus as Yc, pairwiseSignificance as Yd, ExecutorMaterialization as Yf, ScopeProgressInput as Yg, WorkerResumeContext as Yh, PrivateCasOptions as Yi, SupervisorAgentTestDeps as Yl, RetainedPendingCause as Ym, kernelPromptRegistry as Yn, ObserveOptions as Yo, UnconfirmedTeardown as Yp, StrategyTournament as Yr, ShapeContext as Ys, InteractiveWorkerResult as Yt, RunCancelRequest as Yu, WorktreeHarnessResult as Yv, LoopLineageOptions as Yw, sanitizeAgentRuntimeEvent as Yx, UiAuditorDelegate as Yy, TrajectoryAnalysis as Z, NativeContextContinuationExecution as ZC, ToolStepInput as ZS, mapSandboxToolEvent as Z_, SandboxEvidenceRetentionError as Za, FeedbackRefersTo as Zb, FileObserverJournal as Zc, renderLeaderboardMarkdown as Zd, ExecutorProgressEvent as Zf, WorkerProgress as Zg, WorkerWatchOptions as Zh, equalKOnCost as Zi, SupervisorNodeContextSeed as Zl, TRACE_SUMMARY_SCHEMA as Zm, promptHandle as Zn, observe as Zo, UsageEvent as Zp, TournamentRow as Zr, DefinedLeaderboard as Zs, WorkerInteractiveAdmission as Zt, WorkerCancelRequest as Zu, CreateWorktreeOptions as Zv, LoopPlanPayload as Zw, sanitizeRuntimeStreamEvent as Zx, detachedSessionDelegate as Zy, boxSurfaceReader as _, ContinuationPanelResult as _C, AUTHORITY_MARKERS as _S, RuntimeRunOptions as _T, CodexRolloutSession as __, assertTraceDerivedFindings as _a, DelegationRecord as _b, IsolatedCheckBox as _c, supervisorWorkersDir as _d, D1StmtLike as _f, createMcpServer as _g, CoordinationEvent as _h, SessionCapableBox as _i, WorkerSpawnRetryPolicy as _l, HarnessTranscriptArtifact as _m, DispatchStopReason as _n, AgenticRunResult as _o, ResourceSpend as _p, defaultProfileRichnessThresholds as _r, PanelJudge as _s, searchPresets as _t, allWorkersStalled as _u, CreateAgentEnvironmentInput$1 as _v, RetainedRunIntentAdmission as _w, researcherProfile as _x, runLocalHarness as _y, SandboxInstance$1 as a, mapExecutorResult as aC, capDelegationTrace as aS, LoopWinner as aT, BridgeHarnessStore as a_, InMemoryCorpus as aa, DetachedSessionRefParts as ab, LeaderboardScore as ac, legacySupervisorRunsRoot as ad, bestSoFar as af, ResolveSpawnResourcePathsResult as ag, AnalystLensOutput as ah, strategyAuthorSystemPrompt as ai, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as al, WorkerTraceSeamCarrier as am, graphDigest as an, InProcessSandboxClientOptions as ao, MaterializedExecutionIdentity as ap, ChatSessionStore as ar, EqualKOnCost as as, createRootHandle as at, DEFAULT_DEADLINE_WARNING_MS as au, AgentEnvironmentProviderRef as av, RetainedInteractiveEnvironmentAdmission as aw, UiFindingScreenshot as ax, removeWorktree as ay, AnalystAuthoring as b, PanelFinding as bC, PeerMailEnvelope as bS, RuntimeRunStatus as bT, CodexRolloutTurn as b_, registryScopeAnalyst as ba, DelegationResumeTick as bb, IsolatedCheckResult as bc, workerCancellationsDir as bd, FileResultBlobStore as bf, DELEGATE_TOOL_NAME as bg, CoordinationToolsOptions as bh, acquireSandbox as bi, retryPreSpawnRefusals as bl, HarnessTranscriptFile as bm, freeSlots as bn, AgenticTool as bo, ResumedWork as bp, CheckExecChannel as br, Pipeline as bs, ScopeArgs as bt, noProgressFor as bu, ForkRequest as bv, RetainedRunStartMaterial as bw, mergeTraceEnv as bx, ToolSpec as by, VerifierEnvironmentOptions as c, CheckRead as cC, DelegationPersistenceError as cS, OutputAdapter as cT, KeyProvider as c_, flatWidenGate as ca, DriveTurnCapableBox as cb, DeclaredCheck as cc, readWorkerCancelRequests as cd, WaterfallCollector as cf, SpawnResourceBytes as cg, AnalyzeOnSettleRoute as ch, OpenSandboxRunOptions as ci, SuperviseRegistry as cl, workerTraceHeaders as cm, graphRunsFor as cn, LocalMcpMaterialization as co, NodeExecutionIdentity as cp, ChatWorkerSeamOptions as cr, Fanout as cs, SqlRunContextOptions as ct, NoProgressForOptions as cu, AgentEnvironmentStatus as cv, RetainedRunAdmission as cw, KnowledgeItem as cx, CodexTokenUsage as cy, HarvestSurfaceDiffsOptions as d, ContinuationAppend as dC, FileDelegationStore as dS, SelectionReceipt as dT, mcpSecretEnvMetadataKey as d_, pipeline as da, createDetachedTurnResumeDriver as db, assertDeclaredCheck as dc, readWorkerSteerRequests as dd, createWaterfallCollector as df, environmentReader as dg, AuthorizeDownMessage as dh, SandboxRunAbortError as di, supervise as dl, RecoverRetainedInteractiveRunOptions as dm, lookupGraph as dn, McpToolDescriptor as do, NodeStatus as dp, createChatSessionStore as dr, FanoutWinnerSelector as ds, SEARCH_SPEC_CORRELATION_KEY as dt, ProgressTracker as du, AgentSession as dv, RetainedRunCancellation as dw, ResearchOutput as dx, LocalHarness as dy, decodeToolPart as eC, DELEGATION_TRACE_MAX_SPANS as eS, LoopStartedPayload as eT, AuthorityInboxMessage as e_, createShapeRegistry as ea, FleetHandle as eb, LeaderboardBenchmarkAdapter as ec, WorkerSteerRequest as ed, AnytimeReport as ef, createCoordinationTools as eg, ANALYST_DEFINITION_BOUNDS as eh, AuthorStrategyOptions as ei, ObserverRecordKind as el, WorkerInteractiveUnavailableReason as em, GraphRegistryDir as en, LocalSandboxClientOptions as eo, ExecutorTeardownWarning as ep, delegate as er, CombinatorShape as es, WorkerToolTraceArtifact as et, SupervisorToolInvocationContext as eu, sumSandboxUsage as ev, ReconnectRetainedRunOptions as ew, UiAuditorDelegationOutput as ex, GitRunner as ey, SurfaceDiff as f, ContinuationContext as fC, FileDelegationStoreOptions as fS, ValidationCtx as fT, resolveMcpServerLaunch as f_, selectValidWinner as fa, detachedTurnEvents as fb, checkProgramDigest as fc, runCancelRequestFile as fd, SqlRunLease as ff, hostDirectoryReader as fg, AuthorizedDownMessage as fh, TurnResult as fi, superviseWithTestBrain as fl, RetainedInteractiveAdmissionHook as fm, pickBestGraph as fn, StdioMcpConnection as fo, ProfileMaterializationReceipt as fp, AuthoredProfile as fr, FlatWidenGate as fs, SearchSpec as ft, ProgressTrackerOptions as fu, AgentSessionRef as fv, RetainedRunDispatchedAdmission as fw, ResearchSource as fx, LocalHarnessResult as fy, WatchedSurface as g, ContinuationPanelInput as gC, coderTaskToPrompt as gS, RuntimeRunHandle as gT, CodexRolloutIdentity as g_, RegistryAnalyzeProjection as ga, DelegationArgs as gb, readDeclaredCheck as gc, supervisorRunsRoot as gd, D1DatabaseLike as gf, createInProcessTransport as gg, ContinuityMode as gh, SandboxLineageHandle as gi, WorkerSpawnRetryHooks as gl, StartRetainedInteractiveRunOptions as gm, DispatchReport as gn, AgenticOptions as go, ResourceLimit as gp, assessAuthoredProfile as gr, Panel as gs, compileSearchSpec as gt, allOf as gu, CheckpointRequest as gv, RetainedRunHandle as gw, multiHarnessResearcherFanout as gx, parseCodexTokenUsage as gy, SurfaceReader as h, ContinuationPanel as hC, CoderTask as hS, RuntimeRunCost as hT, CodexForkBoundary as h_, CreateScopeAnalystOptions as ha, runDetachedTurn as hb, declaredCheckJudge as hc, supervisorRunDir as hd, openSqlRunStore as hf, McpServerOptions as hg, ContinuationInstruction as hh, SandboxLineage as hi, WorkerSpawnRetryAttempt as hl, RetainedInteractiveStartMaterial as hm, taskShapeDigest as hn, materializeLocalMcp as ho, RecursiveReservationPolicy as hp, asAuthoredProfile as hr, LoopUntilState as hs, assertSearchSpec as ht, StopRule as hu, CheckpointRef as hv, RetainedRunEventOptions as hw, createResearcherValidator as hx, localHarnessExecutable as hy, SandboxEvent$1 as i, gateOnDeliverable as iC, buildDelegationTraceSpans as iS, LoopTraceEvent as iT, createInbox as i_, FileCorpus as ia, createSiblingSandboxExecutor as ib, LeaderboardScenario as ic, legacySupervisorRunDir as id, areaUnderCurve as if, questionEscalationTargets as ig, AnalystKind as ih, strategyAuthorContract as ii, AuthorizedSpawnContext as il, WorkerTraceResolver as im, digestOfGraph as in, InProcessPromptCtx as io, HeldEnvironment as ip, ChatCompletionsTransport as ir, EqualKArm as is, DEFAULT_MAX_DEPTH as it, supervisorAgentWithTestBrain as iu, AgentEnvironmentProvider$1 as iv, RetainedInteractiveAdmission as iw, UiFinding as ix, createWorktree as iy, EVIDENCE_MAX_CHARS as j, defaultRedactor as jC, createPeerMailbox as jS, AgentRuntimeEventSink as jT, SharedBoxCloseReceipt as j_, BenchmarkTaskRow as ja, DelegateFeedbackResult as jb, assertPursuitVersions as jc, CompletionEvidence as jd, materializeTreeView as jf, ExecutorConfig as jg, ManagerWake as jh, recoverRetainedInteractiveRun as ji, createFileRunContext as jl, RetainedHarnessTranscriptDescriptor as jm, GraphEdgeCapError as jn, SurfaceScore as jo, Settled as jp, VisibleCheck as jr, TrajectoryReportOptions as js, SupervisorCleanupReceipt as jt, bestDelivered as ju, resolveAgentEnvironmentProvider as jv, ReservationRejection as jw, buildLoopSpanNodes as jx, CodeModeToolContext as jy, attachWorker as k, verdictFromJudgeScore as kC, PeerMailboxOptions as kS, AgentKnowledgeProvider as kT, DEFAULT_SHARED_BOX_WORKERS as k_, BenchmarkReport as ka, DelegateCodeResult as kb, VersionJudge as kc, writeWorkerSteer as kd, SpawnForestTree as kf, CliWorktreeBridgeSeam as kg, MakeWorkerAgent as kh, claimRetainedInteractiveControl as ki, RunContext as kl, HarnessTranscriptReadOptions as km, EdgeTraversal as kn, StrategyResult as ko, Runtime as kp, StructuralRolloutPolicy as kr, TrajectoryReport as ks, ProvisionSupervisorRequest as kt, FinalizerSettled as ku, providerAsExecutor as kv, ReservationFloor as kw, RuntimeEventOtelOptions as kx, CodeModeStore as ky, createVerifierEnvironment as l, CheckUnavailableError as lC, DelegationStateCorruptError as lS, RunProvenance as lT, ResolvedMcpServerLaunch as l_, loopUntil as la, DriveTurnTick as lb, DeclaredCheckPlacement as lc, readWorkerCancellation as ld, WaterfallReport as lf, SpawnResourceRead as lg, AuthoredAnalystDefinition as lh, OpenSandboxRunPromptOptions as li, SuperviseRegistryTable as ll, workerTraceSeamKey as lm, listGraphRuns as ln, MaterializeLocalMcpOptions as lo, NodeId as lp, chatTransportExecutor as lr, FanoutOptions as ls, createFencedSqlRunContext as lt, PlateauOptions as lu, AgentEnvironmentSummary as lv, RetainedRunAdmissionHook as lw, KnowledgeUpdate as lx, DEFAULT_LOCAL_HARNESS as ly, SurfaceReadOutcome as m, ContinuationNoteInput as mC, CoderOutput as mS, RuntimeRunCompleteInput as mT, secretEnvOfMcpServer as m_, widen as ma, parseDetachedSessionRef as mb, declaredCheckDigest as mc, safeWorkerFile as md, SqlRunStoreOptions as mf, McpServer as mg, BlockedToolReport as mh, BranchCapableBox as mi, ResolvedWorkerSpawnRetry as ml, RetainedInteractiveRunHandle as mm, storedGraphDigests as mn, connectStdioMcp as mo, ProviderModelExecutionEvidence as mp, ProfileRichnessThresholds as mr, LoopUntilSpec as ms, SearchSpecOwnedOption as mt, StopDecision as mu, AgentTurnResult$2 as mv, RetainedRunEnvironmentAdmission as mw, ResearcherProfileOptions as mx, harnessSupportsReasoningEffort as my, AnalystFinding$1 as n, DeliverableSpec as nC, DelegationTraceCollector as nS, LoopTokenUsage as nT, InboxMessage as n_, definePersona as na, SiblingSandboxExecutorOptions as nb, LeaderboardIterationInfo as nc, cancelRun as nd, AnytimeTaskCurve as nf, normalizeAnalyzeOnSettle as ng, AnalystDefinitionIssue as nh, assertStrategyContract as ni, verifyObserverRecords as nl, WorkerTraceUnavailableReason as nm, GraphSelection as nn, inlineSandboxClient as no, FleetYield as np, driverAgent as nr, CorpusFilter as ns, parseWorkerToolTraceArtifact as nt, resolveSupervisorProfile as nu, AgentEnvironmentCapabilities$1 as nv, RecoverRetainedRunOptions as nw, UI_FINDING_SEVERITIES as nx, WorktreeHandle as ny, computeFindingId$1 as o, AdmittedFinding as oC, composeLoopTraceEmitters as oS, MountManifestEntry as oT, BridgeModelCredential as o_, renderCorpusToInstructions as oa, DetachedTurn as ob, LeaderboardSpec as oc, readRunCancelRequest as od, plateauLength as of, ResolvedSpawnResourcePath as og, AnalystRegistry$1 as oh, Deliverable as oi, DeliverableResolutionInput as ol, readWorkerTraceContext as om, graphFromStored as on, inProcessSandboxClient as oo, MaterializedModelIdentity as op, ChatTransportExecutorOptions as or, EqualKOnCostOptions as os, createSupervisor as ot, ManagerWakePolicy as ou, AgentEnvironmentProviderRegistry as ov, RetainedInteractiveIntentAdmission as ow, UiFindingSeverity as ox, CodexExecutionEvidence as oy, SurfaceReadBox as p, ContinuationEntry as pC, InMemoryDelegationStore as pS, Validator as pT, resolveSecretEnv as p_, verify as pa, formatDetachedSessionRef as pb, declaredCheckDeliverable as pc, runCancellationFile as pd, SqlRunOwnershipError as pf, resolveSpawnResourcePaths as pg, AwaitWakeInput as ph, openSandboxRun as pi, workerFromBackend as pl, RetainedInteractiveEnvironmentInput as pm, recordGraphRun as pn, StdioMcpServerSpec as po, ProviderModelAttemptEvidence as pp, ProfileRichness as pr, LoopUntil as ps, SearchSpecInputs as pt, ProgressView as pu, AgentSessionStatus$1 as pv, RetainedRunEffect as pw, ResearchTask as px, RunLocalHarnessOptions as py, gitWorkspace as q, DEFAULT_CHECK_IN_IDLE_MS as qC, defaultToolDetectors as qS, createSandboxToolPartState as q_, isTerminalDecision as qa, DelegationStatus as qb, PursuitRunProjection as qc, ScoreOf as qd, ExecutorExecutionBinding as qf, DEFAULT_STALL_AFTER_MS as qg, SuperviseProfileEntry as qh, PrivateCasDurableStore as qi, ResolvedSupervisorProfile as ql, summarizeDriverAttempts as qm, dumbContinuationPassPrompt as qn, ObservationError as qo, TraceRootReceipt as qp, EvolutionStrategy as qr, RunPersonifiedOptions as qs, InteractiveWorkerKeyInput as qt, FileCoordinationLog as qu, WorktreeCheckRunner as qv, LoopIterationEndedPayload as qw, createRuntimeEventCollector as qx, DetachedWinnerSelection as qy, CreateSandboxOptions$1 as r, ExecutorResultMapping as rC, DelegationTraceSpan as rS, LoopTraceEmitter as rT, PeerInboxMessage as r_, runPersonified as ra, createFleetWorkspaceExecutor as rb, LeaderboardRunContext as rc, cancelWorker as rd, anytimeReport as rf, parseAuthoredAnalystDefinition as rg, AnalystFindingEvent as rh, authorStrategy as ri, AuthorizedSpawn as rl, WorkspaceCheckpointMarker as rm, StoredGraph as rn, InProcessOnPrompt as ro, Handle as rp, finalizeBestDelivered as rr, CorpusRecord as rs, workerTraceAnalysisStore as rt, supervisorAgent as ru, AgentEnvironmentEvent$1 as rv, RecoverRetainedRunResult as rw, UI_LENSES as rx, captureWorktreeDiff as ry, makeFinding$1 as s, CONTINUATION_FACTS as sC, createDelegationTraceCollector as sS, MountRecorder as sT, BridgeSeam as s_, fanout as sa, DetachedTurnResumeDriverOptions as sb, defineLeaderboard as sc, readRunCancellation as sd, renderAnytimeTable as sf, SPAWN_RESOURCE_PATH_MAX_BYTES as sg, AnalystToolGroupName as sh, OpenSandboxRunBeforeStartContext as si, SuperviseOptions as sl, workerTraceEnv as sm, graphRegistry as sn, HttpMcpServerSpec as so, NoWinnerError as sp, ChatTransportTool as sr, EqualKVerdict as ss, FencedSqlRunContext as st, AllWorkersStalledOptions as su, AgentEnvironmentQuery as sv, RetainedInteractiveStartedAdmission as sw, UiLens as sx, CodexExecutionPolicy as sy, AgentProfile$2 as t, sandboxSessionTraceSource as tC, DelegationTraceCaps as tS, LoopTeardownFailedPayload as tT, Inbox as t_, registerShape as ta, FleetWorkspaceExecutorOptions as tb, LeaderboardFlagSpec as tc, WriteWorkerSteerOptions as td, AnytimeStrategySummary as tf, downMessageRefusalReasons as tg, AnalystAssignmentRecord as th, AuthoredStrategy as ti, observerRecordDigest as tl, WorkerTraceEvidence as tm, GraphRunRecord as tn, localSandboxClient as to, ExecutorToolCall as tp, DriverAgentOptions as tr, Corpus as ts, captureWorkerTraceEvidence as tt, assertCoordinationBinding as tu, AgentEnvironment$1 as tv, RecoverRetainedRunIntentOptions as tw, delegationProfiles as tx, RemoveWorktreeOptions as ty, BoxSurfaceReaderOptions as u, CheckVerdict as uC, DelegationStore as uS, SandboxClient as uT, envKeyProvider as u_, panel as ua, RunDetachedTurnOptions as ub, DeclaredCheckStateCapture as uc, readWorkerSteerAcknowledgement as ud, WaterfallSpan as uf, SpawnResourceReader as ug, AuthoredAnalystLimits as uh, SandboxRun as ui, SuperviseTestOptions as ul, ReconnectRetainedInteractiveRunOptions as um, loadGraph as un, McpSpawnFault as uo, NodeSnapshot as up, chatWorkerSeam as ur, FanoutSynthesis as us, CompiledSearchSpec as ut, ProgressSample as uu, AgentProfileRef as uv, RetainedRunCancelOptions as uw, MultiHarnessResearcherFanoutOptions as ux, LOCAL_HARNESSES as uy, fsSurfaceReader as v, ContinuationPolicy as vC, DEFAULT_PEER_MAIL_LIMITS as vS, RuntimeRunPersistenceAdapter as vT, CodexRolloutStoreReader as v_, buildSteerContext as va, DelegationResumeContext as vb, IsolatedCheckBoxEvidence as vc, workerCancelRequestsFile as vd, SqlAdapter as vf, DELEGATE_DESCRIPTION as vg, CoordinationStats as vh, createSandboxLineage as vi, isPreSpawnExecutorFailure as vl, HarnessTranscriptCapture as vm, DispatchUnit as vn, AgenticSurface as vo, ResultBlobStore as vp, profileRichnessFinding as vr, PanelSpec as vs, searchSpecDigest as vt, anyOf as vu, ExecRequest as vv, RetainedRunReplayPoint as vw, TraceContext as vx, RouterResponseReceipt as vy, WorktreeFanoutOptions as w, checkVerdictOf as wC, PeerMailOutcome as wS, WorkerEventPage as wT, harnessUsageIsEmpty as w_, createMcpEnvironment as wa, SubmitInput as wb, NextPursuitVersionInput as wc, workerSteerAcknowledgementFile as wd, SpawnForest as wf, DelegateResult as wg, DownMessageDeliveryOutcome as wh, reconnectRetainedRun as wi, SeatSelectionInput as wl, captureHarnessTranscript as wm, DesignerToolsEnv as wn, ShotSpec as wo, RootProviderModelEvidence as wp, CheckSource as wr, ScopeAnalyst as ws, RemoteSupervisorReader as wt, ReentryTaskInput as wu, ProviderLeafOut as wv, BudgetPool as ww, OtelAttribute as wx, ToolLoopCompactionOptions as wy, analystsFromRegistry as x, VerdictSummary as xC, PeerMailEvent as xS, startRuntimeRun as xT, CodexStoreDelta as x_, observationFromRegistry as xa, DelegationRunContext as xb, runIsolatedCheck as xc, workerControlLogFile as xd, FileSpawnJournal as xf, DelegateArgs as xg, DefinedAnalystRecord as xh, S3PrivateCasStore as xi, withWorkerSpawnRetry as xl, HarnessTranscriptUnavailable as xm, queueOf as xn, ArtifactHandle as xo, RetainedExecutionState as xp, CheckOutcome as xr, PipelineStage as xs, createScope as xt, plateau as xu, PlacementInfo as xv, RetainedRunTurnInput as xw, readTraceContextFromEnv as xx, ToolLoopCallContext as xy, harvestSurfaceDiffs as y, ContinuationProfile as yC, PEER_MAIL_WIRE_KEY as yS, RuntimeRunRow as yT, CodexRolloutStoreRef as y_, createScopeAnalyst as ya, DelegationResumeDriver as yb, IsolatedCheckOptions as yc, workerCancellationFile as yd, d1ToSqlAdapter as yf, DELEGATE_INPUT_SCHEMA as yg, CoordinationTools as yh, AcquireOptions as yi, resolveWorkerSpawnRetry as yl, HarnessTranscriptEvidence as ym, RollingDispatchOptions as yn, AgenticTask as yo, ResumedKeyState as yp, supervisorInstructions as yr, PanelVerdict as ys, SUBTREE_RESULT_LIMIT as yt, createProgressTracker as yu, ExecResult as yv, RetainedRunSnapshot as yw, createPropagatingTraceEmitter as yx, RouterTransportConfig as yy, UntrackedCopyStats as z, PlannerError as zC, McpTransport as zS, OpenAIChatTool as zT, sharedBoxRefusal as z_, SuperviseOptionsForDispatch as za, DelegationError as zb, PursuitCostProvenance as zc, GroupOf as zd, BudgetViolation as zf, createExecutorRegistry as zg, QuestionPolicy as zh, AgentTurnBackend as zi, CoordinationBinding as zl, DriverContractState as zm, runGraphWithTestBrain as zn, sampleThenRefine as zo, SpendGap as zp, officialChecksFromMeta as zr, DefinePersona as zs, profileRunsForName as zt, CoordinationTransportOptions as zu, ProviderWorkspaceCaptureProvenance as zv, AgentRunSpec as zw, toOtelAttributes as zx, FeedbackStore as zy };
+//# sourceMappingURL=index-CGNQWpge.d.ts.map