@tangle-network/agent-runtime 0.321.0 → 0.322.1

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

@@ -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 {
@@ -5652,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.
@@ -8376,7 +8402,8 @@ interface TraceRootArtifact {
  * - `'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
@@ -10017,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;
@@ -12409,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
@@ -12456,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. */
@@ -12529,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
@@ -13574,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.
    *
@@ -15965,193 +16009,506 @@ 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`.
-   */
-  runId?: string;
-  /**
-   * Clock override; default `Date.now`. Deterministic tests pass a
-   * monotonic counter to stabilize iteration timing fields.
-   */
-  now?: () => number;
-  /**
-   * Override the default winner selector (highest-valid-score, ties broken
-   * by earliest iteration).
-   */
-  selectWinner?: (iterations: Iteration<Task, Output>[]) => LoopWinner<Task, Output> | undefined;
-  /**
-   * Same-sandbox driver mode — a kernel→caller out-channel, not a value handed
-   * in. When set, the kernel keeps each finished worker box alive across the
-   * `plan()` boundary and hands it here, so a same-sandbox planner
-   * (one that reuses the worker's box) can stream its move INTO the
-   * worker's live box — steering from the worker's real filesystem and state,
+/** 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
+   * monotonic counter to stabilize iteration timing fields.
+   */
+  now?: () => number;
+  /**
+   * Override the default winner selector (highest-valid-score, ties broken
+   * by earliest iteration).
+   */
+  selectWinner?: (iterations: Iteration<Task, Output>[]) => LoopWinner<Task, Output> | undefined;
+  /**
+   * Same-sandbox driver mode — a kernel→caller out-channel, not a value handed
+   * in. When set, the kernel keeps each finished worker box alive across the
+   * `plan()` boundary and hands it here, so a same-sandbox planner
+   * (one that reuses the worker's box) can stream its move INTO the
+   * worker's live box — steering from the worker's real filesystem and state,
    * not just a history summary. The kernel owns teardown: every box kept alive
    * this way is destroyed at loop end (and the callback is invoked with
    * `undefined` then as a teardown sentinel). Without it, worker boxes are torn
@@ -16242,292 +16599,69 @@ interface LoopDispatchOptions<Task, Output, Decision, TScenario extends Scenario
   /** 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>>;
+  /** 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'>;
 /**
- * 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.)
+ * 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.
  */
-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;
-  }>>;
+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
@@ -17609,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";
@@ -19204,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
@@ -19962,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 $, RetainedInteractiveIntentAdmission as $C, AdmittedFinding as $S, AgentEnvironmentProviderRegistry as $_, SurfaceScore as $a, UiFindingSeverity as $b, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as $c, plateauLength as $d, MaterializedModelIdentity as $f, BridgeModelCredential as $g, ResolvedSpawnResourcePath as $h, createPrivateCasArtifactPort as $i, DEFAULT_DEADLINE_WARNING_MS as $l, AnalystRegistry$1 as $m, ChatCompletionsTransport as $n, EqualKOnCost as $o, readWorkerTraceContext as $p, strategyAuthorContract as $r, LeaderboardScore as $s, digestOfGraph as $t, readRunCancelRequest as $u, CodexExecutionEvidence as $v, MountManifestEntry as $w, composeLoopTraceEmitters as $x, DetachedTurn as $y, readWorkerInteractiveBinding as A, JudgeError as AC, McpToolAnnotations as AS, OpenAIChatToolChoice as AT, SharedWorkerIdentity as A_, BenchmarkConfig as Aa, DelegateUiAuditResult as Ab, PursuitFork as Ac, stopSentinel as Ad, Budget as Af, cliWorktreeExecutor as Ag, QuestionLevel as Ah, startRetainedRunInEnvironment as Ai, SupervisorSpanOutcome as Al, DriverBudgetReadout as Am, RunGraphTestOptions as An, InProcessOnPrompt as Ao, Spend as Ap, defaultExtractCandidate as Ar, WidenLineage as As, bestProfileFor as At, CoordinationMcpHandle as Au, ProviderNativeCapturePhase as Av, createBudgetPool as Aw, padSpanId as Ax, runCodeMode as Ay, copyUntrackedIntoClone as B, DEFAULT_CHECK_IN_IDLE_MS as BC, defaultToolDetectors as BS, createSandboxToolPartState as B_, AgenticSurface as Ba, DelegationStatus as Bb, PursuitProjection as Bc, ScoreOf as Bd, ExecutorExecutionBinding as Bf, DEFAULT_STALL_AFTER_MS as Bg, SuperviseProfileEntry as Bh, assertModelAllowed as Bi, ResolveSupervisorTools as Bl, summarizeDriverAttempts as Bm, delegatesWorkerBriefPrompt as Bn, ObservationAnalysis as Bo, TraceRootReceipt as Bp, EvolutionAuthor as Br, RunPersonified as Bs, createWorktreeCliExecutor as Bt, FileCoordinationLog as Bu, WorktreeCheckRunner as Bv, LoopIterationEndedPayload as Bw, createRuntimeEventCollector as Bx, DetachedWinnerSelection as By, AuthoredHarness as C, Redactor as CC, claimsAuthority as CS, AgentTaskRunResult as CT, ROUTER_CLIENT_HEADER as C_, registryScopeAnalyst as Ca, DelegateFeedbackArgs as Cb, VersionJudge as Cc, CompletionAnalyst as Cd, loadSpawnForest as Cf, CliWorktreeSeam as Cg, ManagerReentryState as Ch, acquireSandbox as Ci, RunContext as Cl, RetainedHarnessTranscriptCapture as Cm, EdgeDeliveryOutcome as Cn, SandboxEvidenceReceipt as Co, Scope as Cp, StructuralRolloutMessage as Cr, TrajectoryReport as Cs, ProvisionSupervisorConnection as Ct, FinalizerSettled as Cu, providerAsSandboxClient as Cv, ReservationHolder as Cw, buildLoopOtelSpans as Cx, CodeModeTool as Cy, WorkerInteractiveBinding as D, AgentEvalErrorCode as DC, peerMailVerbNames as DS, KnowledgeReadinessDecision as DT, SharedBoxPlacementOptions as D_, createMcpEnvironment as Da, DelegateResearchResult as Db, SupervisePursuitOptions as Dc, completionAuthorizes as Dd, Agent as Df, RouterToolsSeam as Dg, QuestionEscalationOutcome as Dh, reconnectRetainedRun as Di, withRunContext as Dl, DriverAttemptRecord as Dm, GraphNode as Dn, LocalSandboxClientOptions as Do, SpawnOpts as Dp, canDisplace as Dr, VerifySpec as Ds, provisionSupervisor as Dt, pickBestDelivered as Du, createTangleSandboxExactProcessProvider as Dv, ReservationTicket as Dw, createOtelExporter as Dx, RunCodeModeOptions as Dy, AttachWorkerOptions as E, AgentEvalError$1 as EC, peerMailTools as ES, BackendErrorDetail as ET, SharedBoxPlacement as E_, McpEnvironmentOptions as Ea, DelegateResearchConfig as Eb, SupervisePursuitError as Ec, CompletionVerdict as Ed, contentAddress as Ef, RouterSeam as Eg, QuestionDecision as Eh, createS3PrivateCasStore as Ei, createInMemoryRunContext as El, retainHarnessTranscript as Em, GraphEdgeCapError as En, captureBeforeDestroy as Eo, SpawnJournal as Ep, VisibleCheck as Er, Verify as Es, SupervisorCleanupReceipt as Et, collectDelivered as Eu, SandboxControlClient as Ev, ReservationStage as Ew, createOpenInferenceFileExporter as Ex, CodeModeToolset as Ey, closingWorkerNote as F, RetainedRunAdmissionError as FC, BusStats as FS, RuntimeSessionStore as FT, SandboxOutputMarker as F_, Environment as Fa, DelegationHistoryEntry as Fb, PursuitNodePlacement as Fc, LeaderboardOptions as Fd, Executor as Ff, SteerableSandboxArgs as Fg, SettledWorker as Fh, startRetainedInteractiveRun as Fi, CoordinationVerbs as Fl, DriverProgressMark as Fm, PromptHandle as Fn, HarvestError as Fo, SubtreeSummary as Fp, resolveEntrySymbol as Fr, LoopShape as Fs, recordProfileRun as Ft, CoordinationHttpOptions as Fu, ProviderWorkspaceEntryMetadata as Fv, ExecCtx as Fw, RuntimeStreamEventSink as Fx, CoderDelegate as Fy, WorkspaceCommit as G, NativeContextContinuationHandle as GC, TraceSource as GS, sandboxEventServedBackend as G_, RunAgenticOptions as Ga, ResearchOutputShape as Gb, FileObserverJournal as Gc, renderLeaderboardSvg as Gd, ExecutorRegistry as Gf, createActivityLog as Gg, analystToolGroupNames as Gh, CollectedAgentTurn as Gi, SupervisorNodeContextSeed as Gl, TraceRootArtifact as Gm, naiveContinuationPrompt as Gn, observe as Go, WidenGate as Gp, TournamentCell as Gr, DefinedLeaderboard as Gs, workerFromInteractiveProvider as Gt, WorkerCancellation as Gu, DiffOptions as Gv, LoopResult as Gw, CappedDelegationTrace as Gx, settleDetachedCoderTurn as Gy, GitWorkspaceOptions as H, WorkerSlots as HC, SessionMessageLike as HS, extractLlmCallEvent as H_, AgenticTool as Ha, DelegationStatusResult as Hb, PursuitRunTotals as Hc, pairwiseSignificance as Hd, ExecutorMaterialization as Hf, ScopeProgressInput as Hg, WorkerResumeContext as Hh, AgentTurnBackend as Hi, SupervisorAgentDeps as Hl, RetainedPendingCause as Hm, dumbContinuationPassPrompt as Hn, ObserveInput as Ho, UnconfirmedTeardown as Hp, EvolutionStrategy as Hr, ShapeBudget as Hs, InteractiveWorkerKeyInput as Ht, RunCancelRequest as Hu, WorktreeHarnessResult as Hv, LoopLineageOptions as Hw, sanitizeAgentRuntimeEvent as Hx, UiAuditorDelegate as Hy, composeWorkerEvidence as I, RetainedRunDispatchBindingError as IC, EventBus as IS, RuntimeStreamEvent as IT, SandboxServedBackend as I_, printBenchmarkReport as Ia, DelegationHistoryResult as Ib, PursuitNodePlatform as Ic, LeaderboardRow as Id, ExecutorAccounting as If, SteerableSandboxSession as Ig, SpawnPreflight as Ih, ResolveSandboxClientOptions as Ii, DriveHarness as Il, DriverReentry as Im, PromptRegistry as In, HarvestFailure as Io, SupervisedResult as Ip, sandboxCheckRunner as Ir, Outcome as Is, PatchDeliverableOptions as It, CoordinationRejectReason as Iu, ProviderWorkspaceRetentionContext as Iv, Iteration as Iw, RuntimeStreamEventSummary as Ix, CoderReview as Iy, jjWorkspace as J, RecoverRetainedRunIntentOptions as JC, sandboxSessionTraceSource as JS, AgentEnvironment$1 as J_, StrategyArtifacts as Ja, delegationProfiles as Jb, ObserverRecordKind as Jc, AnytimeStrategySummary as Jd, ExecutorToolCall as Jf, Inbox as Jg, downMessageRefusalReasons as Jh, streamAgentTurn as Ji, SupervisorToolInvocationContext as Jl, AnalystAssignmentRecord as Jm, defaultDelegateBudget as Jn, CombinatorShape as Jo, WorkerTraceEvidence as Jp, strategyTournament as Jr, LeaderboardBenchmarkAdapter as Js, createInPlaceCliExecutor as Jt, WriteWorkerSteerOptions as Ju, RemoveWorktreeOptions as Jv, LoopTeardownFailedPayload as Jw, DelegationTraceCaps as Jx, FleetWorkspaceExecutorOptions as Jy, WorkspaceRun as K, NativeContextContinuationInput as KC, createPushTraceSource as KS, sandboxProgressEvents as K_, ShotSpec as Ka, UiAuditLensFilter as Kb, ObserverJournal as Kc, renderPairwiseMarkdown as Kd, ExecutorResult as Kf, readWorkerProgress as Kg, canonicalFindingEvent as Kh, StreamAgentTurnOptions as Ki, SupervisorProfile as Kl, TraceSummary as Km, promptHandle as Kn, renderReport as Ko, WorkerInteractiveSession as Kp, TournamentRow as Kr, LeaderboardBenchScore as Ks, WorkerInteractiveAdmission as Kt, WorkerSteerAcknowledgement as Ku, DiffResult as Kv, LoopSandboxPlacement as Kw, DELEGATION_TRACE_MAX_BYTES as Kx, DelegationExecutor as Ky, settledWorkerOut as L, RuntimeRunStateError as LC, PublishOptions as LS, SandboxToolPartState as L_, runBenchmark as La, DelegationProfile as Lb, PursuitNodeProjection as Lc, PairwiseOptions as Ld, ExecutorCancellation as Lf, createSteerableSandboxSession as Lg, SpawnPreflightContext as Lh, resolveSandboxClient as Li, DriveHarnessOwnerContext as Ll, DriverRepromptRefusal as Lm, RegisteredPrompt as Ln, HarvestReport as Lo, Supervisor as Lp, selectBestIndex as Lr, Persona as Ls, patchDelivered as Lt, CoordinationDeliveryEvidence as Lu, ProviderWorkspaceRetentionPort as Lv, LoopDecisionPayload as Lw, RuntimeTelemetryOptions as Lx, CoderReviewer as Ly, NOTE_MAX_CHARS as M, PlannerError as MC, McpTransport as MS, RunAgentTaskStreamOptions as MT, sharedBoxRefusal as M_, BenchmarkReport as Ma, DelegationError as Mb, PursuitObserverDelivery as Mc, GroupOf as Md, BudgetViolation as Mf, createExecutorRegistry as Mg, QuestionPolicy as Mh, claimRetainedInteractiveControl as Mi, createSupervisorSpanRecorder as Ml, DriverContractState as Mm, defaultEdgeTraversalCap as Mn, InProcessSandboxClientOptions as Mo, SpendGap as Mp, filterAuthoredAsserts as Mr, WinnerStrategy as Ms, pickBestProfile as Mt, CoordinationTransportOptions as Mu, ProviderWorkspaceCaptureProvenance as Mv, AgentRunSpec as Mw, toOtelAttributes as Mx, FeedbackStore as My, VERIFY_TAIL_CHARS as N, RetainedInteractiveAdmissionError as NC, BusEvent as NS, RuntimeCanonicalStreamEvent as NT, sharedWorkerClientName as N_, BenchmarkStrategySummary as Na, DelegationFeedbackSnapshot as Nb, PursuitCostProvenance as Nc, Interval as Nd, EnvironmentTeardownReceipt as Nf, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Ng, QuestionRecord as Nh, reconnectRetainedInteractiveRun as Ni, CoordinationBinding as Nl, DriverFailureClass as Nm, runGraph as Nn, inProcessSandboxClient as No, SteerableRootHandle as Np, modelAuthoredChecks as Nr, DefinePersona as Ns, profileRegistry as Nt, serveCoordinationMcp as Nu, ProviderWorkspaceCaptureReceipt as Nv, DefaultVerdict$1 as Nw, RuntimeEventCollector as Nx, InMemoryFeedbackStore as Ny, WorkerInteractiveProviderSource as O, BackendTransportError as OC, JsonRpcMessage as OS, OpenAIChatResponseFormat as OT, SharedBoxProcess as O_, sanitizeMcpToolSchema as Oa, DelegateUiAuditArgs as Ob, SupervisedPursuitResult as Oc, deterministicCompletion as Od, AgentExecutionRef as Of, SandboxSeam as Og, QuestionEscalationRecord as Oh, recoverRetainedRun as Oi, SupervisorSpanAttributes as Ol, DriverAttemptStop as Om, GraphResult as On, localSandboxClient as Oo, SpawnPrior as Op, compareCheckOutcomes as Or, Widen as Os, ProfileRegistryDir as Ot, runFinalizer as Ou, UnavailablePausePolicy as Ov, ReservationWaitRefused as Ow, generateSpanId as Ox, createCodeModeTools as Oy, WorkerEvidenceInput as P, RetainedInteractiveBindingError as PC, BusRecord as PS, RuntimeSession as PT, SandboxLeafOut as P_, BenchmarkTaskRow as Pa, DelegationHistoryArgs as Pb, PursuitNodeCost as Pc, Leaderboard as Pd, ExecutionBindingReceipt as Pf, SandboxSteeringOptions as Pg, QuestionUrgency as Ph, recoverRetainedInteractiveRun as Pi, CoordinationToolFace as Pl, DriverLoopRecord as Pm, runGraphWithTestBrain as Pn, HarvestCorpusOptions as Po, SubtreeResult as Pp, officialChecksFromMeta as Pr, DefinePersonaInput as Ps, profileRunsForName as Pt, CoordinationHttpAudit as Pu, ProviderWorkspaceCaptureResult as Pv, Driver as Pw, RuntimeStreamEventCollector as Px, eventToSnapshot as Py, analyzeTrace as Q, RetainedInteractiveEnvironmentAdmission as QC, mapExecutorResult as QS, AgentEnvironmentProviderRef as Q_, StrategyShotResult as Qa, UiFindingScreenshot as Qb, AuthorizedSpawnContext as Qc, bestSoFar as Qd, MaterializedExecutionIdentity as Qf, BridgeHarnessStore as Qg, ResolveSpawnResourcePathsResult as Qh, PrivateCasOptions as Qi, supervisorAgentWithTestBrain as Ql, AnalystLensOutput as Qm, finalizeBestDelivered as Qn, EqualKArm as Qo, WorkerTraceSeamCarrier as Qp, authorStrategy as Qr, LeaderboardScenario as Qs, StoredGraph as Qt, legacySupervisorRunsRoot as Qu, removeWorktree as Qv, LoopWinner as Qw, capDelegationTrace as Qx, DetachedSessionRefParts as Qy, CopyOptions as R, ValidationError as RC, createEventBus as RS, SandboxUsageLedger as R_, AgenticOptions as Ra, DelegationProgress as Rb, PursuitNodeTiming as Rc, PairwiseVerdict as Rd, ExecutorCancellationRequest as Rf, ActivityLog as Rg, SpawnRefusal as Rh, profileChatClient as Ri, ObserveSupervisorNodeEvent as Rl, DriverRetryPolicy as Rm, analyzesFindingsReportPrompt as Rn, harvestCorpus as Ro, SupervisorOpts as Rp, structuralRollout as Rr, PersonaContext as Rs, WorktreeCliExecutorOptions as Rt, CoordinationLog as Ru, ProviderPlacement as Rv, LoopEndedPayload as Rw, SanitizedKnowledgeReadinessReport as Rx, DelegateRunCtx as Ry, failuresAnalyst as S, verdictFromJudgeScore as SC, PeerMailboxOptions as SS, AgentTaskContext as ST, DEFAULT_SHARED_BOX_WORKERS as S_, createScopeAnalyst as Sa, DelegateCodeResult as Sb, SettledPursuitVersion as Sc, writeWorkerSteer as Sd, SpawnForestTree as Sf, CliWorktreeBridgeSeam as Sg, MakeWorkerAgent as Sh, AcquireOptions as Si, InMemoryRunContextOptions as Sl, HarnessTranscriptReadOptions as Sm, AgentGraph as Sn, SandboxEvidenceContext as So, Runtime as Sp, StructuralRolloutConfig as Sr, TrajectoryNode as Ss, settledToIteration as St, FinalizeContext as Su, providerAsExecutor as Sv, ReservationFloor as Sw, RuntimeEventOtelOptions as Sx, CodeModeStore as Sy, worktreeFanout as T, resolveRedactor as TC, isPeerMailEnvelope as TS, AgentTaskStatus as TT, SharedBoxHandle as T_, McpEndpoint as Ta, DelegateResearchArgs as Tb, assertPursuitVersions as Tc, CompletionPolicy as Td, replaySpawnTree as Tf, ProviderSeam as Tg, Question as Th, S3PrivateCasStoreOptions as Ti, createFileRunContext as Tl, resolveHarnessTranscriptCapture as Tm, GraphEdge as Tn, SandboxEvidenceRetentionPort as To, SpawnEvent as Tp, StructuralRolloutResult as Tr, TrajectoryReportOptions as Ts, ProvisionedSupervisor as Tt, bestDelivered as Tu, CreateTangleSandboxExactProcessProviderOptions as Tv, ReservationShortfall as Tw, buildRuntimeEventOtelSpans as Tx, CodeModeToolsOptions as Ty, Shell as U, createWorkerSlots as UC, SessionTraceBox as US, mapSandboxEvent as U_, ArtifactHandle as Ua, FeedbackRating as Ub, PursuitStatus as Uc, renderLeaderboardHtml as Ud, ExecutorNodeContext as Uf, TeamProgress as Ug, WorkerSpawnContext as Uh, AgentTurnInput$1 as Ui, SupervisorAgentTestDeps as Ul, TRACE_ROOT_SCHEMA as Um, formatPromptHandle as Un, ObserveOptions as Uo, UnknownMaterializationReason as Up, StrategyEvolutionConfig as Ur, ShapeContext as Us, InteractiveWorkerOptions as Ut, RunCancellation as Uu, WorktreeProfileMaterializationReceipt as Uv, LoopPlanDescription as Uw, sanitizeKnowledgeReadinessReport as Ux, coderTaskFromArgs as Uy, withUntrackedArtifacts as V, DeadlineCheckIn as VC, watchTrace as VS, createSandboxUsageLedger as V_, AgenticTask as Va, DelegationStatusArgs as Vb, PursuitRunProjection as Vc, leaderboard as Vd, ExecutorFactory as Vf, ExecutorProgress as Vg, ToolOutcomeEvent as Vh, assertProfileModelsAllowed as Vi, ResolvedSupervisorProfile as Vl, upstreamUnavailableSignal as Vm, dumbContinuationFailPrompt as Vn, ObservationError as Vo, TreeView as Vp, EvolutionReport as Vr, RunPersonifiedOptions as Vs, InteractiveWorkerEnvironment as Vt, PriorCoordination as Vu, WorktreeCommandResult as Vv, LoopIterationStartedPayload as Vw, createRuntimeStreamEventCollector as Vx, SettleDetachedCoderTurnOptions as Vy, Workspace as W, NativeContextContinuationExecution as WC, ToolStepInput as WS, mapSandboxToolEvent as W_, CorpusReadbackOptions as Wa, FeedbackRefersTo as Wb, projectPursuit as Wc, renderLeaderboardMarkdown as Wd, ExecutorProgressEvent as Wf, WorkerProgress as Wg, WorkerWatchOptions as Wh, AgentTurnUsage as Wi, SupervisorNodeContext as Wl, TRACE_SUMMARY_SCHEMA as Wm, kernelPromptRegistry as Wn, defaultAnalystInstruction as Wo, UsageEvent as Wp, StrategyTournament as Wr, ShapeRegistry as Ws, InteractiveWorkerResult as Wt, WorkerCancelRequest as Wu, CreateWorktreeOptions as Wv, LoopPlanPayload as Ww, sanitizeRuntimeStreamEvent as Wx, detachedSessionDelegate as Wy, runInWorkspace as X, RecoverRetainedRunResult as XC, ExecutorResultMapping as XS, AgentEnvironmentEvent$1 as X_, StrategyMessage as Xa, UI_LENSES as Xb, verifyObserverRecords as Xc, anytimeReport as Xd, Handle as Xf, PeerInboxMessage as Xg, parseAuthoredAnalystDefinition as Xh, PrivateCasDurableStore as Xi, resolveSupervisorProfile as Xl, AnalystFindingEvent as Xm, DriverAgentOptions as Xn, CorpusFilter as Xo, WorkspaceCheckpointMarker as Xp, AuthoredStrategy as Xr, LeaderboardIterationInfo as Xs, GraphRunRecord as Xt, cancelWorker as Xu, captureWorktreeDiff as Xv, LoopTraceEmitter as Xw, DelegationTraceSpan as Xx, createFleetWorkspaceExecutor as Xy, localShell as Y, RecoverRetainedRunOptions as YC, DeliverableSpec as YS, AgentEnvironmentCapabilities$1 as Y_, StrategyCtx as Ya, UI_FINDING_SEVERITIES as Yb, observerRecordDigest as Yc, AnytimeTaskCurve as Yd, FleetYield as Yf, InboxMessage as Yg, normalizeAnalyzeOnSettle as Yh, PrivateCasArtifactPort as Yi, assertCoordinationBinding as Yl, AnalystDefinitionIssue as Ym, delegate as Yn, Corpus as Yo, WorkerTraceUnavailableReason as Yp, AuthorStrategyOptions as Yr, LeaderboardFlagSpec as Ys, GraphRegistryDir as Yt, cancelRun as Yu, WorktreeHandle as Yv, LoopTokenUsage as Yw, DelegationTraceCollector as Yx, SiblingSandboxExecutorOptions as Yy, TrajectoryAnalysis as Z, RetainedInteractiveAdmission as ZC, gateOnDeliverable as ZS, AgentEnvironmentProvider$1 as Z_, StrategyResult as Za, UiFinding as Zb, AuthorizedSpawn as Zc, areaUnderCurve as Zd, HeldEnvironment as Zf, createInbox as Zg, questionEscalationTargets as Zh, PrivateCasOffloadReport as Zi, supervisorAgent as Zl, AnalystKind as Zm, driverAgent as Zn, CorpusRecord as Zo, WorkerTraceResolver as Zp, assertStrategyContract as Zr, LeaderboardRunContext as Zs, GraphSelection as Zt, legacySupervisorRunDir as Zu, createWorktree as Zv, LoopTraceEvent as Zw, buildDelegationTraceSpans as Zx, createSiblingSandboxExecutor as Zy, boxSurfaceReader as _, checkVerdictOf as _C, PeerMailOutcome as _S, AgentBackendInput as _T, harnessUsageIsEmpty as __, widen as _a, SubmitInput as _b, NextPursuitVersion as _c, workerSteerAcknowledgementFile as _d, SpawnForest as _f, DelegateResult as _g, DownMessageDeliveryOutcome as _h, BranchCapableBox as _i, SeatSelection as _l, captureHarnessTranscript as _m, rollingDispatch as _n, TERMINAL_DECISIONS as _o, RootProviderModelEvidence as _p, CheckRunContext as _r, RenderCorpusToInstructionsOptions as _s, searchPresets as _t, ReentryContinuity as _u, ProviderLeafOut as _v, BudgetPool as _w, OtelAttribute as _x, ToolLoopCompactionOptions as _y, SandboxInstance$1 as a, ContinuationContext as aC, FileDelegationStoreOptions as aS, ValidationCtx as aT, resolveMcpServerLaunch as a_, definePersona as aa, detachedTurnEvents as ab, assertDeclaredCheck as ac, runCancelRequestFile as ad, SqlRunLease as af, hostDirectoryReader as ag, AuthorizedDownMessage as ah, StdioMcpConnection as ai, supervise as al, RetainedInteractiveAdmissionHook as am, loadGraph as an, runAgentic as ao, ProfileMaterializationReceipt as ap, chatWorkerSeam as ar, FanoutWinnerSelector as as, createRootHandle as at, ProgressTracker as au, AgentSessionRef as av, RetainedRunDispatchedAdmission as aw, ResearchSource as ax, LocalHarnessResult as ay, AnalystAuthoring as b, failedItems as bC, PeerMailSendInput as bS, AgentRuntimeEvent as bT, decodeHarnessUsage as b_, assertTraceDerivedFindings as ba, DelegateCodeArgs as bb, PursuitVersionStop as bc, workerSteerRequestsDir as bd, SpawnForestMissingTree as bf, CliInPlaceSeam as bg, EventAcknowledgement as bh, SessionCapableBox as bi, SelectSeat as bl, HarnessTranscriptMetadata as bm, GraphDesignerExtraTools as bn, isTerminalDecision as bo, RootSignal as bp, CheckSourceCtx as br, ScopeWidenGate as bs, ScopeArgs as bt, composeReentryTask as bu, WorkspaceRequest as bv, BudgetReconcileFault as bw, OtelExporter as bx, CodeModeOptions as by, VerifierEnvironmentOptions as c, ContinuationPanel as cC, CoderTask as cS, RuntimeRunCost as cT, CodexForkBoundary as c_, InMemoryCorpus as ca, runDetachedTurn as cb, declaredCheckDigest as cc, supervisorRunDir as cd, openSqlRunStore as cf, McpServerOptions as cg, ContinuationInstruction as ch, materializeLocalMcp as ci, ResolvedWorkerSpawnRetry as cl, RetainedInteractiveStartMaterial as cm, recordGraphRun as cn, LoopCampaignDispatchOptions as co, RecursiveReservationPolicy as cp, ProfileRichness as cr, LoopUntilSpec as cs, SqlRunContextOptions as ct, StopDecision as cu, CheckpointRef as cv, RetainedRunEventOptions as cw, createResearcherValidator as cx, localHarnessExecutable as cy, HarvestSurfaceDiffsOptions as d, ContinuationPolicy as dC, DEFAULT_PEER_MAIL_LIMITS as dS, RuntimeRunPersistenceAdapter as dT, CodexRolloutStoreReader as d_, flatWidenGate as da, DelegationResumeContext as db, IsolatedCheckBox as dc, workerCancelRequestsFile as dd, SqlAdapter as df, DELEGATE_DESCRIPTION as dg, CoordinationStats as dh, OpenSandboxRunOptions as di, WorkerSpawnRetryPolicy as dl, HarnessTranscriptCapture as dm, DispatchReport as dn, SuperviseDispatchOptions as do, ResultBlobStore as dp, assessAuthoredProfile as dr, PanelJudge as ds, SEARCH_SPEC_CORRELATION_KEY as dt, allWorkersStalled as du, ExecRequest as dv, RetainedRunReplayPoint as dw, TraceContext as dx, RouterResponseReceipt as dy, CONTINUATION_FACTS as eC, createDelegationTraceCollector as eS, MountRecorder as eT, BridgeSeam as e_, equalKOnCost as ea, DetachedTurnResumeDriverOptions as eb, LeaderboardSpec as ec, readRunCancellation as ed, renderAnytimeTable as ef, SPAWN_RESOURCE_PATH_MAX_BYTES as eg, AnalystToolGroupName as eh, strategyAuthorSystemPrompt as ei, DeliverableResolutionInput as el, workerTraceEnv as em, graphDigest as en, adaptiveRefine as eo, NoWinnerError as ep, ChatSessionStore as er, EqualKOnCostOptions as es, WorkerToolTraceArtifact as et, ManagerWakePolicy as eu, AgentEnvironmentQuery as ev, RetainedInteractiveStartedAdmission as ew, UiLens as ex, CodexExecutionPolicy as ey, SurfaceDiff as f, ContinuationProfile as fC, PEER_MAIL_WIRE_KEY as fS, RuntimeRunRow as fT, CodexRolloutStoreRef as f_, loopUntil as fa, DelegationResumeDriver as fb, IsolatedCheckBoxEvidence as fc, workerCancellationFile as fd, d1ToSqlAdapter as ff, DELEGATE_INPUT_SCHEMA as fg, CoordinationTools as fh, OpenSandboxRunPromptOptions as fi, isPreSpawnExecutorFailure as fl, HarnessTranscriptEvidence as fm, DispatchStopReason as fn, SuperviseOptionsForDispatch as fo, ResumedKeyState as fp, defaultProfileRichnessThresholds as fr, PanelSpec as fs, SearchSpec as ft, anyOf as fu, ExecResult as fv, RetainedRunSnapshot as fw, createPropagatingTraceEmitter as fx, RouterTransportConfig as fy, WatchedSurface as g, admitFinding as gC, PeerMailLimits as gS, AgentBackendContext as gT, createCodexRolloutStoreReader as g_, verify as ga, DelegationTaskQueueOptions as gb, JudgedPursuitVersion as gc, workerInboxFileFromEventDir as gd, InMemorySpawnJournal as gf, DelegateHandlerOptions as gg, DownMessageDeliveryAttempt as gh, openSandboxRun as gi, SeatSegment as gl, ReadableEnvironment as gm, queueOf as gn, RunAgentRoundsOptions as go, RootMaterialization as gp, CheckOutcome as gr, RenderCorpusToInstructions as gs, compileSearchSpec as gt, sampleFromSettled as gu, ProviderExecutorOptions as gv, StartRetainedRunOptions as gw, LoopSpanNode as gx, ToolLoopCompaction as gy, SurfaceReader as h, admitContinuationPolicy as hC, PeerMailKind as hS, AgentAdapter as hT, addHarnessUsage as h_, selectValidWinner as ha, DelegationTaskQueue as hb, runIsolatedCheck as hc, workerInboxFile as hd, InMemoryResultBlobStore as hf, DelegateError as hg, DownMessageAuthorizationInput as hh, TurnResult as hi, withWorkerSpawnRetry as hl, HarnessTranscriptUnavailableReason as hm, freeSlots as hn, superviseDispatch as ho, RootHandle as hp, CheckExecChannel as hr, PipelineStage as hs, assertSearchSpec as ht, plateau as hu, ProviderAsSandboxClientOptions as hv, StartRetainedRunInEnvironmentOptions as hw, traceContextToEnv as hx, ToolLoopChat as hy, SandboxEvent$1 as i, ContinuationAppend as iC, FileDelegationStore as iS, SelectionReceipt as iT, mcpSecretEnvMetadataKey as i_, registerShape as ia, createDetachedTurnResumeDriver as ib, DeclaredCheckStateCapture as ic, readWorkerSteerRequests as id, createWaterfallCollector as if, environmentReader as ig, AuthorizeDownMessage as ih, McpToolDescriptor as ii, SuperviseTestOptions as il, RecoverRetainedInteractiveRunOptions as im, listGraphRuns as in, refine as io, NodeStatus as ip, chatTransportExecutor as ir, FanoutSynthesis as is, DEFAULT_MAX_DEPTH as it, ProgressSample as iu, AgentSession as iv, RetainedRunCancellation as iw, ResearchOutput as ix, LocalHarness as iy, EVIDENCE_MAX_CHARS as j, NotFoundError as jC, McpToolDescriptor$1 as jS, RunAgentTaskOptions as jT, sharedBoxPlacement as j_, BenchmarkLift as ja, DelegateUiAuditRoute as jb, RUN_FORK_CORRELATION_KEYS as jc, AxisScoresOf as jd, BudgetOverspend as jf, createExecutor as jg, QuestionOption as jh, ClaimRetainedInteractiveControlOptions as ji, SupervisorSpanRecorder as jl, DriverContinuationRecord as jm, TraversalContinuity as jn, InProcessPromptCtx as jo, SpendChannel as jp, defaultStructuralRolloutPolicy as jr, WidenSpec as js, loadProfile as jt, CoordinationPublicAddress as ju, ProviderWorkspaceAttemptProvenance as jv, spendFromUsageEvents as jw, padTraceId as jx, FeedbackEvent as jy, attachWorker as k, ConfigError as kC, JsonRpcResponse as kS, OpenAIChatTool as kT, SharedBoxStats as k_, BenchmarkCell as ka, DelegateUiAuditConfig as kb, supervisePursuit as kc, sentinelCompletion as kd, AgentSpec as kf, cliInPlaceExecutor as kg, QuestionEscalationTarget as kh, startRetainedRun as ki, SupervisorSpanOptions as kl, DriverAttemptsExhaustedError as km, RunGraphOptions as kn, inlineSandboxClient as ko, SpawnRejection as kp, composeCheckSources as kr, WidenDecision as ks, ProfileRunRecord as kt, CoordinationAuthentication as ku, ProviderCheckpointCaptureContext as kv, ReserveOptions as kw, loopEventToOtelSpan as kx, describeCodeModeTools as ky, createVerifierEnvironment as l, ContinuationPanelInput as lC, coderTaskToPrompt as lS, RuntimeRunHandle as lT, CodexRolloutIdentity as l_, renderCorpusToInstructions as la, DelegationArgs as lb, declaredCheckJudge as lc, supervisorRunsRoot as ld, D1DatabaseLike as lf, createInProcessTransport as lg, ContinuityMode as lh, Deliverable as li, WorkerSpawnRetryAttempt as ll, StartRetainedInteractiveRunOptions as lm, storedGraphDigests as ln, LoopDispatchOptions as lo, ResourceLimit as lp, ProfileRichnessThresholds as lr, LoopUntilState as ls, createFencedSqlRunContext as lt, StopRule as lu, CheckpointRequest as lv, RetainedRunHandle as lw, multiHarnessResearcherFanout as lx, parseCodexTokenUsage as ly, SurfaceReadOutcome as m, VerdictSummary as mC, PeerMailEvent as mS, startRuntimeRun as mT, CodexStoreDelta as m_, pipeline as ma, DelegationRunContext as mb, IsolatedCheckResult as mc, workerControlLogFile as md, FileSpawnJournal as mf, DelegateArgs as mg, DefinedAnalystRecord as mh, SandboxRunAbortError as mi, retryPreSpawnRefusals as ml, HarnessTranscriptUnavailable as mm, RollingDispatchOptions as mn, loopDispatch as mo, RetainedExecutionState as mp, supervisorInstructions as mr, Pipeline as ms, SearchSpecOwnedOption as mt, noProgressFor as mu, PlacementInfo as mv, RetainedRunTurnInput as mw, readTraceContextFromEnv as mx, ToolLoopCallContext as my, AnalystFinding$1 as n, CheckUnavailableError as nC, DelegationStateCorruptError as nS, RunProvenance as nT, ResolvedMcpServerLaunch as n_, builtinShapes as na, DriveTurnTick as nb, DeclaredCheck as nc, readWorkerCancellation as nd, WaterfallReport as nf, SpawnResourceRead as ng, AuthoredAnalystDefinition as nh, MaterializeLocalMcpOptions as ni, SuperviseRegistry as nl, workerTraceSeamKey as nm, graphRegistry as nn, defineStrategy as no, NodeId as np, ChatTransportTool as nr, Fanout as ns, parseWorkerToolTraceArtifact as nt, NoProgressForOptions as nu, AgentEnvironmentSummary as nv, RetainedRunAdmissionHook as nw, KnowledgeUpdate as nx, DEFAULT_LOCAL_HARNESS as ny, computeFindingId$1 as o, ContinuationEntry as oC, InMemoryDelegationStore as oS, Validator as oT, resolveSecretEnv as o_, runPersonified as oa, formatDetachedSessionRef as ob, checkProgramDigest as oc, runCancellationFile as od, SqlRunOwnershipError as of, resolveSpawnResourcePaths as og, AwaitWakeInput as oh, StdioMcpServerSpec as oi, superviseWithTestBrain as ol, RetainedInteractiveEnvironmentInput as om, lookupGraph as on, sample as oo, ProviderModelAttemptEvidence as op, createChatSessionStore as or, FlatWidenGate as os, createSupervisor as ot, ProgressTrackerOptions as ou, AgentSessionStatus$1 as ov, RetainedRunEffect as ow, ResearchTask as ox, RunLocalHarnessOptions as oy, SurfaceReadBox as p, PanelFinding as pC, PeerMailEnvelope as pS, RuntimeRunStatus as pT, CodexRolloutTurn as p_, panel as pa, DelegationResumeTick as pb, IsolatedCheckOptions as pc, workerCancellationsDir as pd, FileResultBlobStore as pf, DELEGATE_TOOL_NAME as pg, CoordinationToolsOptions as ph, SandboxRun as pi, resolveWorkerSpawnRetry as pl, HarnessTranscriptFile as pm, DispatchUnit as pn, loopCampaignDispatch as po, ResumedWork as pp, profileRichnessFinding as pr, PanelVerdict as ps, SearchSpecInputs as pt, createProgressTracker as pu, ForkRequest as pv, RetainedRunStartMaterial as pw, mergeTraceEnv as px, ToolSpec as py, gitWorkspace as q, ReconnectRetainedRunOptions as qC, decodeToolPart as qS, sumSandboxUsage as q_, Strategy as qa, UiAuditorDelegationOutput as qb, ObserverRecord as qc, AnytimeReport as qd, ExecutorTeardownWarning as qf, AuthorityInboxMessage as qg, createCoordinationTools as qh, collectAgentTurn as qi, SupervisorToolDescriptor as ql, ANALYST_DEFINITION_BOUNDS as qm, DelegateOptions as qn, AssertTraceDerivedFindings as qo, WorkerInteractiveUnavailableReason as qp, runStrategyEvolution as qr, LeaderboardBenchTask as qs, InPlaceCliExecutorOptions as qt, WorkerSteerRequest as qu, GitRunner as qv, LoopStartedPayload as qw, DELEGATION_TRACE_MAX_SPANS as qx, FleetHandle as qy, CreateSandboxOptions$1 as r, CheckVerdict as rC, DelegationStore as rS, SandboxClient as rT, envKeyProvider as r_, createShapeRegistry as ra, RunDetachedTurnOptions as rb, DeclaredCheckPlacement as rc, readWorkerSteerAcknowledgement as rd, WaterfallSpan as rf, SpawnResourceReader as rg, AuthoredAnalystLimits as rh, McpSpawnFault as ri, SuperviseRegistryTable as rl, ReconnectRetainedInteractiveRunOptions as rm, graphRunsFor as rn, depthStrategy as ro, NodeSnapshot as rp, ChatWorkerSeamOptions as rr, FanoutOptions as rs, workerTraceAnalysisStore as rt, PlateauOptions as ru, AgentProfileRef as rv, RetainedRunCancelOptions as rw, MultiHarnessResearcherFanoutOptions as rx, LOCAL_HARNESSES as ry, makeFinding$1 as s, ContinuationNoteInput as sC, CoderOutput as sS, RuntimeRunCompleteInput as sT, secretEnvOfMcpServer as s_, FileCorpus as sa, parseDetachedSessionRef as sb, declaredCheckDeliverable as sc, safeWorkerFile as sd, SqlRunStoreOptions as sf, McpServer as sg, BlockedToolReport as sh, connectStdioMcp as si, workerFromBackend as sl, RetainedInteractiveRunHandle as sm, pickBestGraph as sn, sampleThenRefine as so, ProviderModelExecutionEvidence as sp, AuthoredProfile as sr, LoopUntil as ss, FencedSqlRunContext as st, ProgressView as su, AgentTurnResult$2 as sv, RetainedRunEnvironmentAdmission as sw, ResearcherProfileOptions as sx, harnessSupportsReasoningEffort as sy, AgentProfile$2 as t, CheckRead as tC, DelegationPersistenceError as tS, OutputAdapter as tT, KeyProvider as t_, trajectoryReport as ta, DriveTurnCapableBox as tb, defineLeaderboard as tc, readWorkerCancelRequests as td, WaterfallCollector as tf, SpawnResourceBytes as tg, AnalyzeOnSettleRoute as th, LocalMcpMaterialization as ti, SuperviseOptions as tl, workerTraceHeaders as tm, graphFromStored as tn, breadthStrategy as to, NodeExecutionIdentity as tp, ChatTransportExecutorOptions as tr, EqualKVerdict as ts, captureWorkerTraceEvidence as tt, AllWorkersStalledOptions as tu, AgentEnvironmentStatus as tv, RetainedRunAdmission as tw, KnowledgeItem as tx, CodexTokenUsage as ty, BoxSurfaceReaderOptions as u, ContinuationPanelResult as uC, AUTHORITY_MARKERS as uS, RuntimeRunOptions as uT, CodexRolloutSession as u_, fanout as ua, DelegationRecord as ub, readDeclaredCheck as uc, supervisorWorkersDir as ud, D1StmtLike as uf, createMcpServer as ug, CoordinationEvent as uh, OpenSandboxRunBeforeStartContext as ui, WorkerSpawnRetryHooks as ul, HarnessTranscriptArtifact as um, taskShapeDigest as un, LoopOptionsForDispatch as uo, ResourceSpend as up, asAuthoredProfile as ur, Panel as us, CompiledSearchSpec as ut, allOf as uu, CreateAgentEnvironmentInput$1 as uv, RetainedRunIntentAdmission as uw, researcherProfile as ux, runLocalHarness as uy, fsSurfaceReader as v, distillFindings as vC, PeerMailReadout as vS, AgentExecutionBackend as vT, readCodexRolloutSession as v_, CreateScopeAnalystOptions as va, SubmitOutput as vb, NextPursuitVersionInput as vc, workerSteerAcknowledgementsDir as vd, SpawnForestEvent as vf, createDelegateHandler as vg, DownMessageEvent as vh, SandboxLineage as vi, SeatSelectionInput as vl, harnessTranscriptArtifact as vm, DesignerRunGraphEnv as vn, TerminalDecision as vo, RootSegment as vp, CheckRunner as vr, ScopeAnalyst as vs, searchSpecDigest as vt, ReentryTaskInput as vu, ProviderPromptOptions as vv, BudgetPoolRestore as vw, OtelExportConfig as vx, ToolLoopMessageRecord as vy, WorktreeFanoutOptions as w, defaultRedactor as wC, createPeerMailbox as wS, AgentTaskSpec as wT, SharedBoxCloseReceipt as w_, observationFromRegistry as wa, DelegateFeedbackResult as wb, VersionVerdict as wc, CompletionEvidence as wd, materializeTreeView as wf, ExecutorConfig as wg, ManagerWake as wh, S3PrivateCasStore as wi, RunContextLease as wl, RetainedHarnessTranscriptDescriptor as wm, EdgeTraversal as wn, SandboxEvidenceRetentionError as wo, Settled as wp, StructuralRolloutPolicy as wr, TrajectoryReportFn as ws, ProvisionSupervisorRequest as wt, SupervisorFinalizer as wu, resolveAgentEnvironmentProvider as wv, ReservationRejection as ww, buildLoopSpanNodes as wx, CodeModeToolContext as wy, analystsFromRegistry as x, passedItems as xC, PeerMailbox as xS, AgentRuntimeEventSink as xT, DEFAULT_SHARED_BOX_RESOURCES as x_, buildSteerContext as xa, DelegateCodeConfig as xb, PursuitVersions as xc, workerSteersDir as xd, SpawnForestNode as xf, CliSeam as xg, LeadMessage as xh, createSandboxLineage as xi, InMemoryRunContext as xl, HarnessTranscriptReadLimits as xm, graphDesignerExtraTools as xn, runAgentRounds as xo, RootStreamReceipt as xp, RepairStop as xr, SteerContext as xs, createScope as xt, DeliveredOutput as xu, createAgentEnvironmentProviderRegistry as xv, LeakedReservation as xw, OtelSpan as xx, CodeModeResult as xy, harvestSurfaceDiffs as y, expandQuestions as yC, PeerMailRefusal as yS, AgentKnowledgeProvider as yT, HarnessUsage as y_, RegistryAnalyzeProjection as ya, hashIdempotencyInput as yb, PursuitVersionChain as yc, workerSteerRequestFile as yd, SpawnForestInDoubtNode as yf, validateDelegateArgs as yg, EscalateQuestion as yh, SandboxLineageHandle as yi, SeatStage as yl, persistHarnessTranscript as ym, DesignerToolsEnv as yn, defaultSelectWinner as yo, RootSegmentEntry as yp, CheckSource as yr, ScopeAnalyzeInput as ys, SUBTREE_RESULT_LIMIT as yt, UNPROVEN_CONTINUITY as yu, ResourceRequest as yv, BudgetReadout as yw, OtelExportStats as yx, ToolLoopToolCall as yy, UntrackedCopyStats as z, DEADLINE_CHECK_IN_MESSAGE as zC, WatchTraceOptions as zS, assertSandboxServedModel as z_, AgenticRunResult as za, DelegationResultPayload as zb, PursuitNodeUsage as zc, ProfileKeyOf as zd, ExecutorContext as zf, ActivityNote as zg, SpawnRefusalCause as zh, profileOptimizerModelCall as zi, ResolveDriveHarness as zl, classifyDriverFailure as zm, createPromptRegistry as zn, Observation as zo, TokenUsageProvenance as zp, visibleCheckScore as zr, PersonaExecutors as zs, WorktreePatchArtifact as zt, CoordinationOwnerId as zu, InPlaceHarnessResult as zv, LoopIterationDispatchPayload as zw, SanitizedKnowledgeRequirement as zx, DetachedSessionDelegateOptions as zy };
-//# sourceMappingURL=index-BxiHetnG.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