@tangle-network/agent-runtime 0.317.0 → 0.319.3

package/dist/{index-CUh40yUJ.d.ts → index-Da7w2H86.d.ts}

@@ -1,18 +1,19 @@
 import { n as AnalystRegistryLike } from "./types-zWfqDjeL.js";
-import { s as ProfileMaterializationContract } from "./profile-materialization-Cca615eu.js";
+import { s as ProfileMaterializationContract } from "./profile-materialization-C5-t3HJ7.js";
 import { l as RuntimeHooks, o as RuntimeHookEvent, r as RuntimeDecisionPoint } from "./runtime-hooks-Bj6wJHlH.js";
-import { P as AgentCandidateOutputArtifactPort, g as AgentCandidateArtifactPort, l as AgentCandidateWorkspaceArchiveLimits, n as AgentCandidateWorkspaceTree } from "./workspace-streams-CpSmt3zx.js";
-import { AgentCandidateArtifactRef, AgentCandidateWorkspaceManifestMaterial, AgentCandidateWorkspaceSnapshotEvidence, AgentExactRunControlRef, AgentInteractiveSession, AgentInteractiveSessionControlClaim, AgentInteractiveSessionPromptAcknowledgement, AgentInteractiveSessionPromptCommand, AgentInteractiveSessionRef, AgentInteractiveSessionStart, AgentInteractiveSessionStatus, AgentNativeContextContinuationOptions, AgentNativeContextContinuationResult, AgentProfile, AgentProfile as AgentProfile$2, AgentProfile as AgentProfile$3, AgentProfileDiff, AgentProfileMcpServer, AgentProfilePrompt, AgentProfileSecurityPolicy, AgentSessionStatus, AgentTurnResult, ChildTaskEvent, ContextTransferRequest, HarnessType, InputPart, InteractionAcknowledgement, InteractionRequest, InteractionResponseCommand, NativeContextBoundaryProof, NativeContextContinuationRequest, NativeContextContinuationTurn, ReasoningEffort, RequestedInteractions, RuntimeEventEnvelope, Sha256Digest, StreamEvent, WorkspaceCheckpointRef, WorkspaceCheckpointRequest } from "@tangle-network/agent-interface";
+import { P as AgentCandidateOutputArtifactPort, g as AgentCandidateArtifactPort, l as AgentCandidateWorkspaceArchiveLimits, n as AgentCandidateWorkspaceTree } from "./workspace-streams-U6_UfOXu.js";
+import { AgentCandidateArtifactRef, AgentCandidateWorkspaceManifestMaterial, AgentCandidateWorkspaceSnapshotEvidence, AgentExactRunControlRef, AgentInteractiveSession, AgentInteractiveSessionControlClaim, AgentInteractiveSessionPromptAcknowledgement, AgentInteractiveSessionPromptCommand, AgentInteractiveSessionRef, AgentInteractiveSessionStart, AgentInteractiveSessionStatus, AgentNativeContextContinuationOptions, AgentNativeContextContinuationResult, AgentProfile, AgentProfile as AgentProfile$2, AgentProfile as AgentProfile$3, AgentProfileDiff, AgentProfileMcpServer, AgentProfilePrompt, AgentProfileSecurityPolicy, AgentSessionStatus, AgentTurnResult, ChildTaskEvent, ContextTransferReceipt, ContextTransferRequest, HarnessType, InputPart, InteractionAcknowledgement, InteractionRequest, InteractionResponseCommand, NativeContextBoundaryProof, NativeContextContinuationRequest, NativeContextContinuationTurn, ReasoningEffort, RequestedInteractions, RuntimeEventEnvelope, Sha256Digest, StreamEvent, WorkspaceCheckpointRef, WorkspaceCheckpointRequest } from "@tangle-network/agent-interface";
 import { AgentEvalError, AgentEvalError as AgentEvalError$1, AgentEvalErrorCode, AgentProfile as AgentProfile$1, AnalystFinding, AnalystFinding as AnalystFinding$1, AnalystFinding as AnalystFinding$2, AnalystRunInputs, ChatClient, ConfigError, ControlBudget, ControlDecision, ControlEvalResult, ControlRunResult, ControlStep, CustomTokenPricing, DataAcquisitionPlan, DefaultVerdict, DefaultVerdict as DefaultVerdict$1, DetectorSignal, HarnessType as HarnessType$1, JudgeError, KnowledgeReadinessReport, KnowledgeRequirement, MaximumCharge, NotFoundError, PairedPromotionDecision, ProposalFinding, RankTestMethod, RegistryRunOpts, RunRecord, StreamingDetector, ToolSpan, TraceAnalysisEngine, TraceAnalysisStore, TraceStore, UserQuestion, ValidationError, buildTrajectory, computeFindingId as computeFindingId$1, makeFinding as makeFinding$1 } from "@tangle-network/agent-eval";
 import { AgentRunOutcome } from "@tangle-network/sandbox/runtime";
 import { ChildProcess } from "node:child_process";
-import { WorkspacePlanReceipt } from "@tangle-network/agent-profile-materialize";
+import { HarnessId, WorkspacePlanReceipt } from "@tangle-network/agent-profile-materialize";
 import { BackendType, BranchOptions, CreateRequestOptions, CreateSandboxOptions, CreateSandboxOptions as CreateSandboxOptions$1, PromptOptions, Sandbox, SandboxEvent, SandboxEvent as SandboxEvent$1, SandboxInstance, SandboxInstance as SandboxInstance$1, SandboxResources } from "@tangle-network/sandbox";
 import { AnalystRegistry, AnalystRunInputs as AnalystRunInputs$1, AnalystRunResult as AnalystRunResult$1, RegistryRunOpts as RegistryRunOpts$1 } from "@tangle-network/agent-eval/analyst";
 import { DispatchFn, ExternalOptimizerModelCall, JudgeConfig, NodeEstimate, ProfileDispatchFn, RunProfileMatrixOptions, RunProfileMatrixResult, Scenario, SearchAllocator, SearchAudit, SearchClaim, SearchClaimVerification, SearchCloseReason, SearchHistoryReceipt, SearchNodeStatus, SearchPolicy, SearchSplit, SearchStateView } from "@tangle-network/agent-eval/campaign";
 import { EvaluationClaim, SealedExperiment } from "@tangle-network/agent-eval/experiment";
 import { stuckLoopView, toolWasteView } from "@tangle-network/agent-eval/pipelines";
 import { AgentEnvironment, AgentEnvironment as AgentEnvironment$1, AgentEnvironmentCapabilities, AgentEnvironmentCapabilities as AgentEnvironmentCapabilities$1, AgentEnvironmentEvent, AgentEnvironmentEvent as AgentEnvironmentEvent$1, AgentEnvironmentProvider, AgentEnvironmentProvider as AgentEnvironmentProvider$1, AgentEnvironmentQuery, AgentEnvironmentStatus, AgentEnvironmentSummary, AgentProfileRef, AgentSession, AgentSessionRef, AgentSessionStatus as AgentSessionStatus$1, AgentTurnInput, AgentTurnInput as AgentTurnInput$1, AgentTurnResult as AgentTurnResult$1, AgentTurnResult as AgentTurnResult$2, CheckpointRef, CheckpointRequest, CreateAgentEnvironmentInput, CreateAgentEnvironmentInput as CreateAgentEnvironmentInput$1, ExecRequest, ExecResult, ForkRequest, PlacementInfo, ResourceRequest, WorkspaceRequest } from "@tangle-network/agent-interface/environment-provider";
+import { CodemodeExecuteOptions, CodemodeJsonSchema, CodemodeResult, CodemodeSandboxOptions } from "@earendil-works/pi-codemode";
 //#region src/types.d.ts
 /** @stable */
 interface AgentTaskSpec {
@@ -1714,6 +1715,8 @@ interface RetainedRunStartMaterial {
   /** Reuse an environment whose retained ownership key is verified instead of creating one. */
   readonly existingEnvironmentId?: string;
   readonly turn: RetainedRunTurnInput;
+  /** Accepted destination to attach, without creating or replacing its environment. */
+  readonly contextTransferReceipt?: ContextTransferReceipt;
   /**
    * Explicit dispatch coordinates. When omitted, the runtime mints
    * deterministic coordinates from `(environment.idempotencyKey, turn.turnId)`
@@ -1781,6 +1784,17 @@ interface RecoverRetainedRunOptions {
   readonly environmentId: string;
   readonly sessionId: string;
   readonly executionId: string;
+  /**
+   * Transfer replay identity, when the crashed run started from an ACCEPTED
+   * context transfer: the original request and its authoritative receipt.
+   * Recovery repeats the receipt-authorized lookup and verifies the receipt's
+   * run binding — without it, an adapter that requires receipt-authorized
+   * lookup answers not_found, and one that does not can return a run the
+   * receipt never bound. Callers that persisted the turn's context-transfer
+   * material supply these; behavior is unchanged for runs that had none.
+   */
+  readonly contextTransfer?: ContextTransferRequest;
+  readonly transferReceipt?: ContextTransferReceipt;
   readonly now?: () => number;
 }
 /**
@@ -4658,6 +4672,74 @@ declare class InMemoryFeedbackStore implements FeedbackStore {
  */
 declare function eventToSnapshot(event: FeedbackEvent): DelegationFeedbackSnapshot;
 //#endregion
+//#region src/runtime/code-mode.d.ts
+type CodeModeResult = CodemodeResult;
+type CodeModeStore = NonNullable<CodemodeExecuteOptions['store']>;
+interface CodeModeToolContext {
+  /** Aborted on script return, failure, timeout, or cancellation. */
+  readonly signal: AbortSignal;
+  /** Parent tool-call identity, supplied by the existing Runtime loop. */
+  readonly parentCallId: string;
+  /** Identity for this nested call, not an external-effect idempotency key. */
+  readonly callId: string;
+}
+interface CodeModeTool {
+  readonly name: string;
+  readonly description?: string;
+  /** Declaration metadata only; the original handler must validate input before effects. */
+  readonly inputSchema?: CodemodeJsonSchema;
+  /** Declaration metadata only; does not validate or transform handler results. */
+  readonly outputSchema?: CodemodeJsonSchema;
+  /** Use the host's normal authorized, validated, metered dispatch here. */
+  readonly execute: (args: unknown, context: CodeModeToolContext) => Promise<unknown> | unknown;
+}
+interface CodeModeOptions {
+  /** Includes time in tools; at most 2,147,483,647 ms. Infinity disables the deadline. */
+  readonly timeoutMs?: number;
+  readonly memoryLimitBytes?: number;
+  /** Excess calls queue; Promise.all does not fail simply because the queue is full. */
+  readonly concurrency?: number;
+  /** Bounds total admitted calls, including queued calls. */
+  readonly maxCalls?: number;
+  /** Only bundled hosts need to override upstream's on-disk worker/wasm resolution. */
+  readonly wasm?: CodemodeSandboxOptions['wasm'];
+  readonly workerUrl?: CodemodeSandboxOptions['workerUrl'];
+}
+interface RunCodeModeOptions extends CodeModeOptions {
+  readonly tools: ReadonlyArray<CodeModeTool>;
+  readonly signal?: AbortSignal;
+  readonly callId: string;
+  /** An explicit snapshot from the caller's existing state owner. */
+  readonly store?: CodeModeStore;
+}
+/** Render the same tool descriptors that are executed, including their result schemas. */
+declare function describeCodeModeTools(tools: ReadonlyArray<CodeModeTool>, query?: string): Promise<string>;
+/**
+ * Execute a JS async-function body against Runtime capabilities. The upstream
+ * QuickJS/WASM worker is the boundary; there is no node:vm or unsafe fallback.
+ * Every invocation has a fresh VM. Only successful storeWrites may be committed
+ * by the caller. External tool effects are neither transactional nor retried.
+ */
+declare function runCodeMode(code: string, options: RunCodeModeOptions): Promise<CodeModeResult>;
+/** Session data is explicit so the existing run owner can retain and restore it. */
+interface CodeModeToolsOptions extends CodeModeOptions {
+  readonly store?: CodeModeStore;
+  /** These capabilities keep their direct model tools and are not callable from code. */
+  readonly directTools?: ReadonlyArray<string>;
+}
+interface CodeModeToolset {
+  readonly tools: ReadonlyArray<CodeModeTool>;
+  /** Detached successful store state, never the guest heap or a program checkpoint. */
+  snapshotStore(): CodeModeStore;
+}
+/**
+ * Present an existing authorized tool set as code mode. This is used by Runtime's
+ * existing loops; it does not execute a model, create an agent, or grant authority.
+ * One toolset belongs to one conversation. Concurrent programs are refused to
+ * avoid silently losing store writes; concurrency within a program is queued.
+ */
+declare function createCodeModeTools(granted: ReadonlyArray<CodeModeTool>, options?: CodeModeToolsOptions): CodeModeToolset;
+//#endregion
 //#region src/runtime/router-retry-policy.d.ts
 /** Exact retry controls accepted at `AgentProfile.model.metadata.retry`. */
 interface RouterRetryPolicy {
@@ -4684,6 +4766,8 @@ interface ToolLoopToolCall {
   name: string;
   /** Raw JSON arguments emitted by the model. */
   arguments: string;
+  /** Opaque fields echoed on this call's assistant tool_calls entry, such as a provider signature. */
+  providerFields?: Record<string, unknown>;
 }
 /** Runtime-owned identity and cancellation for one logical inference call. The wrapper is frozen
  * before dispatch; a transport may observe the signal but cannot replace the authority it names. */
@@ -4842,6 +4926,7 @@ interface ToolSpec {
     name: string;
     description?: string;
     parameters: unknown;
+    outputSchema?: Record<string, unknown> | boolean;
   };
 }
 //#endregion
@@ -5616,6 +5701,10 @@ interface ProviderExecutorOptions {
   runtime?: Runtime;
   destroyOnSettle?: boolean;
   requireTerminalEvent?: boolean;
+  /** Maximum silence while observing an admitted retained turn. Activity resets this bound. */
+  retainedObservationIdleMs?: number;
+  /** Maximum wait for the exact retained result after observation ends without a terminal frame. */
+  retainedResultWaitMs?: number;
   /**
    * Per-run prompt options merged UNDER every streamed turn: a mapped turn's own field wins, and
    * the runtime's abort signal is applied last. `providerOptions` merges one level, so a
@@ -6256,11 +6345,17 @@ interface KeyProvider {
 declare function envKeyProvider(env?: Record<string, string | undefined>): KeyProvider;
 /** The `AgentProfileMcpServer.metadata` key the declarative secret-env map
  *  rides under: `{ ENV_VAR_NAME: 'PROVIDER_KEY_NAME' }`. Names only — values
- *  are resolved at materialize time and never stored. */
+ *  are resolved at materialize time and never stored.
+ *
+ *  DEPRECATED (2026-10-12): this is the interface <0.40 channel. Author
+ *  `profile.mcp[key].env.ENV_VAR_NAME = { kind: 'secret-ref', key }` instead —
+ *  the canonical form since 0.40. The legacy map keeps resolving (profiles
+ *  are data in the wild and must not break at boot) but every use now warns
+ *  once per server; removal lands at the next interface major. */
 declare const mcpSecretEnvMetadataKey = "secretEnv";
 /** Read (and validate) a server entry's declared secret-env map, if any.
  *  Malformed metadata throws — a half-declared secret must never half-boot. */
-declare function secretEnvOfMcpServer(server: AgentProfileMcpServer): Record<string, string> | undefined;
+declare function secretEnvOfMcpServer(server: AgentProfileMcpServer, label?: string): Record<string, string> | undefined;
 /**
  * Resolve a declared secret-env map into the real env entries for a server
  * spawn. Fail-closed: no provider or a missing key throws, naming the KEY
@@ -6850,13 +6945,17 @@ interface RouterToolsSeam {
   routerKey: string;
   complete?: RouterConfig['complete'];
   tools: ReadonlyArray<ToolSpec>;
-  executeToolCall: (name: string, args: Record<string, unknown>, task: unknown) => Promise<string>;
+  executeToolCall: (name: string, args: Record<string, unknown>, task: unknown, context: CodeModeToolContext) => Promise<unknown>;
+  /** Run model-written scripts over the same profile-authorized tool handlers. */
+  codeMode?: true | Omit<CodeModeToolsOptions, 'wasm' | 'workerUrl'>;
   /** Exact conversation to continue. Runtime validates its system message against the profile. */
   initialMessages?: ReadonlyArray<Readonly<Record<string, unknown>>>;
   /** Persist each buffered HTTP attempt, including failed responses, before the next turn. */
   onProviderResponse?: (receipt: RouterResponseReceipt) => void | Promise<void>;
   /** Observe the detached final conversation for session persistence. */
-  onMessages?: (messages: ReadonlyArray<Readonly<Record<string, unknown>>>) => void | Promise<void>;
+  onMessages?: (messages: ReadonlyArray<Readonly<Record<string, unknown>>>, context?: {
+    codeModeStore: CodeModeStore;
+  }) => void | Promise<void>;
   /** Online observer of each tool step — the seam a `DetectorMonitor` taps to watch the live pipe
    *  (raise a `finding` when the worker loops/errors). Called after every tool call resolves, with
    *  real per-call wall-clock (`startedAt`/`endedAt`/`durationMs`) so a push `TraceSource` can carry
@@ -8252,7 +8351,7 @@ declare function createCoordinationTools(opts: CoordinationToolsOptions): Coordi
  * `RETAINED_CONTROL_REF_READ_FAILED`). The second kind is a wrapper: what it wraps decides, in a
  * post-admission context, and a wrapper around nothing classifiable is exhibit 4.
  */
-type RetainedPendingCause = 'unobservable' | 'provider-contract' | 'request-rejected' | 'transport' | 'nested-recovery';
+type RetainedPendingCause = 'unobservable' | 'terminal-event-lost' | 'provider-contract' | 'request-rejected' | 'transport' | 'nested-recovery';
 /** @internal Validated original invocation selected for live adoption by the supervisor. */
 interface RetainedChildRecovery {
   readonly spawned: Extract<SpawnEvent, {
@@ -15851,6 +15950,8 @@ declare function inlineSandboxClient(factory: ExecutorFactory<unknown>, defaults
 //#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;
@@ -17074,7 +17175,7 @@ declare function claimRetainedInteractiveControl(options: ClaimRetainedInteracti
  * coordinates are confirmed by the provider and persisted by the caller.
  *
  * The required `onAdmission` hook first records a digest-only intent before
- * creation, then records recovery coordinates and the verified exact control
+ * creation or receipt-authorized attachment, then records recovery coordinates and the verified exact control
  * reference. The returned promise resolves only after the dispatched admission
  * is durable, so a crash cannot lose a successful start's exact reference.
  *
@@ -17487,9 +17588,11 @@ interface LocalMcpMaterialization {
   close(): Promise<void>;
 }
 /**
- * Spawn every explicitly trusted stdio server in `profile.mcp` as a same-host
- * child and expose its tools under `<server>__<tool>` names. The default policy
- * refuses local processes. A profile with no MCP surface returns zero tools.
+ * 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
@@ -17967,51 +18070,6 @@ interface ChatWorkerSeamOptions {
 /** Session-owning worker factory for graph continuity. */
 declare function chatWorkerSeam(opts: ChatWorkerSeamOptions): MakeWorkerAgent;
 //#endregion
-//#region src/runtime/supervise/code-mode.d.ts
-/** Where model-written code runs. THE isolation boundary — see the module doc: this runtime ships
- *  no default, so a caller chooses trusted-in-process or a real jail deliberately. */
-interface CodeModeRunner {
-  run(args: {
-    readonly code: string;
-    /** The granted operations, already cancellation-gated and result-detached by the caller. The
-     *  runner exposes these to the program as `api.<name>` and adds nothing else reachable. */
-    readonly bindings: Readonly<Record<string, (args: unknown) => Promise<unknown>>>;
-    /** Aborts when the manager cancels or a caller-authored deadline passes. */
-    readonly signal: AbortSignal;
-  }): Promise<{
-    readonly result: unknown;
-    readonly logs: ReadonlyArray<string>;
-  }>;
-}
-/**
- * An in-process runner for TRUSTED model output ONLY. NOT a security boundary.
- *
- * It runs the program in a `node:vm` context whose globals are the bindings (`api`) and a
- * capturing `console`, with code generation disabled and inherited properties stripped. Those are
- * capability discipline, not containment: `node:vm` shares the host realm, and a host function's
- * `.constructor` is the host `Function`, so code that WANTS out can get out
- * (`api.<binding>.constructor('return process')()`). Use this for your own eval harness, offline
- * tests, or a model you trust; for untrusted output supply a jailed `CodeModeRunner` instead.
- */
-declare function unsafeInProcessRunner(): CodeModeRunner;
-interface CodeModeOptions {
-  /** Optional caller-authored deadline for one `execute` call. Omit it to run until the manager
-   *  cancels. A declared deadline aborts the runner and refuses later `api` calls. */
-  readonly timeoutMs?: number | null;
-}
-/**
- * Put a supervisor in code mode: its product tool surface becomes exactly `search` and `execute`.
- *
- * `runner` is REQUIRED and has no default — this runtime ships no isolate, so the execution
- * boundary is the caller's explicit choice (see the module doc). Use {@link unsafeInProcessRunner}
- * for trusted output; a jailed runner for untrusted models.
- *
- * Pass the result as `SuperviseOptions.resolveSupervisorTools` (which `runGraph` forwards to its
- * root supervisor). The graph engine's `supervisorKind` does not accept it yet, so a graph
- * supervisor node cannot be put in code mode through node config today.
- */
-declare function codeModeSupervisorTools(runner: CodeModeRunner, options?: CodeModeOptions): ResolveSupervisorTools;
-//#endregion
 //#region src/runtime/supervise/router-transcript.d.ts
 /** What the brain returned for one turn, as the recorder keeps it. */
 interface RouterTranscriptReply {
@@ -18271,78 +18329,6 @@ interface DelegateOptions<Out = unknown> {
  */
 declare function delegate<Out = unknown>(intent: string, opts: DelegateOptions<Out>): Promise<SupervisedResult<Out>>;
 //#endregion
-//#region src/runtime/supervise/dispatch.d.ts
-/** One unit of queued work: the agent to run, its task, and the spawn options (budget + label).
- *  `nextUnit` mints these lazily so a queue can be generated, re-ordered, or grown while the
- *  dispatcher runs. */
-interface DispatchUnit<Out> {
-  readonly agent: Agent<unknown, Out>;
-  readonly task: unknown;
-  readonly opts: SpawnOpts;
-}
-/** Why the dispatcher stopped admitting work. `drained` = the queue ran dry (the ordinary end);
- *  `not-admitted` = the conserved pool or the depth ceiling refused a spawn; `stopped` = the
- *  caller's `shouldStop` returned true; `aborted` = the scope's signal fired. */
-type DispatchStopReason = 'drained' | 'not-admitted' | 'stopped' | 'aborted';
-interface RollingDispatchOptions<Out> {
-  /**
-   * How many children to hold in flight. Must be a positive integer. This is a SIMULTANEITY fence
-   * only — the conserved pool still bounds total work, and a `width` larger than the pool can
-   * afford simply hits `not-admitted` sooner.
-   */
-  readonly width: number;
-  /**
-   * Produce the next unit of work, or `undefined` when the queue is dry. Called only when a slot
-   * is free, so a caller may compute the next unit from what has already settled (the point of a
-   * refilling dispatcher: the queue is allowed to react). Never called after a stop.
-   */
-  nextUnit(): DispatchUnit<Out> | undefined | Promise<DispatchUnit<Out> | undefined>;
-  /**
-   * Called once per settlement, in cursor order, BEFORE the freed slot is refilled — so an
-   * `onSettled` that appends to the caller's queue is visible to the very next `nextUnit`.
-   */
-  onSettled?(settled: Settled<Out>): void | Promise<void>;
-  /**
-   * Consulted before each admission. `true` stops admitting; the already-live children are still
-   * drained to completion (no orphan, no lost settlement). Use it for a progress/plateau rule.
-   */
-  shouldStop?(): boolean;
-}
-interface DispatchReport<Out> {
-  /** Every settlement, in the order `scope.next()` yielded them. */
-  readonly settled: ReadonlyArray<Settled<Out>>;
-  /** How many children this dispatcher admitted. */
-  readonly admitted: number;
-  /** Admission rejections, in order — `label: reason`. Non-empty ⇒ the pool or depth fenced. */
-  readonly rejected: ReadonlyArray<string>;
-  readonly stopReason: DispatchStopReason;
-  /** The highest simultaneous live count actually reached — the number to compare against
-   *  `width` when asking "did the slots really stay full?" */
-  readonly peakLive: number;
-}
-/**
- * Run the refilling dispatch loop over `scope` until the queue is dry (or a stop fires) and every
- * admitted child has settled. Returns the settlements in cursor order plus the admission ledger.
- *
- * The loop is: fill free slots from `nextUnit` → `await scope.next()` → deliver the settlement →
- * refill → repeat. Because the refill happens immediately after each settlement rather than after
- * a whole round, a slow child never idles the other slots.
- */
-declare function rollingDispatch<Out>(scope: Scope<Out>, opts: RollingDispatchOptions<Out>): Promise<DispatchReport<Out>>;
-/**
- * Free worker slots under a simultaneity cap: `cap - live`, floored at 0, or `null` when there is
- * no cap (the conserved pool is then the only fence and "free slots" is not a finite number).
- * The one place the answer is computed, so the driver-facing tool payload and a dispatcher agree.
- */
-declare function freeSlots(liveCount: number, cap: number | undefined): number | null;
-/** Convenience: a `DispatchUnit` factory over a fixed array of tasks, for the common case where
- *  the queue is known up front and only the refill behavior is wanted. */
-declare function queueOf<Out>(units: ReadonlyArray<{
-  agent: Agent<unknown, Out>;
-  task: unknown;
-  label: string;
-}>, budget: Budget): () => DispatchUnit<Out> | undefined;
-//#endregion
 //#region src/runtime/supervise/prompt-registry.d.ts
 /**
  *
@@ -18614,6 +18600,190 @@ declare function runGraph(graph: AgentGraph, opts: RunGraphOptions): Promise<Gra
  *  entry accepts the same shape; this wrapper only keeps the `/testing` import path working. */
 declare function runGraphWithTestBrain(graph: AgentGraph, opts: RunGraphTestOptions): Promise<GraphResult>;
 //#endregion
+//#region src/runtime/supervise/designer-tools.d.ts
+/** How the ENVIRONMENT executes a graph the designer asked to run. */
+interface DesignerRunGraphEnv {
+  /** Run one graph (check already re-bound by {@link DesignerToolsEnv.bindCheck}). */
+  readonly runGraph: (graph: AgentGraph) => Promise<GraphResult>;
+  /** Attach the environment's deliverable check to an authored graph. */
+  readonly bindCheck: (graph: AgentGraph) => AgentGraph;
+}
+interface DesignerToolsEnv extends DesignerRunGraphEnv {
+  /** Workspace holding the graph registry (the sandbox's persistent volume). */
+  readonly registryDir: string;
+  /** Distinct run ids per inner run; default: `designer-<n>`. */
+  readonly nextRunId?: () => string;
+}
+interface GraphDesignerExtraTools {
+  readonly extraTools: ReadonlyArray<{
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+  }>;
+  /** The executeExtraTool contract: answers ONLY these tools, null otherwise. */
+  readonly executeExtraTool: (name: string, args: unknown) => Promise<unknown> | unknown;
+}
+/** The designer's three tools over one registry. Record-every-run is enforced
+ *  by construction: running IS recording. */
+declare function graphDesignerExtraTools(env: DesignerToolsEnv): GraphDesignerExtraTools;
+//#endregion
+//#region src/runtime/supervise/dispatch.d.ts
+/** One unit of queued work: the agent to run, its task, and the spawn options (budget + label).
+ *  `nextUnit` mints these lazily so a queue can be generated, re-ordered, or grown while the
+ *  dispatcher runs. */
+interface DispatchUnit<Out> {
+  readonly agent: Agent<unknown, Out>;
+  readonly task: unknown;
+  readonly opts: SpawnOpts;
+}
+/** Why the dispatcher stopped admitting work. `drained` = the queue ran dry (the ordinary end);
+ *  `not-admitted` = the conserved pool or the depth ceiling refused a spawn; `stopped` = the
+ *  caller's `shouldStop` returned true; `aborted` = the scope's signal fired. */
+type DispatchStopReason = 'drained' | 'not-admitted' | 'stopped' | 'aborted';
+interface RollingDispatchOptions<Out> {
+  /**
+   * How many children to hold in flight. Must be a positive integer. This is a SIMULTANEITY fence
+   * only — the conserved pool still bounds total work, and a `width` larger than the pool can
+   * afford simply hits `not-admitted` sooner.
+   */
+  readonly width: number;
+  /**
+   * Produce the next unit of work, or `undefined` when the queue is dry. Called only when a slot
+   * is free, so a caller may compute the next unit from what has already settled (the point of a
+   * refilling dispatcher: the queue is allowed to react). Never called after a stop.
+   */
+  nextUnit(): DispatchUnit<Out> | undefined | Promise<DispatchUnit<Out> | undefined>;
+  /**
+   * Called once per settlement, in cursor order, BEFORE the freed slot is refilled — so an
+   * `onSettled` that appends to the caller's queue is visible to the very next `nextUnit`.
+   */
+  onSettled?(settled: Settled<Out>): void | Promise<void>;
+  /**
+   * Consulted before each admission. `true` stops admitting; the already-live children are still
+   * drained to completion (no orphan, no lost settlement). Use it for a progress/plateau rule.
+   */
+  shouldStop?(): boolean;
+}
+interface DispatchReport<Out> {
+  /** Every settlement, in the order `scope.next()` yielded them. */
+  readonly settled: ReadonlyArray<Settled<Out>>;
+  /** How many children this dispatcher admitted. */
+  readonly admitted: number;
+  /** Admission rejections, in order — `label: reason`. Non-empty ⇒ the pool or depth fenced. */
+  readonly rejected: ReadonlyArray<string>;
+  readonly stopReason: DispatchStopReason;
+  /** The highest simultaneous live count actually reached — the number to compare against
+   *  `width` when asking "did the slots really stay full?" */
+  readonly peakLive: number;
+}
+/**
+ * Run the refilling dispatch loop over `scope` until the queue is dry (or a stop fires) and every
+ * admitted child has settled. Returns the settlements in cursor order plus the admission ledger.
+ *
+ * The loop is: fill free slots from `nextUnit` → `await scope.next()` → deliver the settlement →
+ * refill → repeat. Because the refill happens immediately after each settlement rather than after
+ * a whole round, a slow child never idles the other slots.
+ */
+declare function rollingDispatch<Out>(scope: Scope<Out>, opts: RollingDispatchOptions<Out>): Promise<DispatchReport<Out>>;
+/**
+ * Free worker slots under a simultaneity cap: `cap - live`, floored at 0, or `null` when there is
+ * no cap (the conserved pool is then the only fence and "free slots" is not a finite number).
+ * The one place the answer is computed, so the driver-facing tool payload and a dispatcher agree.
+ */
+declare function freeSlots(liveCount: number, cap: number | undefined): number | null;
+/** Convenience: a `DispatchUnit` factory over a fixed array of tasks, for the common case where
+ *  the queue is known up front and only the refill behavior is wanted. */
+declare function queueOf<Out>(units: ReadonlyArray<{
+  agent: Agent<unknown, Out>;
+  task: unknown;
+  label: string;
+}>, budget: Budget): () => DispatchUnit<Out> | undefined;
+//#endregion
+//#region src/runtime/supervise/graph-registry.d.ts
+/** A graph as stored: every axis serializable; the check re-bound at replay. */
+interface StoredGraph {
+  readonly digest: string;
+  readonly nodes: ReadonlyArray<{
+    readonly id: string;
+    readonly profile: AgentProfile;
+  }>;
+  readonly edges: ReadonlyArray<GraphEdge>;
+  readonly budget: AgentGraph['budget'];
+  readonly deliverable: {
+    readonly describe?: string;
+    readonly checkRef?: string;
+  };
+}
+/** One completed run of one graph, for one task shape. */
+interface GraphRunRecord {
+  /** Content-address of the exact graph that ran. */
+  readonly graphDigest: string;
+  /** Digest of the normalized task shape the designer computed for lookup. */
+  readonly taskDigest: string;
+  readonly startedAt: string;
+  readonly finishedAt: string;
+  readonly outcome: {
+    readonly kind: 'delivered';
+    readonly summary?: string;
+  } | {
+    readonly kind: 'no-winner';
+    readonly reason?: string;
+  };
+  /** Cost from the run's terminal accounting. Unknown channels omitted. */
+  readonly cost: {
+    readonly iterations?: number;
+    readonly tokens?: number;
+    readonly usd?: number;
+    readonly ms?: number;
+  };
+  /** Ledger size + exhausted edges: the trace's shape, for the designer's read. */
+  readonly traversals: number;
+  readonly exhaustedEdges?: ReadonlyArray<string>;
+}
+interface GraphRegistryDir {
+  readonly root: string;
+}
+/** Digest of the exact graph (nodes + edges + budget + deliverable describe). */
+declare function graphDigest(graph: Omit<StoredGraph, 'digest'>): string;
+/** Digest of the normalized task shape a designer looks records up by. */
+declare function taskShapeDigest(taskShape: Record<string, unknown>): string;
+/** Digest of a runnable graph exactly as the registry stores it — the value
+ *  `recordGraphRun` demands. Callers recording real runs hash through this,
+ *  never hand-rolled, so a record always matches its graph. */
+declare function digestOfGraph(graph: AgentGraph): string;
+/** Open (or lazily create) a registry rooted at a workspace directory. The
+ *  directory is the sandbox workspace; snapshots carry it across runs. */
+declare function graphRegistry(root: string): GraphRegistryDir;
+/** Append one run record; the exact graph is content-addressed beside it.
+ *  Idempotent per (taskDigest, graphDigest, startedAt): a replayed append with
+ *  the same key replaces the prior row rather than duplicating it. */
+declare function recordGraphRun(reg: GraphRegistryDir, graph: AgentGraph, record: GraphRunRecord): Promise<StoredGraph>;
+/** All records, newest last. */
+declare function listGraphRuns(reg: GraphRegistryDir): Promise<GraphRunRecord[]>;
+/** Records for one task shape, newest last. */
+declare function graphRunsFor(reg: GraphRegistryDir, taskDigest: string): Promise<GraphRunRecord[]>;
+type GraphSelection = {
+  readonly kind: 'replay';
+  readonly graph: StoredGraph;
+  readonly record: GraphRunRecord;
+} | {
+  readonly kind: 'author';
+  readonly reason: string;
+};
+/** The documented heuristic: delivered beats failed; among delivered, cheaper
+ *  (tokens, then iterations) wins; ties go to the most recent. */
+declare function pickBestGraph(records: ReadonlyArray<GraphRunRecord>): GraphRunRecord | undefined;
+/** Load a stored graph by digest. */
+declare function loadGraph(reg: GraphRegistryDir, digest: string): Promise<StoredGraph | undefined>;
+/** The designer's lookup: replay the known-good graph for this task shape, or
+ *  author a new one — with the reason stated either way (the decision is data). */
+declare function lookupGraph(reg: GraphRegistryDir, taskDigest: string): Promise<GraphSelection>;
+/** Rehydrate a stored graph into a runnable one. The check comes from the
+ *  CALLER's environment (oracles are environment, never stored). */
+declare function graphFromStored(stored: StoredGraph, check: AgentGraph['deliverable']['check']): AgentGraph;
+/** Digests present on disk (integrity probe for tests and audits). */
+declare function storedGraphDigests(reg: GraphRegistryDir): Promise<string[]>;
+//#endregion
 //#region src/runtime/supervise/in-place-cli-executor.d.ts
 /** @experimental */
 interface InPlaceCliExecutorOptions {
@@ -18841,6 +19011,55 @@ interface PatchDeliverableOptions extends CoderCheckConstraints {
  */
 declare function patchDelivered(options?: PatchDeliverableOptions): DeliverableSpec<WorktreePatchArtifact>;
 //#endregion
+//#region src/runtime/supervise/profile-registry.d.ts
+/** One completed run of one exact profile revision, under its stable NAME. */
+interface ProfileRunRecord {
+  /** The profile's stable name — the registry key (routing identity). */
+  readonly name: string;
+  /** Canonical digest of the EXACT profile revision that ran. */
+  readonly profileDigest: string;
+  readonly startedAt: string;
+  readonly finishedAt: string;
+  readonly outcome: {
+    readonly kind: 'delivered';
+    readonly summary?: string;
+  } | {
+    readonly kind: 'failed';
+    readonly reason?: string;
+  };
+  readonly cost: {
+    readonly iterations?: number;
+    readonly tokens?: number;
+    readonly usd?: number;
+  };
+  /** Where this run came from — a graph run id, a product surface, a bench. */
+  readonly origin?: string;
+}
+interface ProfileRegistryDir {
+  readonly root: string;
+}
+/** Open (or lazily create) a profile registry rooted at a workspace directory. */
+declare function profileRegistry(root: string): ProfileRegistryDir;
+/** Record one run and persist the exact profile revision beside it. The
+ *  record's digest must match the supplied profile — a record always names
+ *  the revision that actually ran. The revision file is write-once: a
+ *  different profile under the same digest is refused. */
+declare function recordProfileRun(reg: ProfileRegistryDir, profile: AgentProfile, record: ProfileRunRecord): Promise<void>;
+/** All records for one name, newest last. */
+declare function profileRunsForName(reg: ProfileRegistryDir, name: string): Promise<ProfileRunRecord[]>;
+/** The best revision of a name by the same documented heuristic as the graph
+ *  registry: delivered beats failed, then cheaper (tokens, then iterations),
+ *  then most recent. This is the answer to "which prompt revision is winning?"
+ *  — and every alternative is a controlled diff away (versions never overwrite). */
+declare function pickBestProfile(records: ReadonlyArray<ProfileRunRecord>): ProfileRunRecord | undefined;
+/** Load a stored profile revision by digest (for replaying the winning revision). */
+declare function loadProfile(reg: ProfileRegistryDir, digest: string): Promise<AgentProfile | undefined>;
+/** The winning revision of a name, ready to mount. */
+declare function bestProfileFor(reg: ProfileRegistryDir, name: string): Promise<{
+  profile: AgentProfile;
+  record: ProfileRunRecord;
+} | undefined>;
+//#endregion
 //#region src/runtime/supervise/provision-supervisor.d.ts
 /** Caller-supplied environment provider for one supervisor run. */
 interface ProvisionSupervisorConnection {
@@ -19502,5 +19721,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 $, LoopTeardownFailedPayload as $C, RecoverRetainedRunIntentOptions as $S, ProviderWorkspaceRetentionPort as $_, InProcessSandboxClientOptions as $a, DelegationTraceCaps as $b, createSupervisorSpanRecorder as $c, BudgetViolation as $d, SpendGap as $f, SandboxToolPartState as $g, createSteerableSandboxSession as $h, BenchmarkReport as $i, CoordinationTransportOptions as $l, SpawnPreflightContext as $m, filterAuthoredAsserts as $n, WinnerStrategy as $o, DriverFailureClass as $p, claimRetainedInteractiveControl as $r, PursuitObserverDelivery as $s, formatPromptHandle as $t, GroupOf as $u, FleetWorkspaceExecutorOptions as $v, sandboxSessionTraceSource as $x, delegationProfiles as $y, readWorkerInteractiveBinding as A, ReservationShortfall as AC, resolveRedactor as AS, PlacementInfo as A_, LoopDispatchOptions as Aa, buildRuntimeEventOtelSpans as Ab, WorkerSpawnRetryAttempt as Ac, D1DatabaseLike as Ad, ResourceLimit as Af, CodexStoreDelta as Ag, DelegateArgs as Ah, renderCorpusToInstructions as Ai, StopRule as Al, DefinedAnalystRecord as Am, ProfileRichnessThresholds as An, LoopUntilState as Ao, HarnessTranscriptArtifact as Ap, Deliverable as Ar, declaredCheckJudge as As, InPlaceCliExecutorOptions as At, supervisorRunsRoot as Au, ToolLoopCallContext as Av, AgentTaskStatus as Aw, isPeerMailEnvelope as Ax, DelegateResearchArgs as Ay, copyUntrackedIntoClone as B, ExecCtx as BC, RetainedRunAdmissionError as BS, resolveAgentEnvironmentProvider as B_, defaultSelectWinner as Ba, RuntimeStreamEventSink as Bb, SeatStage as Bc, SpawnForestInDoubtNode as Bd, RootSegmentEntry as Bf, SharedBoxCloseReceipt as Bg, ExecutorConfig as Bh, RegistryAnalyzeProjection as Bi, UNPROVEN_CONTINUITY as Bl, ManagerWake as Bm, CheckSource as Bn, ScopeAnalyzeInput as Bo, HarnessTranscriptMetadata as Bp, SandboxLineageHandle as Br, PursuitVersionChain as Bs, RunGraphTestOptions as Bt, workerSteerRequestFile as Bu, CoderDelegate as Bv, RuntimeSessionStore as Bw, BusStats as Bx, DelegationHistoryEntry as By, AuthoredHarness as C, BudgetPoolRestore as CC, distillFindings as CS, AgentTurnResult$2 as C_, defineStrategy as Ca, OtelExportConfig as Cb, SuperviseRegistry as Cc, WaterfallReport as Cd, NodeId as Cf, secretEnvOfMcpServer as Cg, McpServer as Ch, builtinShapes as Ci, NoProgressForOptions as Cl, BlockedToolReport as Cm, ChatTransportTool as Cn, Fanout as Co, ReconnectRetainedInteractiveRunOptions as Cp, MaterializeLocalMcpOptions as Cr, DeclaredCheck as Cs, createWorktreeCliExecutor as Ct, readWorkerCancellation as Cu, harnessSupportsReasoningEffort as Cv, AgentExecutionBackend as Cw, PeerMailReadout as Cx, SubmitOutput as Cy, WorkerInteractiveBinding as D, ReservationFloor as DC, verdictFromJudgeScore as DS, ExecRequest as D_, sample as Da, RuntimeEventOtelOptions as Db, superviseWithTestBrain as Dc, SqlRunOwnershipError as Dd, ProviderModelAttemptEvidence as Df, CodexRolloutStoreReader as Dg, DELEGATE_DESCRIPTION as Dh, runPersonified as Di, ProgressTrackerOptions as Dl, CoordinationStats as Dm, createChatSessionStore as Dn, FlatWidenGate as Do, RetainedInteractiveRunHandle as Dp, StdioMcpServerSpec as Dr, checkProgramDigest as Ds, InteractiveWorkerResult as Dt, runCancellationFile as Du, RouterResponseReceipt as Dv, AgentTaskContext as Dw, PeerMailboxOptions as Dx, DelegateCodeResult as Dy, AttachWorkerOptions as E, LeakedReservation as EC, passedItems as ES, CreateAgentEnvironmentInput$1 as E_, runAgentic as Ea, OtelSpan as Eb, supervise as Ec, SqlRunLease as Ed, ProfileMaterializationReceipt as Ef, CodexRolloutSession as Eg, createMcpServer as Eh, definePersona as Ei, ProgressTracker as El, CoordinationEvent as Em, chatWorkerSeam as En, FanoutWinnerSelector as Eo, RetainedInteractiveEnvironmentInput as Ep, StdioMcpConnection as Er, assertDeclaredCheck as Es, InteractiveWorkerOptions as Et, runCancelRequestFile as Eu, runLocalHarness as Ev, AgentRuntimeEventSink as Ew, PeerMailbox as Ex, DelegateCodeConfig as Ey, closingWorkerNote as F, createBudgetPool as FC, JudgeError as FS, ResourceRequest as F_, loopDispatch as Fa, padSpanId as Fb, retryPreSpawnRefusals as Fc, FileSpawnJournal as Fd, RetainedExecutionState as Ff, HarnessUsage as Fg, validateDelegateArgs as Fh, pipeline as Fi, noProgressFor as Fl, EscalateQuestion as Fm, supervisorInstructions as Fn, Pipeline as Fo, HarnessTranscriptUnavailableReason as Fp, SandboxRunAbortError as Fr, IsolatedCheckResult as Fs, GraphEdge as Ft, workerControlLogFile as Fu, ToolLoopToolCall as Fv, OpenAIChatToolChoice as Fw, McpToolAnnotations as Fx, DelegateUiAuditResult as Fy, WorkspaceCommit as G, LoopIterationEndedPayload as GC, DEFAULT_CHECK_IN_IDLE_MS as GS, ProviderCheckpointCaptureContext as G_, SandboxEvidenceRetentionError as Ga, createRuntimeEventCollector as Gb, RunContextLease as Gc, materializeTreeView as Gd, Settled as Gf, SharedBoxStats as Gg, cliInPlaceExecutor as Gh, observationFromRegistry as Gi, SupervisorFinalizer as Gl, QuestionEscalationTarget as Gm, StructuralRolloutPolicy as Gn, TrajectoryReportFn as Go, resolveHarnessTranscriptCapture as Gp, S3PrivateCasStore as Gr, VersionVerdict as Gs, PromptHandle as Gt, CompletionEvidence as Gu, DetachedWinnerSelection as Gv, defaultToolDetectors as Gx, DelegationStatus as Gy, GitWorkspaceOptions as H, LoopDecisionPayload as HC, RuntimeRunStateError as HS, SandboxControlClient as H_, runAgentRounds as Ha, RuntimeTelemetryOptions as Hb, InMemoryRunContext as Hc, SpawnForestNode as Hd, RootStreamReceipt as Hf, SharedBoxPlacement as Hg, RouterSeam as Hh, buildSteerContext as Hi, DeliveredOutput as Hl, QuestionDecision as Hm, RepairStop as Hn, SteerContext as Ho, HarnessTranscriptReadOptions as Hp, createSandboxLineage as Hr, PursuitVersions as Hs, defaultEdgeTraversalCap as Ht, workerSteersDir as Hu, CoderReviewer as Hv, PublishOptions as Hx, DelegationProfile as Hy, composeWorkerEvidence as I, spendFromUsageEvents as IC, NotFoundError as IS, WorkspaceRequest as I_, superviseDispatch as Ia, padTraceId as Ib, withWorkerSpawnRetry as Ic, InMemoryResultBlobStore as Id, RootHandle as If, decodeHarnessUsage as Ig, CliInPlaceSeam as Ih, selectValidWinner as Ii, plateau as Il, EventAcknowledgement as Im, CheckExecChannel as In, PipelineStage as Io, ReadableEnvironment as Ip, TurnResult as Ir, runIsolatedCheck as Is, GraphEdgeCapError as It, workerInboxFile as Iu, FeedbackEvent as Iv, RunAgentTaskOptions as Iw, McpToolDescriptor$1 as Ix, DelegateUiAuditRoute as Iy, jjWorkspace as J, LoopPlanDescription as JC, createWorkerSlots as JS, ProviderWorkspaceCaptureProvenance as J_, LocalSandboxClientOptions as Ja, sanitizeKnowledgeReadinessReport as Jb, withRunContext as Jc, Agent as Jd, SpawnOpts as Jf, sharedBoxRefusal as Jg, createExecutorRegistry as Jh, createMcpEnvironment as Ji, pickBestDelivered as Jl, QuestionPolicy as Jm, canDisplace as Jn, VerifySpec as Jo, DriverAttemptStop as Jp, reconnectRetainedRun as Jr, SupervisePursuitOptions as Js, analyzesFindingsReportPrompt as Jt, completionAuthorizes as Ju, coderTaskFromArgs as Jv, SessionTraceBox as Jx, FeedbackRating as Jy, WorkspaceRun as K, LoopIterationStartedPayload as KC, DeadlineCheckIn as KS, ProviderNativeCapturePhase as K_, SandboxEvidenceRetentionPort as Ka, createRuntimeStreamEventCollector as Kb, createFileRunContext as Kc, replaySpawnTree as Kd, SpawnEvent as Kf, SharedWorkerIdentity as Kg, cliWorktreeExecutor as Kh, McpEndpoint as Ki, bestDelivered as Kl, QuestionLevel as Km, StructuralRolloutResult as Kn, TrajectoryReportOptions as Ko, retainHarnessTranscript as Kp, S3PrivateCasStoreOptions as Kr, assertPursuitVersions as Ks, PromptRegistry as Kt, CompletionPolicy as Ku, SettleDetachedCoderTurnOptions as Kv, watchTrace as Kx, DelegationStatusArgs as Ky, settledWorkerOut as L, AgentRunSpec as LC, PlannerError as LS, createAgentEnvironmentProviderRegistry as L_, RunAgentRoundsOptions as La, toOtelAttributes as Lb, SeatSegment as Lc, InMemorySpawnJournal as Ld, RootMaterialization as Lf, DEFAULT_SHARED_BOX_RESOURCES as Lg, CliSeam as Lh, verify as Li, sampleFromSettled as Ll, LeadMessage as Lm, CheckOutcome as Ln, RenderCorpusToInstructions as Lo, captureHarnessTranscript as Lp, openSandboxRun as Lr, JudgedPursuitVersion as Ls, GraphNode as Lt, workerInboxFileFromEventDir as Lu, FeedbackStore as Lv, RunAgentTaskStreamOptions as Lw, McpTransport as Lx, DelegationError as Ly, NOTE_MAX_CHARS as M, ReservationTicket as MC, AgentEvalErrorCode as MS, ProviderExecutorOptions as M_, SuperviseDispatchOptions as Ma, createOtelExporter as Mb, WorkerSpawnRetryPolicy as Mc, SqlAdapter as Md, ResultBlobStore as Mf, createCodexRolloutStoreReader as Mg, DelegateHandlerOptions as Mh, flatWidenGate as Mi, allWorkersStalled as Ml, DownMessageDeliveryAttempt as Mm, assessAuthoredProfile as Mn, PanelJudge as Mo, HarnessTranscriptEvidence as Mp, OpenSandboxRunOptions as Mr, IsolatedCheckBox as Ms, AgentGraph as Mt, workerCancelRequestsFile as Mu, ToolLoopCompaction as Mv, KnowledgeReadinessDecision as Mw, peerMailVerbNames as Mx, DelegateResearchResult as My, VERIFY_TAIL_CHARS as N, ReservationWaitRefused as NC, BackendTransportError as NS, ProviderLeafOut as N_, SuperviseOptionsForDispatch as Na, generateSpanId as Nb, isPreSpawnExecutorFailure as Nc, d1ToSqlAdapter as Nd, ResumedKeyState as Nf, harnessUsageIsEmpty as Ng, DelegateResult as Nh, loopUntil as Ni, anyOf as Nl, DownMessageDeliveryOutcome as Nm, defaultProfileRichnessThresholds as Nn, PanelSpec as No, HarnessTranscriptFile as Np, OpenSandboxRunPromptOptions as Nr, IsolatedCheckBoxEvidence as Ns, EdgeDeliveryOutcome as Nt, workerCancellationFile as Nu, ToolLoopCompactionOptions as Nv, OpenAIChatResponseFormat as Nw, JsonRpcMessage as Nx, DelegateUiAuditArgs as Ny, WorkerInteractiveProviderSource as O, ReservationHolder as OC, Redactor as OS, ExecResult as O_, sampleThenRefine as Oa, buildLoopOtelSpans as Ob, workerFromBackend as Oc, SqlRunStoreOptions as Od, ProviderModelExecutionEvidence as Of, CodexRolloutStoreRef as Og, DELEGATE_INPUT_SCHEMA as Oh, FileCorpus as Oi, ProgressView as Ol, CoordinationTools as Om, AuthoredProfile as On, LoopUntil as Oo, RetainedInteractiveStartMaterial as Op, connectStdioMcp as Or, declaredCheckDeliverable as Os, workerFromInteractiveProvider as Ot, safeWorkerFile as Ou, RouterTransportConfig as Ov, AgentTaskRunResult as Ow, claimsAuthority as Ox, DelegateFeedbackArgs as Oy, WorkerEvidenceInput as P, ReserveOptions as PC, ConfigError as PS, ProviderPromptOptions as P_, loopCampaignDispatch as Pa, loopEventToOtelSpan as Pb, resolveWorkerSpawnRetry as Pc, FileResultBlobStore as Pd, ResumedWork as Pf, readCodexRolloutSession as Pg, createDelegateHandler as Ph, panel as Pi, createProgressTracker as Pl, DownMessageEvent as Pm, profileRichnessFinding as Pn, PanelVerdict as Po, HarnessTranscriptUnavailable as Pp, SandboxRun as Pr, IsolatedCheckOptions as Ps, EdgeTraversal as Pt, workerCancellationsDir as Pu, ToolLoopMessageRecord as Pv, OpenAIChatTool as Pw, JsonRpcResponse as Px, DelegateUiAuditConfig as Py, analyzeTrace as Q, LoopStartedPayload as QC, ReconnectRetainedRunOptions as QS, ProviderWorkspaceRetentionContext as Q_, InProcessPromptCtx as Qa, DELEGATION_TRACE_MAX_SPANS as Qb, SupervisorSpanRecorder as Qc, BudgetOverspend as Qd, SpendChannel as Qf, SandboxServedBackend as Qg, SteerableSandboxSession as Qh, BenchmarkLift as Qi, CoordinationPublicAddress as Ql, SpawnPreflight as Qm, defaultStructuralRolloutPolicy as Qn, WidenSpec as Qo, DriverContractState as Qp, ClaimRetainedInteractiveControlOptions as Qr, RUN_FORK_CORRELATION_KEYS as Qs, dumbContinuationPassPrompt as Qt, AxisScoresOf as Qu, FleetHandle as Qv, decodeToolPart as Qx, UiAuditorDelegationOutput as Qy, CopyOptions as R, DefaultVerdict$1 as RC, RetainedInteractiveAdmissionError as RS, providerAsExecutor as R_, TERMINAL_DECISIONS as Ra, RuntimeEventCollector as Rb, SeatSelection as Rc, SpawnForest as Rd, RootProviderModelEvidence as Rf, DEFAULT_SHARED_BOX_WORKERS as Rg, CliWorktreeBridgeSeam as Rh, widen as Ri, ReentryContinuity as Rl, MakeWorkerAgent as Rm, CheckRunContext as Rn, RenderCorpusToInstructionsOptions as Ro, harnessTranscriptArtifact as Rp, BranchCapableBox as Rr, NextPursuitVersion as Rs, GraphResult as Rt, workerSteerAcknowledgementFile as Ru, InMemoryFeedbackStore as Rv, RuntimeCanonicalStreamEvent as Rw, BusEvent as Rx, DelegationFeedbackSnapshot as Ry, failuresAnalyst as S, BudgetPool as SC, checkVerdictOf as SS, AgentSessionStatus$1 as S_, breadthStrategy as Sa, OtelAttribute as Sb, SuperviseOptions as Sc, WaterfallCollector as Sd, NodeExecutionIdentity as Sf, resolveSecretEnv as Sg, resolveSpawnResourcePaths as Sh, trajectoryReport as Si, AllWorkersStalledOptions as Sl, AwaitWakeInput as Sm, ChatTransportExecutorOptions as Sn, EqualKVerdict as So, workerTraceSeamKey as Sp, LocalMcpMaterialization as Sr, defineLeaderboard as Ss, WorktreePatchArtifact as St, readWorkerCancelRequests as Su, RunLocalHarnessOptions as Sv, AgentBackendInput as Sw, PeerMailOutcome as Sx, SubmitInput as Sy, worktreeFanout as T, BudgetReconcileFault as TC, failedItems as TS, CheckpointRequest as T_, refine as Ta, OtelExporter as Tb, SuperviseTestOptions as Tc, createWaterfallCollector as Td, NodeStatus as Tf, CodexRolloutIdentity as Tg, createInProcessTransport as Th, registerShape as Ti, ProgressSample as Tl, ContinuityMode as Tm, chatTransportExecutor as Tn, FanoutSynthesis as To, RetainedInteractiveAdmissionHook as Tp, McpToolDescriptor as Tr, DeclaredCheckStateCapture as Ts, InteractiveWorkerKeyInput as Tt, readWorkerSteerRequests as Tu, parseCodexTokenUsage as Tv, AgentRuntimeEvent as Tw, PeerMailSendInput as Tx, DelegateCodeArgs as Ty, Shell as U, LoopEndedPayload as UC, ValidationError as US, createTangleSandboxExactProcessProvider as U_, SandboxEvidenceContext as Ua, SanitizedKnowledgeReadinessReport as Ub, InMemoryRunContextOptions as Uc, SpawnForestTree as Ud, Runtime as Uf, SharedBoxPlacementOptions as Ug, RouterToolsSeam as Uh, createScopeAnalyst as Ui, FinalizeContext as Ul, QuestionEscalationOutcome as Um, StructuralRolloutConfig as Un, TrajectoryNode as Uo, RetainedHarnessTranscriptCapture as Up, AcquireOptions as Ur, SettledPursuitVersion as Us, runGraph as Ut, writeWorkerSteer as Uu, DelegateRunCtx as Uv, createEventBus as Ux, DelegationProgress as Uy, withUntrackedArtifacts as V, Iteration as VC, RetainedRunDispatchBindingError as VS, CreateTangleSandboxExactProcessProviderOptions as V_, isTerminalDecision as Va, RuntimeStreamEventSummary as Vb, SelectSeat as Vc, SpawnForestMissingTree as Vd, RootSignal as Vf, SharedBoxHandle as Vg, ProviderSeam as Vh, assertTraceDerivedFindings as Vi, composeReentryTask as Vl, Question as Vm, CheckSourceCtx as Vn, ScopeWidenGate as Vo, HarnessTranscriptReadLimits as Vp, SessionCapableBox as Vr, PursuitVersionStop as Vs, TraversalContinuity as Vt, workerSteerRequestsDir as Vu, CoderReview as Vv, RuntimeStreamEvent as Vw, EventBus as Vx, DelegationHistoryResult as Vy, Workspace as W, LoopIterationDispatchPayload as WC, DEADLINE_CHECK_IN_MESSAGE as WS, UnavailablePausePolicy as W_, SandboxEvidenceReceipt as Wa, SanitizedKnowledgeRequirement as Wb, RunContext as Wc, loadSpawnForest as Wd, Scope as Wf, SharedBoxProcess as Wg, SandboxSeam as Wh, registryScopeAnalyst as Wi, FinalizerSettled as Wl, QuestionEscalationRecord as Wm, StructuralRolloutMessage as Wn, TrajectoryReport as Wo, RetainedHarnessTranscriptDescriptor as Wp, acquireSandbox as Wr, VersionJudge as Ws, runGraphWithTestBrain as Wt, CompletionAnalyst as Wu, DetachedSessionDelegateOptions as Wv, WatchTraceOptions as Wx, DelegationResultPayload as Wy, runInWorkspace as X, LoopResult as XC, NativeContextContinuationHandle as XS, ProviderWorkspaceCaptureResult as X_, inlineSandboxClient as Xa, CappedDelegationTrace as Xb, SupervisorSpanOptions as Xc, AgentSpec as Xd, SpawnRejection as Xf, SandboxLeafOut as Xg, SandboxSteeringOptions as Xh, BenchmarkCell as Xi, CoordinationAuthentication as Xl, QuestionUrgency as Xm, composeCheckSources as Xn, WidenDecision as Xo, DriverBudgetReadout as Xp, startRetainedRun as Xr, supervisePursuit as Xs, delegatesWorkerBriefPrompt as Xt, sentinelCompletion as Xu, settleDetachedCoderTurn as Xv, TraceSource as Xx, ResearchOutputShape as Xy, localShell as Y, LoopPlanPayload as YC, NativeContextContinuationExecution as YS, ProviderWorkspaceCaptureReceipt as Y_, localSandboxClient as Ya, sanitizeRuntimeStreamEvent as Yb, SupervisorSpanAttributes as Yc, AgentExecutionRef as Yd, SpawnPrior as Yf, sharedWorkerClientName as Yg, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Yh, sanitizeMcpToolSchema as Yi, runFinalizer as Yl, QuestionRecord as Ym, compareCheckOutcomes as Yn, Widen as Yo, DriverAttemptsExhaustedError as Yp, recoverRetainedRun as Yr, SupervisedPursuitResult as Ys, createPromptRegistry as Yt, deterministicCompletion as Yu, detachedSessionDelegate as Yv, ToolStepInput as Yx, FeedbackRefersTo as Yy, TrajectoryAnalysis as Z, LoopSandboxPlacement as ZC, NativeContextContinuationInput as ZS, ProviderWorkspaceEntryMetadata as Z_, InProcessOnPrompt as Za, DELEGATION_TRACE_MAX_BYTES as Zb, SupervisorSpanOutcome as Zc, Budget as Zd, Spend as Zf, SandboxOutputMarker as Zg, SteerableSandboxArgs as Zh, BenchmarkConfig as Zi, CoordinationMcpHandle as Zl, SettledWorker as Zm, defaultExtractCandidate as Zn, WidenLineage as Zo, DriverContinuationRecord as Zp, startRetainedRunInEnvironment as Zr, PursuitFork as Zs, dumbContinuationFailPrompt as Zt, stopSentinel as Zu, DelegationExecutor as Zv, createPushTraceSource as Zx, UiAuditLensFilter as Zy, boxSurfaceReader as _, RetainedRunSnapshot as _C, ContinuationProfile as _S, AgentEnvironmentStatus as __, StrategyMessage as _a, createPropagatingTraceEmitter as _b, verifyObserverRecords as _c, anytimeReport as _d, Handle as _f, KeyProvider as _g, SpawnResourceBytes as _h, PrivateCasDurableStore as _i, resolveSupervisorProfile as _l, AnalyzeOnSettleRoute as _m, CodeModeRunner as _n, CorpusFilter as _o, WorkerTraceResolver as _p, AuthoredStrategy as _r, LeaderboardIterationInfo as _s, SupervisorCleanupReceipt as _t, cancelWorker as _u, CodexTokenUsage as _v, RuntimeRunRow as _w, PEER_MAIL_WIRE_KEY as _x, DelegationResumeDriver as _y, SandboxInstance$1 as a, RetainedInteractiveStartedAdmission as aC, CONTINUATION_FACTS as aS, mapSandboxEvent as a_, AgenticOptions as aa, UiLens as ab, PursuitNodeTiming as ac, PairwiseVerdict as ad, ExecutorCancellationRequest as af, TeamProgress as ag, WorkerSpawnContext as ah, profileChatClient as ai, ObserveSupervisorNodeEvent as al, classifyDriverFailure as am, DispatchUnit as an, harvestCorpus as ao, SupervisorOpts as ap, structuralRollout as ar, PersonaContext as as, createRootHandle as at, CoordinationLog as au, WorktreeProfileMaterializationReceipt as av, MountRecorder as aw, createDelegationTraceCollector as ax, DetachedTurnResumeDriverOptions as ay, AnalystAuthoring as b, StartRetainedRunInEnvironmentOptions as bC, admitContinuationPolicy as bS, AgentSession as b_, SurfaceScore as ba, traceContextToEnv as bb, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as bc, plateauLength as bd, MaterializedModelIdentity as bf, mcpSecretEnvMetadataKey as bg, environmentReader as bh, createPrivateCasArtifactPort as bi, DEFAULT_DEADLINE_WARNING_MS as bl, AuthorizeDownMessage as bm, ChatCompletionsTransport as bn, EqualKOnCost as bo, workerTraceEnv as bp, strategyAuthorContract as br, LeaderboardScore as bs, patchDelivered as bt, readRunCancelRequest as bu, LocalHarness as bv, AgentAdapter as bw, PeerMailKind as bx, DelegationTaskQueue as by, VerifierEnvironmentOptions as c, RetainedRunCancelOptions as cC, CheckVerdict as cS, sandboxProgressEvents as c_, AgenticTask as ca, MultiHarnessResearcherFanoutOptions as cb, PursuitRunProjection as cc, leaderboard as cd, ExecutorFactory as cf, readWorkerProgress as cg, canonicalFindingEvent as ch, assertProfileModelsAllowed as ci, ResolvedSupervisorProfile as cl, RetainedPendingCause as cm, queueOf as cn, ObservationError as co, UnconfirmedTeardown as cp, EvolutionReport as cr, RunPersonifiedOptions as cs, SqlRunContextOptions as ct, PriorCoordination as cu, DiffResult as cv, SandboxClient as cw, DelegationStore as cx, RunDetachedTurnOptions as cy, HarvestSurfaceDiffsOptions as d, RetainedRunEffect as dC, ContinuationEntry as dS, AgentEnvironmentCapabilities$1 as d_, CorpusReadbackOptions as da, ResearchTask as db, projectPursuit as dc, renderLeaderboardMarkdown as dd, ExecutorProgressEvent as df, InboxMessage as dg, normalizeAnalyzeOnSettle as dh, AgentTurnUsage as di, SupervisorNodeContext as dl, AnalystDefinitionIssue as dm, defaultDelegateBudget as dn, defaultAnalystInstruction as do, WidenGate as dp, StrategyTournament as dr, ShapeRegistry as ds, ScopeArgs as dt, WorkerCancelRequest as du, WorktreeHandle as dv, Validator as dw, InMemoryDelegationStore as dx, formatDetachedSessionRef as dy, RecoverRetainedRunOptions as eC, DeliverableSpec as eS, SandboxUsageLedger as e_, BenchmarkStrategySummary as ea, UI_FINDING_SEVERITIES as eb, PursuitCostProvenance as ec, Interval as ed, EnvironmentTeardownReceipt as ef, ActivityLog as eg, SpawnRefusal as eh, reconnectRetainedInteractiveRun as ei, CoordinationBinding as el, DriverLoopRecord as em, kernelPromptRegistry as en, inProcessSandboxClient as eo, SteerableRootHandle as ep, modelAuthoredChecks as er, DefinePersona as es, WorkerToolTraceArtifact as et, serveCoordinationMcp as eu, ProviderPlacement as ev, LoopTokenUsage as ew, DelegationTraceCollector as ex, SiblingSandboxExecutorOptions as ey, SurfaceDiff as f, RetainedRunEnvironmentAdmission as fC, ContinuationNoteInput as fS, AgentEnvironmentEvent$1 as f_, RunAgenticOptions as fa, ResearcherProfileOptions as fb, FileObserverJournal as fc, renderLeaderboardSvg as fd, ExecutorRegistry as ff, PeerInboxMessage as fg, parseAuthoredAnalystDefinition as fh, CollectedAgentTurn as fi, SupervisorNodeContextSeed as fl, AnalystFindingEvent as fm, delegate as fn, observe as fo, WorkerInteractiveSession as fp, TournamentCell as fr, DefinedLeaderboard as fs, createScope as ft, WorkerCancellation as fu, captureWorktreeDiff as fv, RuntimeRunCompleteInput as fw, CoderOutput as fx, parseDetachedSessionRef as fy, WatchedSurface as g, RetainedRunReplayPoint as gC, ContinuationPolicy as gS, AgentEnvironmentQuery as g_, StrategyCtx as ga, TraceContext as gb, observerRecordDigest as gc, AnytimeTaskCurve as gd, FleetYield as gf, BridgeSeam as gg, SPAWN_RESOURCE_PATH_MAX_BYTES as gh, PrivateCasArtifactPort as gi, assertCoordinationBinding as gl, AnalystToolGroupName as gm, CodeModeOptions as gn, Corpus as go, WorkspaceCheckpointMarker as gp, AuthorStrategyOptions as gr, LeaderboardFlagSpec as gs, ProvisionedSupervisor as gt, cancelRun as gu, CodexExecutionPolicy as gv, RuntimeRunPersistenceAdapter as gw, DEFAULT_PEER_MAIL_LIMITS as gx, DelegationResumeContext as gy, SurfaceReader as h, RetainedRunIntentAdmission as hC, ContinuationPanelResult as hS, AgentEnvironmentProviderRegistry as h_, StrategyArtifacts as ha, researcherProfile as hb, ObserverRecordKind as hc, AnytimeStrategySummary as hd, ExecutorToolCall as hf, BridgeModelCredential as hg, ResolvedSpawnResourcePath as hh, streamAgentTurn as hi, SupervisorToolInvocationContext as hl, AnalystRegistry$1 as hm, finalizeBestDelivered as hn, CombinatorShape as ho, WorkerTraceUnavailableReason as hp, strategyTournament as hr, LeaderboardBenchmarkAdapter as hs, ProvisionSupervisorRequest as ht, WriteWorkerSteerOptions as hu, CodexExecutionEvidence as hv, RuntimeRunOptions as hw, AUTHORITY_MARKERS as hx, DelegationRecord as hy, SandboxEvent$1 as i, RetainedInteractiveIntentAdmission as iC, AdmittedFinding as iS, extractLlmCallEvent as i_, runBenchmark as ia, UiFindingSeverity as ib, PursuitNodeProjection as ic, PairwiseOptions as id, ExecutorCancellation as if, ScopeProgressInput as ig, WorkerResumeContext as ih, resolveSandboxClient as ii, DriveHarnessOwnerContext as il, DriverRetryPolicy as im, DispatchStopReason as in, HarvestReport as io, Supervisor as ip, selectBestIndex as ir, Persona as is, DEFAULT_MAX_DEPTH as it, CoordinationDeliveryEvidence as iu, WorktreeHarnessResult as iv, MountManifestEntry as iw, composeLoopTraceEmitters as ix, DetachedTurn as iy, EVIDENCE_MAX_CHARS as j, ReservationStage as jC, AgentEvalError$1 as jS, ProviderAsSandboxClientOptions as j_, LoopOptionsForDispatch as ja, createOpenInferenceFileExporter as jb, WorkerSpawnRetryHooks as jc, D1StmtLike as jd, ResourceSpend as jf, addHarnessUsage as jg, DelegateError as jh, fanout as ji, allOf as jl, DownMessageAuthorizationInput as jm, asAuthoredProfile as jn, Panel as jo, HarnessTranscriptCapture as jp, OpenSandboxRunBeforeStartContext as jr, readDeclaredCheck as js, createInPlaceCliExecutor as jt, supervisorWorkersDir as ju, ToolLoopChat as jv, BackendErrorDetail as jw, peerMailTools as jx, DelegateResearchConfig as jy, attachWorker as k, ReservationRejection as kC, defaultRedactor as kS, ForkRequest as k_, LoopCampaignDispatchOptions as ka, buildLoopSpanNodes as kb, ResolvedWorkerSpawnRetry as kc, openSqlRunStore as kd, RecursiveReservationPolicy as kf, CodexRolloutTurn as kg, DELEGATE_TOOL_NAME as kh, InMemoryCorpus as ki, StopDecision as kl, CoordinationToolsOptions as km, ProfileRichness as kn, LoopUntilSpec as ko, StartRetainedInteractiveRunOptions as kp, materializeLocalMcp as kr, declaredCheckDigest as ks, WorkerInteractiveAdmission as kt, supervisorRunDir as ku, ToolSpec as kv, AgentTaskSpec as kw, createPeerMailbox as kx, DelegateFeedbackResult as ky, createVerifierEnvironment as l, RetainedRunCancellation as lC, ContinuationAppend as lS, sumSandboxUsage as l_, AgenticTool as la, ResearchOutput as lb, PursuitRunTotals as lc, pairwiseSignificance as ld, ExecutorMaterialization as lf, AuthorityInboxMessage as lg, createCoordinationTools as lh, AgentTurnBackend as li, SupervisorAgentDeps as ll, ANALYST_DEFINITION_BOUNDS as lm, rollingDispatch as ln, ObserveInput as lo, UnknownMaterializationReason as lp, EvolutionStrategy as lr, ShapeBudget as ls, createFencedSqlRunContext as lt, RunCancelRequest as lu, GitRunner as lv, SelectionReceipt as lw, FileDelegationStore as lx, createDetachedTurnResumeDriver as ly, SurfaceReadOutcome as m, RetainedRunHandle as mC, ContinuationPanelInput as mS, AgentEnvironmentProviderRef as m_, Strategy as ma, multiHarnessResearcherFanout as mb, ObserverRecord as mc, AnytimeReport as md, ExecutorTeardownWarning as mf, BridgeHarnessStore as mg, ResolveSpawnResourcePathsResult as mh, collectAgentTurn as mi, SupervisorToolDescriptor as ml, AnalystLensOutput as mm, driverAgent as mn, AssertTraceDerivedFindings as mo, WorkerTraceEvidence as mp, runStrategyEvolution as mr, LeaderboardBenchTask as ms, ProvisionSupervisorConnection as mt, WorkerSteerRequest as mu, removeWorktree as mv, RuntimeRunHandle as mw, coderTaskToPrompt as mx, DelegationArgs as my, AnalystFinding$1 as n, RetainedInteractiveAdmission as nC, gateOnDeliverable as nS, createSandboxToolPartState as n_, Environment as na, UiFinding as nb, PursuitNodePlacement as nc, LeaderboardOptions as nd, Executor as nf, DEFAULT_STALL_AFTER_MS as ng, SuperviseProfileEntry as nh, startRetainedInteractiveRun as ni, CoordinationVerbs as nl, DriverReentry as nm, promptHandle as nn, HarvestError as no, SubtreeSummary as np, resolveEntrySymbol as nr, LoopShape as ns, parseWorkerToolTraceArtifact as nt, CoordinationHttpOptions as nu, WorktreeCheckRunner as nv, LoopTraceEvent as nw, buildDelegationTraceSpans as nx, createSiblingSandboxExecutor as ny, computeFindingId$1 as o, RetainedRunAdmission as oC, CheckRead as oS, mapSandboxToolEvent as o_, AgenticRunResult as oa, KnowledgeItem as ob, PursuitNodeUsage as oc, ProfileKeyOf as od, ExecutorContext as of, WorkerProgress as og, WorkerWatchOptions as oh, profileOptimizerModelCall as oi, ResolveDriveHarness as ol, summarizeDriverAttempts as om, RollingDispatchOptions as on, Observation as oo, TokenUsageProvenance as op, visibleCheckScore as or, PersonaExecutors as os, createSupervisor as ot, CoordinationOwnerId as ou, CreateWorktreeOptions as ov, OutputAdapter as ow, DelegationPersistenceError as ox, DriveTurnCapableBox as oy, SurfaceReadBox as p, RetainedRunEventOptions as pC, ContinuationPanel as pS, AgentEnvironmentProvider$1 as p_, ShotSpec as pa, createResearcherValidator as pb, ObserverJournal as pc, renderPairwiseMarkdown as pd, ExecutorResult as pf, createInbox as pg, questionEscalationTargets as ph, StreamAgentTurnOptions as pi, SupervisorProfile as pl, AnalystKind as pm, DriverAgentOptions as pn, renderReport as po, WorkerInteractiveUnavailableReason as pp, TournamentRow as pr, LeaderboardBenchScore as ps, settledToIteration as pt, WorkerSteerAcknowledgement as pu, createWorktree as pv, RuntimeRunCost as pw, CoderTask as px, runDetachedTurn as py, gitWorkspace as q, LoopLineageOptions as qC, WorkerSlots as qS, ProviderWorkspaceAttemptProvenance as q_, captureBeforeDestroy as qa, sanitizeAgentRuntimeEvent as qb, createInMemoryRunContext as qc, contentAddress as qd, SpawnJournal as qf, sharedBoxPlacement as qg, createExecutor as qh, McpEnvironmentOptions as qi, collectDelivered as ql, QuestionOption as qm, VisibleCheck as qn, Verify as qo, DriverAttemptRecord as qp, createS3PrivateCasStore as qr, SupervisePursuitError as qs, RegisteredPrompt as qt, CompletionVerdict as qu, UiAuditorDelegate as qv, SessionMessageLike as qx, DelegationStatusResult as qy, CreateSandboxOptions$1 as r, RetainedInteractiveEnvironmentAdmission as rC, mapExecutorResult as rS, createSandboxUsageLedger as r_, printBenchmarkReport as ra, UiFindingScreenshot as rb, PursuitNodePlatform as rc, LeaderboardRow as rd, ExecutorAccounting as rf, ExecutorProgress as rg, ToolOutcomeEvent as rh, ResolveSandboxClientOptions as ri, DriveHarness as rl, DriverRepromptRefusal as rm, DispatchReport as rn, HarvestFailure as ro, SupervisedResult as rp, sandboxCheckRunner as rr, Outcome as rs, workerTraceAnalysisStore as rt, CoordinationRejectReason as ru, WorktreeCommandResult as rv, LoopWinner as rw, capDelegationTrace as rx, DetachedSessionRefParts as ry, makeFinding$1 as s, RetainedRunAdmissionHook as sC, CheckUnavailableError as sS, sandboxEventServedBackend as s_, AgenticSurface as sa, KnowledgeUpdate as sb, PursuitProjection as sc, ScoreOf as sd, ExecutorExecutionBinding as sf, createActivityLog as sg, analystToolGroupNames as sh, assertModelAllowed as si, ResolveSupervisorTools as sl, upstreamUnavailableSignal as sm, freeSlots as sn, ObservationAnalysis as so, TreeView as sp, EvolutionAuthor as sr, RunPersonified as ss, FencedSqlRunContext as st, FileCoordinationLog as su, DiffOptions as sv, RunProvenance as sw, DelegationStateCorruptError as sx, DriveTurnTick as sy, AgentProfile$2 as t, RecoverRetainedRunResult as tC, ExecutorResultMapping as tS, assertSandboxServedModel as t_, BenchmarkTaskRow as ta, UI_LENSES as tb, PursuitNodeCost as tc, Leaderboard as td, ExecutionBindingReceipt as tf, ActivityNote as tg, SpawnRefusalCause as th, recoverRetainedInteractiveRun as ti, CoordinationToolFace as tl, DriverProgressMark as tm, naiveContinuationPrompt as tn, HarvestCorpusOptions as to, SubtreeResult as tp, officialChecksFromMeta as tr, DefinePersonaInput as ts, captureWorkerTraceEvidence as tt, CoordinationHttpAudit as tu, InPlaceHarnessResult as tv, LoopTraceEmitter as tw, DelegationTraceSpan as tx, createFleetWorkspaceExecutor as ty, BoxSurfaceReaderOptions as u, RetainedRunDispatchedAdmission as uC, ContinuationContext as uS, AgentEnvironment$1 as u_, ArtifactHandle as ua, ResearchSource as ub, PursuitStatus as uc, renderLeaderboardHtml as ud, ExecutorNodeContext as uf, Inbox as ug, downMessageRefusalReasons as uh, AgentTurnInput$1 as ui, SupervisorAgentTestDeps as ul, AnalystAssignmentRecord as um, DelegateOptions as un, ObserveOptions as uo, UsageEvent as up, StrategyEvolutionConfig as ur, ShapeContext as us, SUBTREE_RESULT_LIMIT as ut, RunCancellation as uu, RemoveWorktreeOptions as uv, ValidationCtx as uw, FileDelegationStoreOptions as ux, detachedTurnEvents as uy, fsSurfaceReader as v, RetainedRunStartMaterial as vC, PanelFinding as vS, AgentEnvironmentSummary as v_, StrategyResult as va, mergeTraceEnv as vb, AuthorizedSpawn as vc, areaUnderCurve as vd, HeldEnvironment as vf, ResolvedMcpServerLaunch as vg, SpawnResourceRead as vh, PrivateCasOffloadReport as vi, supervisorAgent as vl, AuthoredAnalystDefinition as vm, codeModeSupervisorTools as vn, CorpusRecord as vo, WorkerTraceSeamCarrier as vp, assertStrategyContract as vr, LeaderboardRunContext as vs, provisionSupervisor as vt, legacySupervisorRunDir as vu, DEFAULT_LOCAL_HARNESS as vv, RuntimeRunStatus as vw, PeerMailEnvelope as vx, DelegationResumeTick as vy, WorktreeFanoutOptions as w, BudgetReadout as wC, expandQuestions as wS, CheckpointRef as w_, depthStrategy as wa, OtelExportStats as wb, SuperviseRegistryTable as wc, WaterfallSpan as wd, NodeSnapshot as wf, CodexForkBoundary as wg, McpServerOptions as wh, createShapeRegistry as wi, PlateauOptions as wl, ContinuationInstruction as wm, ChatWorkerSeamOptions as wn, FanoutOptions as wo, RecoverRetainedInteractiveRunOptions as wp, McpSpawnFault as wr, DeclaredCheckPlacement as ws, InteractiveWorkerEnvironment as wt, readWorkerSteerAcknowledgement as wu, localHarnessExecutable as wv, AgentKnowledgeProvider as ww, PeerMailRefusal as wx, hashIdempotencyInput as wy, analystsFromRegistry as x, StartRetainedRunOptions as xC, admitFinding as xS, AgentSessionRef as x_, adaptiveRefine as xa, LoopSpanNode as xb, DeliverableResolutionInput as xc, renderAnytimeTable as xd, NoWinnerError as xf, resolveMcpServerLaunch as xg, hostDirectoryReader as xh, equalKOnCost as xi, ManagerWakePolicy as xl, AuthorizedDownMessage as xm, ChatSessionStore as xn, EqualKOnCostOptions as xo, workerTraceHeaders as xp, strategyAuthorSystemPrompt as xr, LeaderboardSpec as xs, WorktreeCliExecutorOptions as xt, readRunCancellation as xu, LocalHarnessResult as xv, AgentBackendContext as xw, PeerMailLimits as xx, DelegationTaskQueueOptions as xy, harvestSurfaceDiffs as y, RetainedRunTurnInput as yC, VerdictSummary as yS, AgentProfileRef as y_, StrategyShotResult as ya, readTraceContextFromEnv as yb, AuthorizedSpawnContext as yc, bestSoFar as yd, MaterializedExecutionIdentity as yf, envKeyProvider as yg, SpawnResourceReader as yh, PrivateCasOptions as yi, supervisorAgentWithTestBrain as yl, AuthoredAnalystLimits as ym, unsafeInProcessRunner as yn, EqualKArm as yo, readWorkerTraceContext as yp, authorStrategy as yr, LeaderboardScenario as ys, PatchDeliverableOptions as yt, legacySupervisorRunsRoot as yu, LOCAL_HARNESSES as yv, startRuntimeRun as yw, PeerMailEvent as yx, DelegationRunContext as yy, UntrackedCopyStats as z, Driver as zC, RetainedInteractiveBindingError as zS, providerAsSandboxClient as z_, TerminalDecision as za, RuntimeStreamEventCollector as zb, SeatSelectionInput as zc, SpawnForestEvent as zd, RootSegment as zf, ROUTER_CLIENT_HEADER as zg, CliWorktreeSeam as zh, CreateScopeAnalystOptions as zi, ReentryTaskInput as zl, ManagerReentryState as zm, CheckRunner as zn, ScopeAnalyst as zo, persistHarnessTranscript as zp, SandboxLineage as zr, NextPursuitVersionInput as zs, RunGraphOptions as zt, workerSteerAcknowledgementsDir as zu, eventToSnapshot as zv, RuntimeSession as zw, BusRecord as zx, DelegationHistoryArgs as zy };
-//# sourceMappingURL=index-CUh40yUJ.d.ts.map
+export { WORKER_TOOL_TRACE_SCHEMA_VERSION as $, RetainedRunStartMaterial as $C, PanelFinding as $S, ForkRequest as $_, LoopCampaignDispatchOptions as $a, mergeTraceEnv as $b, ResolvedWorkerSpawnRetry as $c, openSqlRunStore as $d, RecursiveReservationPolicy as $f, CodexRolloutTurn as $g, DELEGATE_TOOL_NAME as $h, InMemoryCorpus as $i, StopDecision as $l, CoordinationToolsOptions as $m, ProfileRichness as $n, LoopUntilSpec as $o, StartRetainedInteractiveRunOptions as $p, materializeLocalMcp as $r, declaredCheckDigest as $s, recordGraphRun as $t, supervisorRunDir as $u, ToolSpec as $v, RuntimeRunStatus as $w, PeerMailEnvelope as $x, DelegationResumeTick as $y, readWorkerInteractiveBinding as A, NativeContextContinuationExecution as AC, ToolStepInput as AS, mapSandboxToolEvent as A_, AgenticRunResult as Aa, FeedbackRefersTo as Ab, PursuitNodeUsage as Ac, ProfileKeyOf as Ad, ExecutorContext as Af, WorkerProgress as Ag, WorkerWatchOptions as Ah, profileOptimizerModelCall as Ai, ResolveDriveHarness as Al, summarizeDriverAttempts as Am, createPromptRegistry as An, Observation as Ao, TokenUsageProvenance as Ap, visibleCheckScore as Ar, PersonaExecutors as As, WorktreePatchArtifact as At, CoordinationOwnerId as Au, CreateWorktreeOptions as Av, LoopPlanPayload as Aw, sanitizeRuntimeStreamEvent as Ax, detachedSessionDelegate as Ay, copyUntrackedIntoClone as B, RetainedInteractiveStartedAdmission as BC, CONTINUATION_FACTS as BS, AgentEnvironmentQuery as B_, StrategyCtx as Ba, UiLens as Bb, observerRecordDigest as Bc, AnytimeTaskCurve as Bd, FleetYield as Bf, BridgeSeam as Bg, SPAWN_RESOURCE_PATH_MAX_BYTES as Bh, PrivateCasArtifactPort as Bi, assertCoordinationBinding as Bl, AnalystToolGroupName as Bm, delegate as Bn, Corpus as Bo, WorkspaceCheckpointMarker as Bp, AuthorStrategyOptions as Br, LeaderboardFlagSpec as Bs, GraphRegistryDir as Bt, cancelRun as Bu, CodexExecutionPolicy as Bv, MountRecorder as Bw, createDelegationTraceCollector as Bx, DetachedTurnResumeDriverOptions as By, AuthoredHarness as C, RuntimeRunStateError as CC, PublishOptions as CS, SandboxToolPartState as C_, BenchmarkReport as Ca, DelegationProfile as Cb, PursuitObserverDelivery as Cc, GroupOf as Cd, BudgetViolation as Cf, createSteerableSandboxSession as Cg, SpawnPreflightContext as Ch, claimRetainedInteractiveControl as Ci, createSupervisorSpanRecorder as Cl, DriverFailureClass as Cm, defaultEdgeTraversalCap as Cn, InProcessSandboxClientOptions as Co, SpendGap as Cp, filterAuthoredAsserts as Cr, WinnerStrategy as Cs, pickBestProfile as Ct, CoordinationTransportOptions as Cu, ProviderWorkspaceRetentionPort as Cv, LoopDecisionPayload as Cw, RuntimeTelemetryOptions as Cx, CoderReviewer as Cy, WorkerInteractiveBinding as D, DeadlineCheckIn as DC, watchTrace as DS, createSandboxUsageLedger as D_, printBenchmarkReport as Da, DelegationStatusArgs as Db, PursuitNodePlatform as Dc, LeaderboardRow as Dd, ExecutorAccounting as Df, ExecutorProgress as Dg, ToolOutcomeEvent as Dh, ResolveSandboxClientOptions as Di, DriveHarness as Dl, DriverRepromptRefusal as Dm, PromptRegistry as Dn, HarvestFailure as Do, SupervisedResult as Dp, sandboxCheckRunner as Dr, Outcome as Ds, PatchDeliverableOptions as Dt, CoordinationRejectReason as Du, WorktreeCommandResult as Dv, LoopIterationStartedPayload as Dw, createRuntimeStreamEventCollector as Dx, SettleDetachedCoderTurnOptions as Dy, AttachWorkerOptions as E, DEFAULT_CHECK_IN_IDLE_MS as EC, defaultToolDetectors as ES, createSandboxToolPartState as E_, Environment as Ea, DelegationStatus as Eb, PursuitNodePlacement as Ec, LeaderboardOptions as Ed, Executor as Ef, DEFAULT_STALL_AFTER_MS as Eg, SuperviseProfileEntry as Eh, startRetainedInteractiveRun as Ei, CoordinationVerbs as El, DriverReentry as Em, PromptHandle as En, HarvestError as Eo, SubtreeSummary as Ep, resolveEntrySymbol as Er, LoopShape as Es, recordProfileRun as Et, CoordinationHttpOptions as Eu, WorktreeCheckRunner as Ev, LoopIterationEndedPayload as Ew, createRuntimeEventCollector as Ex, DetachedWinnerSelection as Ey, closingWorkerNote as F, RecoverRetainedRunOptions as FC, DeliverableSpec as FS, AgentEnvironmentCapabilities$1 as F_, CorpusReadbackOptions as Fa, UI_FINDING_SEVERITIES as Fb, projectPursuit as Fc, renderLeaderboardMarkdown as Fd, ExecutorProgressEvent as Ff, InboxMessage as Fg, normalizeAnalyzeOnSettle as Fh, AgentTurnUsage as Fi, SupervisorNodeContext as Fl, AnalystDefinitionIssue as Fm, kernelPromptRegistry as Fn, defaultAnalystInstruction as Fo, WidenGate as Fp, StrategyTournament as Fr, ShapeRegistry as Fs, InteractiveWorkerResult as Ft, WorkerCancelRequest as Fu, WorktreeHandle as Fv, LoopTokenUsage as Fw, DelegationTraceCollector as Fx, SiblingSandboxExecutorOptions as Fy, WorkspaceCommit as G, RetainedRunDispatchedAdmission as GC, ContinuationContext as GS, AgentSessionRef as G_, adaptiveRefine as Ga, ResearchSource as Gb, DeliverableResolutionInput as Gc, renderAnytimeTable as Gd, NoWinnerError as Gf, resolveMcpServerLaunch as Gg, hostDirectoryReader as Gh, equalKOnCost as Gi, ManagerWakePolicy as Gl, AuthorizedDownMessage as Gm, ChatSessionStore as Gn, EqualKOnCostOptions as Go, workerTraceHeaders as Gp, strategyAuthorSystemPrompt as Gr, LeaderboardSpec as Gs, graphDigest as Gt, readRunCancellation as Gu, LocalHarnessResult as Gv, ValidationCtx as Gw, FileDelegationStoreOptions as Gx, detachedTurnEvents as Gy, GitWorkspaceOptions as H, RetainedRunAdmissionHook as HC, CheckUnavailableError as HS, AgentEnvironmentSummary as H_, StrategyResult as Ha, KnowledgeUpdate as Hb, AuthorizedSpawn as Hc, areaUnderCurve as Hd, HeldEnvironment as Hf, ResolvedMcpServerLaunch as Hg, SpawnResourceRead as Hh, PrivateCasOffloadReport as Hi, supervisorAgent as Hl, AuthoredAnalystDefinition as Hm, driverAgent as Hn, CorpusRecord as Ho, WorkerTraceSeamCarrier as Hp, assertStrategyContract as Hr, LeaderboardRunContext as Hs, GraphSelection as Ht, legacySupervisorRunDir as Hu, DEFAULT_LOCAL_HARNESS as Hv, RunProvenance as Hw, DelegationStateCorruptError as Hx, DriveTurnTick as Hy, composeWorkerEvidence as I, RecoverRetainedRunResult as IC, ExecutorResultMapping as IS, AgentEnvironmentEvent$1 as I_, RunAgenticOptions as Ia, UI_LENSES as Ib, FileObserverJournal as Ic, renderLeaderboardSvg as Id, ExecutorRegistry as If, PeerInboxMessage as Ig, parseAuthoredAnalystDefinition as Ih, CollectedAgentTurn as Ii, SupervisorNodeContextSeed as Il, AnalystFindingEvent as Im, naiveContinuationPrompt as In, observe as Io, WorkerInteractiveSession as Ip, TournamentCell as Ir, DefinedLeaderboard as Is, workerFromInteractiveProvider as It, WorkerCancellation as Iu, captureWorktreeDiff as Iv, LoopTraceEmitter as Iw, DelegationTraceSpan as Ix, createFleetWorkspaceExecutor as Iy, jjWorkspace as J, RetainedRunEventOptions as JC, ContinuationPanel as JS, CheckpointRef as J_, depthStrategy as Ja, createResearcherValidator as Jb, SuperviseRegistryTable as Jc, WaterfallSpan as Jd, NodeSnapshot as Jf, CodexForkBoundary as Jg, McpServerOptions as Jh, createShapeRegistry as Ji, PlateauOptions as Jl, ContinuationInstruction as Jm, ChatWorkerSeamOptions as Jn, FanoutOptions as Jo, RecoverRetainedInteractiveRunOptions as Jp, McpSpawnFault as Jr, DeclaredCheckPlacement as Js, graphRunsFor as Jt, readWorkerSteerAcknowledgement as Ju, localHarnessExecutable as Jv, RuntimeRunCost as Jw, CoderTask as Jx, runDetachedTurn as Jy, WorkspaceRun as K, RetainedRunEffect as KC, ContinuationEntry as KS, AgentSessionStatus$1 as K_, breadthStrategy as Ka, ResearchTask as Kb, SuperviseOptions as Kc, WaterfallCollector as Kd, NodeExecutionIdentity as Kf, resolveSecretEnv as Kg, resolveSpawnResourcePaths as Kh, trajectoryReport as Ki, AllWorkersStalledOptions as Kl, AwaitWakeInput as Km, ChatTransportExecutorOptions as Kn, EqualKVerdict as Ko, workerTraceSeamKey as Kp, LocalMcpMaterialization as Kr, defineLeaderboard as Ks, graphFromStored as Kt, readWorkerCancelRequests as Ku, RunLocalHarnessOptions as Kv, Validator as Kw, InMemoryDelegationStore as Kx, formatDetachedSessionRef as Ky, settledWorkerOut as L, RetainedInteractiveAdmission as LC, gateOnDeliverable as LS, AgentEnvironmentProvider$1 as L_, ShotSpec as La, UiFinding as Lb, ObserverJournal as Lc, renderPairwiseMarkdown as Ld, ExecutorResult as Lf, createInbox as Lg, questionEscalationTargets as Lh, StreamAgentTurnOptions as Li, SupervisorProfile as Ll, AnalystKind as Lm, promptHandle as Ln, renderReport as Lo, WorkerInteractiveUnavailableReason as Lp, TournamentRow as Lr, LeaderboardBenchScore as Ls, WorkerInteractiveAdmission as Lt, WorkerSteerAcknowledgement as Lu, createWorktree as Lv, LoopTraceEvent as Lw, buildDelegationTraceSpans as Lx, createSiblingSandboxExecutor as Ly, NOTE_MAX_CHARS as M, NativeContextContinuationInput as MC, createPushTraceSource as MS, sandboxProgressEvents as M_, AgenticTask as Ma, UiAuditLensFilter as Mb, PursuitRunProjection as Mc, leaderboard as Md, ExecutorFactory as Mf, readWorkerProgress as Mg, canonicalFindingEvent as Mh, assertProfileModelsAllowed as Mi, ResolvedSupervisorProfile as Ml, RetainedPendingCause as Mm, dumbContinuationFailPrompt as Mn, ObservationError as Mo, UnconfirmedTeardown as Mp, EvolutionReport as Mr, RunPersonifiedOptions as Ms, InteractiveWorkerEnvironment as Mt, PriorCoordination as Mu, DiffResult as Mv, LoopSandboxPlacement as Mw, DELEGATION_TRACE_MAX_BYTES as Mx, DelegationExecutor as My, VERIFY_TAIL_CHARS as N, ReconnectRetainedRunOptions as NC, decodeToolPart as NS, sumSandboxUsage as N_, AgenticTool as Na, UiAuditorDelegationOutput as Nb, PursuitRunTotals as Nc, pairwiseSignificance as Nd, ExecutorMaterialization as Nf, AuthorityInboxMessage as Ng, createCoordinationTools as Nh, AgentTurnBackend as Ni, SupervisorAgentDeps as Nl, ANALYST_DEFINITION_BOUNDS as Nm, dumbContinuationPassPrompt as Nn, ObserveInput as No, UnknownMaterializationReason as Np, EvolutionStrategy as Nr, ShapeBudget as Ns, InteractiveWorkerKeyInput as Nt, RunCancelRequest as Nu, GitRunner as Nv, LoopStartedPayload as Nw, DELEGATION_TRACE_MAX_SPANS as Nx, FleetHandle as Ny, WorkerInteractiveProviderSource as O, WorkerSlots as OC, SessionMessageLike as OS, extractLlmCallEvent as O_, runBenchmark as Oa, DelegationStatusResult as Ob, PursuitNodeProjection as Oc, PairwiseOptions as Od, ExecutorCancellation as Of, ScopeProgressInput as Og, WorkerResumeContext as Oh, resolveSandboxClient as Oi, DriveHarnessOwnerContext as Ol, DriverRetryPolicy as Om, RegisteredPrompt as On, HarvestReport as Oo, Supervisor as Op, selectBestIndex as Or, Persona as Os, patchDelivered as Ot, CoordinationDeliveryEvidence as Ou, WorktreeHarnessResult as Ov, LoopLineageOptions as Ow, sanitizeAgentRuntimeEvent as Ox, UiAuditorDelegate as Oy, WorkerEvidenceInput as P, RecoverRetainedRunIntentOptions as PC, sandboxSessionTraceSource as PS, AgentEnvironment$1 as P_, ArtifactHandle as Pa, delegationProfiles as Pb, PursuitStatus as Pc, renderLeaderboardHtml as Pd, ExecutorNodeContext as Pf, Inbox as Pg, downMessageRefusalReasons as Ph, AgentTurnInput$1 as Pi, SupervisorAgentTestDeps as Pl, AnalystAssignmentRecord as Pm, formatPromptHandle as Pn, ObserveOptions as Po, UsageEvent as Pp, StrategyEvolutionConfig as Pr, ShapeContext as Ps, InteractiveWorkerOptions as Pt, RunCancellation as Pu, RemoveWorktreeOptions as Pv, LoopTeardownFailedPayload as Pw, DelegationTraceCaps as Px, FleetWorkspaceExecutorOptions as Py, analyzeTrace as Q, RetainedRunSnapshot as QC, ContinuationProfile as QS, ExecResult as Q_, sampleThenRefine as Qa, createPropagatingTraceEmitter as Qb, workerFromBackend as Qc, SqlRunStoreOptions as Qd, ProviderModelExecutionEvidence as Qf, CodexRolloutStoreRef as Qg, DELEGATE_INPUT_SCHEMA as Qh, FileCorpus as Qi, ProgressView as Ql, CoordinationTools as Qm, AuthoredProfile as Qn, LoopUntil as Qo, RetainedInteractiveStartMaterial as Qp, connectStdioMcp as Qr, declaredCheckDeliverable as Qs, pickBestGraph as Qt, safeWorkerFile as Qu, RouterTransportConfig as Qv, RuntimeRunRow as Qw, PEER_MAIL_WIRE_KEY as Qx, DelegationResumeDriver as Qy, CopyOptions as R, RetainedInteractiveEnvironmentAdmission as RC, mapExecutorResult as RS, AgentEnvironmentProviderRef as R_, Strategy as Ra, UiFindingScreenshot as Rb, ObserverRecord as Rc, AnytimeReport as Rd, ExecutorTeardownWarning as Rf, BridgeHarnessStore as Rg, ResolveSpawnResourcePathsResult as Rh, collectAgentTurn as Ri, SupervisorToolDescriptor as Rl, AnalystLensOutput as Rm, DelegateOptions as Rn, AssertTraceDerivedFindings as Ro, WorkerTraceEvidence as Rp, runStrategyEvolution as Rr, LeaderboardBenchTask as Rs, InPlaceCliExecutorOptions as Rt, WorkerSteerRequest as Ru, removeWorktree as Rv, LoopWinner as Rw, capDelegationTrace as Rx, DetachedSessionRefParts as Ry, failuresAnalyst as S, RetainedRunDispatchBindingError as SC, EventBus as SS, RuntimeStreamEvent as ST, SandboxServedBackend as S_, BenchmarkLift as Sa, DelegationHistoryResult as Sb, RUN_FORK_CORRELATION_KEYS as Sc, AxisScoresOf as Sd, BudgetOverspend as Sf, SteerableSandboxSession as Sg, SpawnPreflight as Sh, ClaimRetainedInteractiveControlOptions as Si, SupervisorSpanRecorder as Sl, DriverContractState as Sm, TraversalContinuity as Sn, InProcessPromptCtx as So, SpendChannel as Sp, defaultStructuralRolloutPolicy as Sr, WidenSpec as Ss, loadProfile as St, CoordinationPublicAddress as Su, ProviderWorkspaceRetentionContext as Sv, Iteration as Sw, RuntimeStreamEventSummary as Sx, CoderReview as Sy, worktreeFanout as T, DEADLINE_CHECK_IN_MESSAGE as TC, WatchTraceOptions as TS, assertSandboxServedModel as T_, BenchmarkTaskRow as Ta, DelegationResultPayload as Tb, PursuitNodeCost as Tc, Leaderboard as Td, ExecutionBindingReceipt as Tf, ActivityNote as Tg, SpawnRefusalCause as Th, recoverRetainedInteractiveRun as Ti, CoordinationToolFace as Tl, DriverProgressMark as Tm, runGraphWithTestBrain as Tn, HarvestCorpusOptions as To, SubtreeResult as Tp, officialChecksFromMeta as Tr, DefinePersonaInput as Ts, profileRunsForName as Tt, CoordinationHttpAudit as Tu, InPlaceHarnessResult as Tv, LoopIterationDispatchPayload as Tw, SanitizedKnowledgeRequirement as Tx, DetachedSessionDelegateOptions as Ty, Shell as U, RetainedRunCancelOptions as UC, CheckVerdict as US, AgentProfileRef as U_, StrategyShotResult as Ua, MultiHarnessResearcherFanoutOptions as Ub, AuthorizedSpawnContext as Uc, bestSoFar as Ud, MaterializedExecutionIdentity as Uf, envKeyProvider as Ug, SpawnResourceReader as Uh, PrivateCasOptions as Ui, supervisorAgentWithTestBrain as Ul, AuthoredAnalystLimits as Um, finalizeBestDelivered as Un, EqualKArm as Uo, readWorkerTraceContext as Up, authorStrategy as Ur, LeaderboardScenario as Us, StoredGraph as Ut, legacySupervisorRunsRoot as Uu, LOCAL_HARNESSES as Uv, SandboxClient as Uw, DelegationStore as Ux, RunDetachedTurnOptions as Uy, withUntrackedArtifacts as V, RetainedRunAdmission as VC, CheckRead as VS, AgentEnvironmentStatus as V_, StrategyMessage as Va, KnowledgeItem as Vb, verifyObserverRecords as Vc, anytimeReport as Vd, Handle as Vf, KeyProvider as Vg, SpawnResourceBytes as Vh, PrivateCasDurableStore as Vi, resolveSupervisorProfile as Vl, AnalyzeOnSettleRoute as Vm, DriverAgentOptions as Vn, CorpusFilter as Vo, WorkerTraceResolver as Vp, AuthoredStrategy as Vr, LeaderboardIterationInfo as Vs, GraphRunRecord as Vt, cancelWorker as Vu, CodexTokenUsage as Vv, OutputAdapter as Vw, DelegationPersistenceError as Vx, DriveTurnCapableBox as Vy, Workspace as W, RetainedRunCancellation as WC, ContinuationAppend as WS, AgentSession as W_, SurfaceScore as Wa, ResearchOutput as Wb, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as Wc, plateauLength as Wd, MaterializedModelIdentity as Wf, mcpSecretEnvMetadataKey as Wg, environmentReader as Wh, createPrivateCasArtifactPort as Wi, DEFAULT_DEADLINE_WARNING_MS as Wl, AuthorizeDownMessage as Wm, ChatCompletionsTransport as Wn, EqualKOnCost as Wo, workerTraceEnv as Wp, strategyAuthorContract as Wr, LeaderboardScore as Ws, digestOfGraph as Wt, readRunCancelRequest as Wu, LocalHarness as Wv, SelectionReceipt as Ww, FileDelegationStore as Wx, createDetachedTurnResumeDriver as Wy, runInWorkspace as X, RetainedRunIntentAdmission as XC, ContinuationPanelResult as XS, CreateAgentEnvironmentInput$1 as X_, runAgentic as Xa, researcherProfile as Xb, supervise as Xc, SqlRunLease as Xd, ProfileMaterializationReceipt as Xf, CodexRolloutSession as Xg, createMcpServer as Xh, definePersona as Xi, ProgressTracker as Xl, CoordinationEvent as Xm, chatWorkerSeam as Xn, FanoutWinnerSelector as Xo, RetainedInteractiveEnvironmentInput as Xp, StdioMcpConnection as Xr, assertDeclaredCheck as Xs, loadGraph as Xt, runCancelRequestFile as Xu, runLocalHarness as Xv, RuntimeRunOptions as Xw, AUTHORITY_MARKERS as Xx, DelegationRecord as Xy, localShell as Y, RetainedRunHandle as YC, ContinuationPanelInput as YS, CheckpointRequest as Y_, refine as Ya, multiHarnessResearcherFanout as Yb, SuperviseTestOptions as Yc, createWaterfallCollector as Yd, NodeStatus as Yf, CodexRolloutIdentity as Yg, createInProcessTransport as Yh, registerShape as Yi, ProgressSample as Yl, ContinuityMode as Ym, chatTransportExecutor as Yn, FanoutSynthesis as Yo, RetainedInteractiveAdmissionHook as Yp, McpToolDescriptor as Yr, DeclaredCheckStateCapture as Ys, listGraphRuns as Yt, readWorkerSteerRequests as Yu, parseCodexTokenUsage as Yv, RuntimeRunHandle as Yw, coderTaskToPrompt as Yx, DelegationArgs as Yy, TrajectoryAnalysis as Z, RetainedRunReplayPoint as ZC, ContinuationPolicy as ZS, ExecRequest as Z_, sample as Za, TraceContext as Zb, superviseWithTestBrain as Zc, SqlRunOwnershipError as Zd, ProviderModelAttemptEvidence as Zf, CodexRolloutStoreReader as Zg, DELEGATE_DESCRIPTION as Zh, runPersonified as Zi, ProgressTrackerOptions as Zl, CoordinationStats as Zm, createChatSessionStore as Zn, FlatWidenGate as Zo, RetainedInteractiveRunHandle as Zp, StdioMcpServerSpec as Zr, checkProgramDigest as Zs, lookupGraph as Zt, runCancellationFile as Zu, RouterResponseReceipt as Zv, RuntimeRunPersistenceAdapter as Zw, DEFAULT_PEER_MAIL_LIMITS as Zx, DelegationResumeContext as Zy, boxSurfaceReader as _, NotFoundError as _C, McpToolDescriptor$1 as _S, RunAgentTaskOptions as _T, sharedBoxPlacement as __, McpEnvironmentOptions as _a, DelegateUiAuditRoute as _b, SupervisePursuitError as _c, CompletionVerdict as _d, contentAddress as _f, createExecutor as _g, QuestionOption as _h, createS3PrivateCasStore as _i, createInMemoryRunContext as _l, DriverAttemptRecord as _m, GraphEdgeCapError as _n, captureBeforeDestroy as _o, SpawnJournal as _p, VisibleCheck as _r, Verify as _s, SupervisorCleanupReceipt as _t, collectDelivered as _u, ProviderWorkspaceAttemptProvenance as _v, spendFromUsageEvents as _w, padTraceId as _x, FeedbackEvent as _y, SandboxInstance$1 as a, expandQuestions as aC, PeerMailRefusal as aS, AgentKnowledgeProvider as aT, HarnessUsage as a_, pipeline as aa, hashIdempotencyInput as ab, IsolatedCheckResult as ac, workerControlLogFile as ad, FileSpawnJournal as af, validateDelegateArgs as ag, EscalateQuestion as ah, SandboxRunAbortError as ai, retryPreSpawnRefusals as al, HarnessTranscriptUnavailableReason as am, RollingDispatchOptions as an, loopDispatch as ao, RetainedExecutionState as ap, supervisorInstructions as ar, Pipeline as as, createRootHandle as at, noProgressFor as au, ResourceRequest as av, BudgetReadout as aw, OtelExportStats as ax, ToolLoopToolCall as ay, AnalystAuthoring as b, RetainedInteractiveBindingError as bC, BusRecord as bS, RuntimeSession as bT, SandboxLeafOut as b_, BenchmarkCell as ba, DelegationHistoryArgs as bb, supervisePursuit as bc, sentinelCompletion as bd, AgentSpec as bf, SandboxSteeringOptions as bg, QuestionUrgency as bh, startRetainedRun as bi, SupervisorSpanOptions as bl, DriverBudgetReadout as bm, RunGraphOptions as bn, inlineSandboxClient as bo, SpawnRejection as bp, composeCheckSources as br, WidenDecision as bs, ProfileRunRecord as bt, CoordinationAuthentication as bu, ProviderWorkspaceCaptureResult as bv, Driver as bw, RuntimeStreamEventCollector as bx, eventToSnapshot as by, VerifierEnvironmentOptions as c, verdictFromJudgeScore as cC, PeerMailboxOptions as cS, AgentTaskContext as cT, DEFAULT_SHARED_BOX_WORKERS as c_, widen as ca, DelegateCodeResult as cb, NextPursuitVersion as cc, workerSteerAcknowledgementFile as cd, SpawnForest as cf, CliWorktreeBridgeSeam as cg, MakeWorkerAgent as ch, BranchCapableBox as ci, SeatSelection as cl, harnessTranscriptArtifact as cm, rollingDispatch as cn, TERMINAL_DECISIONS as co, RootProviderModelEvidence as cp, CheckRunContext as cr, RenderCorpusToInstructionsOptions as cs, SqlRunContextOptions as ct, ReentryContinuity as cu, providerAsExecutor as cv, ReservationFloor as cw, RuntimeEventOtelOptions as cx, CodeModeStore as cy, HarvestSurfaceDiffsOptions as d, resolveRedactor as dC, isPeerMailEnvelope as dS, AgentTaskStatus as dT, SharedBoxHandle as d_, assertTraceDerivedFindings as da, DelegateResearchArgs as db, PursuitVersionStop as dc, workerSteerRequestsDir as dd, SpawnForestMissingTree as df, ProviderSeam as dg, Question as dh, SessionCapableBox as di, SelectSeat as dl, HarnessTranscriptReadLimits as dm, GraphDesignerExtraTools as dn, isTerminalDecision as do, RootSignal as dp, CheckSourceCtx as dr, ScopeWidenGate as ds, ScopeArgs as dt, composeReentryTask as du, CreateTangleSandboxExactProcessProviderOptions as dv, ReservationShortfall as dw, buildRuntimeEventOtelSpans as dx, CodeModeToolsOptions as dy, VerdictSummary as eC, PeerMailEvent as eS, startRuntimeRun as eT, CodexStoreDelta as e_, renderCorpusToInstructions as ea, DelegationRunContext as eb, declaredCheckJudge as ec, supervisorRunsRoot as ed, D1DatabaseLike as ef, DelegateArgs as eg, DefinedAnalystRecord as eh, Deliverable as ei, WorkerSpawnRetryAttempt as el, HarnessTranscriptArtifact as em, storedGraphDigests as en, LoopDispatchOptions as eo, ResourceLimit as ep, ProfileRichnessThresholds as er, LoopUntilState as es, WorkerToolTraceArtifact as et, StopRule as eu, PlacementInfo as ev, RetainedRunTurnInput as ew, readTraceContextFromEnv as ex, ToolLoopCallContext as ey, SurfaceDiff as f, AgentEvalError$1 as fC, peerMailTools as fS, BackendErrorDetail as fT, SharedBoxPlacement as f_, buildSteerContext as fa, DelegateResearchConfig as fb, PursuitVersions as fc, workerSteersDir as fd, SpawnForestNode as ff, RouterSeam as fg, QuestionDecision as fh, createSandboxLineage as fi, InMemoryRunContext as fl, HarnessTranscriptReadOptions as fm, graphDesignerExtraTools as fn, runAgentRounds as fo, RootStreamReceipt as fp, RepairStop as fr, SteerContext as fs, createScope as ft, DeliveredOutput as fu, SandboxControlClient as fv, ReservationStage as fw, createOpenInferenceFileExporter as fx, CodeModeToolset as fy, WatchedSurface as g, JudgeError as gC, McpToolAnnotations as gS, OpenAIChatToolChoice as gT, SharedWorkerIdentity as g_, McpEndpoint as ga, DelegateUiAuditResult as gb, assertPursuitVersions as gc, CompletionPolicy as gd, replaySpawnTree as gf, cliWorktreeExecutor as gg, QuestionLevel as gh, S3PrivateCasStoreOptions as gi, createFileRunContext as gl, retainHarnessTranscript as gm, GraphEdge as gn, SandboxEvidenceRetentionPort as go, SpawnEvent as gp, StructuralRolloutResult as gr, TrajectoryReportOptions as gs, ProvisionedSupervisor as gt, bestDelivered as gu, ProviderNativeCapturePhase as gv, createBudgetPool as gw, padSpanId as gx, runCodeMode as gy, SurfaceReader as h, ConfigError as hC, JsonRpcResponse as hS, OpenAIChatTool as hT, SharedBoxStats as h_, observationFromRegistry as ha, DelegateUiAuditConfig as hb, VersionVerdict as hc, CompletionEvidence as hd, materializeTreeView as hf, cliInPlaceExecutor as hg, QuestionEscalationTarget as hh, S3PrivateCasStore as hi, RunContextLease as hl, resolveHarnessTranscriptCapture as hm, EdgeTraversal as hn, SandboxEvidenceRetentionError as ho, Settled as hp, StructuralRolloutPolicy as hr, TrajectoryReportFn as hs, ProvisionSupervisorRequest as ht, SupervisorFinalizer as hu, ProviderCheckpointCaptureContext as hv, ReserveOptions as hw, loopEventToOtelSpan as hx, describeCodeModeTools as hy, SandboxEvent$1 as i, distillFindings as iC, PeerMailReadout as iS, AgentExecutionBackend as iT, readCodexRolloutSession as i_, panel as ia, SubmitOutput as ib, IsolatedCheckOptions as ic, workerCancellationsDir as id, FileResultBlobStore as if, createDelegateHandler as ig, DownMessageEvent as ih, SandboxRun as ii, resolveWorkerSpawnRetry as il, HarnessTranscriptUnavailable as im, DispatchUnit as in, loopCampaignDispatch as io, ResumedWork as ip, profileRichnessFinding as ir, PanelVerdict as is, DEFAULT_MAX_DEPTH as it, createProgressTracker as iu, ProviderPromptOptions as iv, BudgetPoolRestore as iw, OtelExportConfig as ix, ToolLoopMessageRecord as iy, EVIDENCE_MAX_CHARS as j, NativeContextContinuationHandle as jC, TraceSource as jS, sandboxEventServedBackend as j_, AgenticSurface as ja, ResearchOutputShape as jb, PursuitProjection as jc, ScoreOf as jd, ExecutorExecutionBinding as jf, createActivityLog as jg, analystToolGroupNames as jh, assertModelAllowed as ji, ResolveSupervisorTools as jl, upstreamUnavailableSignal as jm, delegatesWorkerBriefPrompt as jn, ObservationAnalysis as jo, TreeView as jp, EvolutionAuthor as jr, RunPersonified as js, createWorktreeCliExecutor as jt, FileCoordinationLog as ju, DiffOptions as jv, LoopResult as jw, CappedDelegationTrace as jx, settleDetachedCoderTurn as jy, attachWorker as k, createWorkerSlots as kC, SessionTraceBox as kS, mapSandboxEvent as k_, AgenticOptions as ka, FeedbackRating as kb, PursuitNodeTiming as kc, PairwiseVerdict as kd, ExecutorCancellationRequest as kf, TeamProgress as kg, WorkerSpawnContext as kh, profileChatClient as ki, ObserveSupervisorNodeEvent as kl, classifyDriverFailure as km, analyzesFindingsReportPrompt as kn, harvestCorpus as ko, SupervisorOpts as kp, structuralRollout as kr, PersonaContext as ks, WorktreeCliExecutorOptions as kt, CoordinationLog as ku, WorktreeProfileMaterializationReceipt as kv, LoopPlanDescription as kw, sanitizeKnowledgeReadinessReport as kx, coderTaskFromArgs as ky, createVerifierEnvironment as l, Redactor as lC, claimsAuthority as lS, AgentTaskRunResult as lT, ROUTER_CLIENT_HEADER as l_, CreateScopeAnalystOptions as la, DelegateFeedbackArgs as lb, NextPursuitVersionInput as lc, workerSteerAcknowledgementsDir as ld, SpawnForestEvent as lf, CliWorktreeSeam as lg, ManagerReentryState as lh, SandboxLineage as li, SeatSelectionInput as ll, persistHarnessTranscript as lm, DesignerRunGraphEnv as ln, TerminalDecision as lo, RootSegment as lp, CheckRunner as lr, ScopeAnalyst as ls, createFencedSqlRunContext as lt, ReentryTaskInput as lu, providerAsSandboxClient as lv, ReservationHolder as lw, buildLoopOtelSpans as lx, CodeModeTool as ly, SurfaceReadOutcome as m, BackendTransportError as mC, JsonRpcMessage as mS, OpenAIChatResponseFormat as mT, SharedBoxProcess as m_, registryScopeAnalyst as ma, DelegateUiAuditArgs as mb, VersionJudge as mc, CompletionAnalyst as md, loadSpawnForest as mf, SandboxSeam as mg, QuestionEscalationRecord as mh, acquireSandbox as mi, RunContext as ml, RetainedHarnessTranscriptDescriptor as mm, EdgeDeliveryOutcome as mn, SandboxEvidenceReceipt as mo, Scope as mp, StructuralRolloutMessage as mr, TrajectoryReport as ms, ProvisionSupervisorConnection as mt, FinalizerSettled as mu, UnavailablePausePolicy as mv, ReservationWaitRefused as mw, generateSpanId as mx, createCodeModeTools as my, AnalystFinding$1 as n, admitFinding as nC, PeerMailLimits as nS, AgentBackendContext as nT, createCodexRolloutStoreReader as n_, flatWidenGate as na, DelegationTaskQueueOptions as nb, IsolatedCheckBox as nc, workerCancelRequestsFile as nd, SqlAdapter as nf, DelegateHandlerOptions as ng, DownMessageDeliveryAttempt as nh, OpenSandboxRunOptions as ni, WorkerSpawnRetryPolicy as nl, HarnessTranscriptEvidence as nm, DispatchReport as nn, SuperviseDispatchOptions as no, ResultBlobStore as np, assessAuthoredProfile as nr, PanelJudge as ns, parseWorkerToolTraceArtifact as nt, allWorkersStalled as nu, ProviderExecutorOptions as nv, StartRetainedRunOptions as nw, LoopSpanNode as nx, ToolLoopCompaction as ny, computeFindingId$1 as o, failedItems as oC, PeerMailSendInput as oS, AgentRuntimeEvent as oT, decodeHarnessUsage as o_, selectValidWinner as oa, DelegateCodeArgs as ob, runIsolatedCheck as oc, workerInboxFile as od, InMemoryResultBlobStore as of, CliInPlaceSeam as og, EventAcknowledgement as oh, TurnResult as oi, withWorkerSpawnRetry as ol, ReadableEnvironment as om, freeSlots as on, superviseDispatch as oo, RootHandle as op, CheckExecChannel as or, PipelineStage as os, createSupervisor as ot, plateau as ou, WorkspaceRequest as ov, BudgetReconcileFault as ow, OtelExporter as ox, CodeModeOptions as oy, SurfaceReadBox as p, AgentEvalErrorCode as pC, peerMailVerbNames as pS, KnowledgeReadinessDecision as pT, SharedBoxPlacementOptions as p_, createScopeAnalyst as pa, DelegateResearchResult as pb, SettledPursuitVersion as pc, writeWorkerSteer as pd, SpawnForestTree as pf, RouterToolsSeam as pg, QuestionEscalationOutcome as ph, AcquireOptions as pi, InMemoryRunContextOptions as pl, RetainedHarnessTranscriptCapture as pm, AgentGraph as pn, SandboxEvidenceContext as po, Runtime as pp, StructuralRolloutConfig as pr, TrajectoryNode as ps, settledToIteration as pt, FinalizeContext as pu, createTangleSandboxExactProcessProvider as pv, ReservationTicket as pw, createOtelExporter as px, RunCodeModeOptions as py, gitWorkspace as q, RetainedRunEnvironmentAdmission as qC, ContinuationNoteInput as qS, AgentTurnResult$2 as q_, defineStrategy as qa, ResearcherProfileOptions as qb, SuperviseRegistry as qc, WaterfallReport as qd, NodeId as qf, secretEnvOfMcpServer as qg, McpServer as qh, builtinShapes as qi, NoProgressForOptions as ql, BlockedToolReport as qm, ChatTransportTool as qn, Fanout as qo, ReconnectRetainedInteractiveRunOptions as qp, MaterializeLocalMcpOptions as qr, DeclaredCheck as qs, graphRegistry as qt, readWorkerCancellation as qu, harnessSupportsReasoningEffort as qv, RuntimeRunCompleteInput as qw, CoderOutput as qx, parseDetachedSessionRef as qy, CreateSandboxOptions$1 as r, checkVerdictOf as rC, PeerMailOutcome as rS, AgentBackendInput as rT, harnessUsageIsEmpty as r_, loopUntil as ra, SubmitInput as rb, IsolatedCheckBoxEvidence as rc, workerCancellationFile as rd, d1ToSqlAdapter as rf, DelegateResult as rg, DownMessageDeliveryOutcome as rh, OpenSandboxRunPromptOptions as ri, isPreSpawnExecutorFailure as rl, HarnessTranscriptFile as rm, DispatchStopReason as rn, SuperviseOptionsForDispatch as ro, ResumedKeyState as rp, defaultProfileRichnessThresholds as rr, PanelSpec as rs, workerTraceAnalysisStore as rt, anyOf as ru, ProviderLeafOut as rv, BudgetPool as rw, OtelAttribute as rx, ToolLoopCompactionOptions as ry, makeFinding$1 as s, passedItems as sC, PeerMailbox as sS, AgentRuntimeEventSink as sT, DEFAULT_SHARED_BOX_RESOURCES as s_, verify as sa, DelegateCodeConfig as sb, JudgedPursuitVersion as sc, workerInboxFileFromEventDir as sd, InMemorySpawnJournal as sf, CliSeam as sg, LeadMessage as sh, openSandboxRun as si, SeatSegment as sl, captureHarnessTranscript as sm, queueOf as sn, RunAgentRoundsOptions as so, RootMaterialization as sp, CheckOutcome as sr, RenderCorpusToInstructions as ss, FencedSqlRunContext as st, sampleFromSettled as su, createAgentEnvironmentProviderRegistry as sv, LeakedReservation as sw, OtelSpan as sx, CodeModeResult as sy, AgentProfile$2 as t, admitContinuationPolicy as tC, PeerMailKind as tS, AgentAdapter as tT, addHarnessUsage as t_, fanout as ta, DelegationTaskQueue as tb, readDeclaredCheck as tc, supervisorWorkersDir as td, D1StmtLike as tf, DelegateError as tg, DownMessageAuthorizationInput as th, OpenSandboxRunBeforeStartContext as ti, WorkerSpawnRetryHooks as tl, HarnessTranscriptCapture as tm, taskShapeDigest as tn, LoopOptionsForDispatch as to, ResourceSpend as tp, asAuthoredProfile as tr, Panel as ts, captureWorkerTraceEvidence as tt, allOf as tu, ProviderAsSandboxClientOptions as tv, StartRetainedRunInEnvironmentOptions as tw, traceContextToEnv as tx, ToolLoopChat as ty, BoxSurfaceReaderOptions as u, defaultRedactor as uC, createPeerMailbox as uS, AgentTaskSpec as uT, SharedBoxCloseReceipt as u_, RegistryAnalyzeProjection as ua, DelegateFeedbackResult as ub, PursuitVersionChain as uc, workerSteerRequestFile as ud, SpawnForestInDoubtNode as uf, ExecutorConfig as ug, ManagerWake as uh, SandboxLineageHandle as ui, SeatStage as ul, HarnessTranscriptMetadata as um, DesignerToolsEnv as un, defaultSelectWinner as uo, RootSegmentEntry as up, CheckSource as ur, ScopeAnalyzeInput as us, SUBTREE_RESULT_LIMIT as ut, UNPROVEN_CONTINUITY as uu, resolveAgentEnvironmentProvider as uv, ReservationRejection as uw, buildLoopSpanNodes as ux, CodeModeToolContext as uy, fsSurfaceReader as v, PlannerError as vC, McpTransport as vS, RunAgentTaskStreamOptions as vT, sharedBoxRefusal as v_, createMcpEnvironment as va, DelegationError as vb, SupervisePursuitOptions as vc, completionAuthorizes as vd, Agent as vf, createExecutorRegistry as vg, QuestionPolicy as vh, reconnectRetainedRun as vi, withRunContext as vl, DriverAttemptStop as vm, GraphNode as vn, LocalSandboxClientOptions as vo, SpawnOpts as vp, canDisplace as vr, VerifySpec as vs, provisionSupervisor as vt, pickBestDelivered as vu, ProviderWorkspaceCaptureProvenance as vv, AgentRunSpec as vw, toOtelAttributes as vx, FeedbackStore as vy, WorktreeFanoutOptions as w, ValidationError as wC, createEventBus as wS, SandboxUsageLedger as w_, BenchmarkStrategySummary as wa, DelegationProgress as wb, PursuitCostProvenance as wc, Interval as wd, EnvironmentTeardownReceipt as wf, ActivityLog as wg, SpawnRefusal as wh, reconnectRetainedInteractiveRun as wi, CoordinationBinding as wl, DriverLoopRecord as wm, runGraph as wn, inProcessSandboxClient as wo, SteerableRootHandle as wp, modelAuthoredChecks as wr, DefinePersona as ws, profileRegistry as wt, serveCoordinationMcp as wu, ProviderPlacement as wv, LoopEndedPayload as ww, SanitizedKnowledgeReadinessReport as wx, DelegateRunCtx as wy, analystsFromRegistry as x, RetainedRunAdmissionError as xC, BusStats as xS, RuntimeSessionStore as xT, SandboxOutputMarker as x_, BenchmarkConfig as xa, DelegationHistoryEntry as xb, PursuitFork as xc, stopSentinel as xd, Budget as xf, SteerableSandboxArgs as xg, SettledWorker as xh, startRetainedRunInEnvironment as xi, SupervisorSpanOutcome as xl, DriverContinuationRecord as xm, RunGraphTestOptions as xn, InProcessOnPrompt as xo, Spend as xp, defaultExtractCandidate as xr, WidenLineage as xs, bestProfileFor as xt, CoordinationMcpHandle as xu, ProviderWorkspaceEntryMetadata as xv, ExecCtx as xw, RuntimeStreamEventSink as xx, CoderDelegate as xy, harvestSurfaceDiffs as y, RetainedInteractiveAdmissionError as yC, BusEvent as yS, RuntimeCanonicalStreamEvent as yT, sharedWorkerClientName as y_, sanitizeMcpToolSchema as ya, DelegationFeedbackSnapshot as yb, SupervisedPursuitResult as yc, deterministicCompletion as yd, AgentExecutionRef as yf, DEFAULT_SANDBOX_STEERING_MAX_TURNS as yg, QuestionRecord as yh, recoverRetainedRun as yi, SupervisorSpanAttributes as yl, DriverAttemptsExhaustedError as ym, GraphResult as yn, localSandboxClient as yo, SpawnPrior as yp, compareCheckOutcomes as yr, Widen as ys, ProfileRegistryDir as yt, runFinalizer as yu, ProviderWorkspaceCaptureReceipt as yv, DefaultVerdict$1 as yw, RuntimeEventCollector as yx, InMemoryFeedbackStore as yy, UntrackedCopyStats as z, RetainedInteractiveIntentAdmission as zC, AdmittedFinding as zS, AgentEnvironmentProviderRegistry as z_, StrategyArtifacts as za, UiFindingSeverity as zb, ObserverRecordKind as zc, AnytimeStrategySummary as zd, ExecutorToolCall as zf, BridgeModelCredential as zg, ResolvedSpawnResourcePath as zh, streamAgentTurn as zi, SupervisorToolInvocationContext as zl, AnalystRegistry$1 as zm, defaultDelegateBudget as zn, CombinatorShape as zo, WorkerTraceUnavailableReason as zp, strategyTournament as zr, LeaderboardBenchmarkAdapter as zs, createInPlaceCliExecutor as zt, WriteWorkerSteerOptions as zu, CodexExecutionEvidence as zv, MountManifestEntry as zw, composeLoopTraceEmitters as zx, DetachedTurn as zy };
+//# sourceMappingURL=index-Da7w2H86.d.ts.map