@tangle-network/agent-runtime 4.0.0 → 6.0.1

package/dist/{types-ooyUaxq_.d.ts → types-niKnm6ux.d.ts}

@@ -1,6 +1,6 @@
 import { a as ProfileMaterializationContract } from "./profile-materialization-BRY22Oh8.js";
-import { P as AgentCandidateOutputArtifactPort, _ as AgentCandidateArtifactPort, n as AgentCandidateWorkspaceTree, u as AgentCandidateWorkspaceArchiveLimits } from "./workspace-streams-DbKiDOWA.js";
-import { l as RuntimeHooks, o as RuntimeHookEvent, r as RuntimeDecisionPoint } from "./runtime-hooks-ZQqPw-0g.js";
+import { T as AgentCandidateOutputArtifactPort, c as AgentCandidateArtifactPort, t as AgentCandidateWorkspaceArchiveLimits } from "./workspace-archive-DS9E9tUr.js";
+import { r as RuntimeDecisionPoint, s as RuntimeHookEvent, u as RuntimeHooks } from "./runtime-hooks-DPghSHV7.js";
 import { n as AnalystRegistryLike } from "./types-qsqfyQoY.js";
 import { AgentIdentity } from "@tangle-network/agent-trace-contract";
 import { AgentCandidateArtifactRef, AgentCandidateWorkspaceManifestMaterial, AgentCandidateWorkspaceSnapshotEvidence, AgentExactRunControlRef, AgentInteractiveSession, AgentInteractiveSessionControlClaim, AgentInteractiveSessionPromptAcknowledgement, AgentInteractiveSessionPromptCommand, AgentInteractiveSessionRef, AgentInteractiveSessionStart, AgentNativeContextContinuationOptions, AgentNativeContextContinuationResult, AgentProfile, AgentProfile as AgentProfile$2, AgentProfile as AgentProfile$3, AgentProfileDiff, AgentProfileMcpServer, AgentProfilePrompt, AgentProfileSecurityPolicy, AgentSessionStatus, AgentTurnResult, ChildTaskEvent, ContextTransferReceipt, ContextTransferRequest, HarnessType, InputPart, InteractionAcknowledgement, InteractionRequest, InteractionResponseCommand, NativeContextBoundaryProof, NativeContextContinuationRequest, NativeContextContinuationTurn, ReasoningEffort, RequestedInteractions, RuntimeEventEnvelope, Sha256Digest, StreamEvent, TokenUsage, WorkspaceCheckpointRef, WorkspaceCheckpointRequest } from "@tangle-network/agent-interface";
@@ -8,6 +8,7 @@ import { AgentEvalError, AgentEvalError as AgentEvalError$1, AgentEvalErrorCode,
 import { AgentRunOutcome } from "@tangle-network/sandbox/runtime";
 import { BackendType, CreateRequestOptions, CreateSandboxOptions, CreateSandboxOptions as CreateSandboxOptions$1, PromptOptions, SandboxEvent, SandboxEvent as SandboxEvent$1, SandboxInstance, SandboxInstance as SandboxInstance$1, SandboxResources } from "@tangle-network/sandbox";
 import { z } from "zod";
+import { AgentEnvironment, AgentEnvironment as AgentEnvironment$1, AgentEnvironmentCapabilities, AgentEnvironmentCapabilities as AgentEnvironmentCapabilities$1, AgentEnvironmentEvent, AgentEnvironmentEvent as AgentEnvironmentEvent$1, AgentEnvironmentProvider, AgentEnvironmentProvider as AgentEnvironmentProvider$1, AgentEnvironmentQuery, AgentEnvironmentStatus, AgentEnvironmentSummary, AgentSession, AgentSessionRef, AgentSessionStatus as AgentSessionStatus$1, AgentTurnFailure, 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 { watch } from "node:fs";
 import { ChildProcess } from "node:child_process";
 import { HarnessId, WorkspacePlanReceipt } from "@tangle-network/agent-profile-materialize";
@@ -16,7 +17,6 @@ import { AnalystRegistry, AnalystRunInputs as AnalystRunInputs$1, AnalystRunResu
 import { DispatchFn, ExternalOptimizerModelCall, JudgeConfig, NodeEstimate, ProfileDispatchFn, RunProfileMatrixOptions, RunProfileMatrixResult, Scenario, SearchAllocator, SearchAudit, SearchCellResult, SearchClaim, SearchClaimVerification, SearchCloseReason, SearchHistoryReceipt, SearchNodeStatus, SearchPolicy, SearchRecorder, 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, 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";
 /** Cursor plus runtime sequence needed to continue one ordered replay. @stable */
 interface RetainedRunReplayPoint {
@@ -1178,6 +1178,11 @@ type ExecutorProgressEvent = {
   readonly toolName: string;
   readonly toolCallId?: string;
   readonly result?: unknown;
+  readonly status?: 'ok' | 'error';
+  readonly error?: {
+    readonly type: string;
+    readonly message: string;
+  };
 } | {
   readonly kind: 'interaction';
   readonly request: InteractionRequest;
@@ -1285,72 +1290,6 @@ type UsageEvent = {
 } | {
   kind: 'iteration';
 };
-/** The caller-owned boundary used to retain an executable provider workspace. */
-interface ProviderWorkspaceRetentionPort {
-  /** Maximum wall-clock time Runtime gives queueing, capture, and verification. */
-  readonly timeoutMs: number;
-  /**
-   * Maximum simultaneous captures and verifications using this exact port object, including
-   * recursive children. Omit for no admission bound. Share the port to share the bound.
-   * Timed-out callbacks keep their slot until they settle, even if they ignore cancellation.
-   */
-  readonly maxConcurrentCaptures?: number;
-  /** Same explicit archive bounds used by the capture callback. */
-  readonly limits?: Partial<AgentCandidateWorkspaceArchiveLimits>;
-  /** Refuse cleanup while any native session or workspace coverage remains missing. */
-  readonly requireCompleteProvenance?: boolean;
-  /** Reads the durable manifest and archive after capture returns. */
-  readonly artifacts: AgentCandidateArtifactPort;
-  /** Capture the live environment into the standard candidate workspace evidence shape. */
-  capture(context: ProviderWorkspaceRetentionContext): Promise<AgentCandidateWorkspaceSnapshotEvidence | ProviderWorkspaceCaptureResult>;
-  /**
-   * Capture only the harness's native session evidence, without the workspace, into the same
-   * durable artifacts, reporting `workspaceScope: 'none'`.
-   *
-   * Runtime calls it every {@link nativeIntervalMs} while a turn runs and once more on every way
-   * the turn ends: settled, failed, and an abort or deadline that closes the stream without
-   * reaching either. A crash, deadline, credential renewal, reap or coordinator loss then loses
-   * at most one interval of the session, and a workspace too large to capture no longer costs
-   * the session. Measured before this existed: 85 of the 116 Discovery nodes that ran on Runtime
-   * 0.297.x kept no session because their turn ended on an abort path, which never captured.
-   *
-   * When a deadline or an explicit cancellation ends a retained turn, Runtime stops its harness
-   * and waits for the provider to report it stopped, within a 30 s bound, before the failure
-   * capture and the final native copy, so both read a session that has stopped changing.
-   *
-   * Its captures use their own queue and bound, so they never wait behind workspace captures.
-   */
-  captureNative?(context: ProviderWorkspaceRetentionContext): Promise<ProviderWorkspaceCaptureResult>;
-  /**
-   * Store one workspace checkpoint's files in the run's content-addressed store, before Runtime
-   * deletes the checkpoint. Return what `captureAgentCandidateWorkspaceTreeToArtifacts` returns
-   * for the files the environment holds, written to {@link artifacts}.
-   *
-   * A checkpoint is a provider snapshot that Runtime takes while a director works and deletes
-   * once two newer ones exist. Its files are read from a fork Runtime creates from the snapshot
-   * for this call alone: the fork holds exactly the checkpoint's workspace and runs no harness,
-   * so the capture has no session to copy. Runtime verifies the tree against the store and the
-   * checkpoint's marker file, journals its digest, and destroys the fork. Without this method, or
-   * when a capture fails, Runtime keeps the checkpoint: on Discovery Lab run
-   * terraform-dc-tokens-20261006d, 76 of the first 101 checkpoint deletions removed the only copy
-   * of a director's workspace at that moment.
-   *
-   * Captures run on their own queue of {@link maxConcurrentCaptures} slots, under {@link timeoutMs}.
-   */
-  captureCheckpoint?(context: ProviderCheckpointCaptureContext): Promise<AgentCandidateWorkspaceTree>;
-  /** Capture a running environment's workspace without waiting for its turn to settle. */
-  captureLive?(context: ProviderWorkspaceRetentionContext): Promise<AgentCandidateWorkspaceTree>;
-  /** Time between live workspace captures. Omit to leave live capture disabled. */
-  readonly liveIntervalMs?: number;
-  /** Bound on one live capture and verification, including queue wait. Defaults to timeoutMs. */
-  readonly liveTimeoutMs?: number;
-  /** Milliseconds between native captures of a running turn. Default 120,000. */
-  readonly nativeIntervalMs?: number;
-  /** Bound on one native capture, including its queue wait. Default 120,000. */
-  readonly nativeTimeoutMs?: number;
-}
-/** When {@link ProviderWorkspaceRetentionPort.captureNative} runs relative to its turn. */
-type ProviderNativeCapturePhase = 'running' | 'settled' | 'failed' | 'interrupted';
 /** Source inventory metadata for a workspace entry. */
 interface ProviderWorkspaceEntryMetadata {
   readonly path: string;
@@ -1473,43 +1412,6 @@ interface ProviderWorkspaceCaptureResult {
    *  total; on canary test-acceptance-canary-20261019q the split was in the port alone. */
   readonly stages?: Readonly<Record<string, number>>;
 }
-/** The exact live execution facts supplied to a retention callback. */
-interface ProviderWorkspaceRetentionContext {
-  readonly environment: AgentEnvironment;
-  /** Runtime invocation identity used by the artifact store; never a provider session coordinate. */
-  readonly executionId: string;
-  /** Exact admitted provider execution, available even before the harness emits its session id. */
-  readonly controlRef?: AgentExactRunControlRef;
-  /** Exact supervised tree identity, when a supervisor created this execution. */
-  readonly node?: ExecutorNodeContext;
-  /** Sandbox/provider session used for this turn; null means no session id was observed. */
-  readonly providerSessionId?: string | null;
-  /** The harness's own session identity is unknown until a provider reports it. */
-  readonly nativeSessionId?: string | null;
-  /** The exact profile used to create the provider environment. */
-  readonly profile: AgentProfile;
-  /** The provider-derived outcome, when one was available before cleanup. */
-  readonly outcome?: AgentRunOutcome;
-  /** Set on native captures only: whether the turn was still running or how it ended. */
-  readonly phase?: ProviderNativeCapturePhase;
-  /** A fresh signal bounded by {@link ProviderWorkspaceRetentionPort.timeoutMs}. */
-  readonly signal: AbortSignal;
-}
-/** What {@link ProviderWorkspaceRetentionPort.captureCheckpoint} receives. */
-interface ProviderCheckpointCaptureContext {
-  /** A fork of the checkpoint, created for this capture alone. It holds the checkpoint's
-   *  workspace and runs no harness. */
-  readonly environment: AgentEnvironment;
-  /** The checkpoint the fork was created from. */
-  readonly checkpoint: WorkspaceCheckpointRef;
-  /** Runtime artifact identity of this capture: `<node>:checkpoint:<checkpoint id>`. */
-  readonly executionId: string;
-  /** The owner's profile; its harness names what the fork's source ran. */
-  readonly profile: AgentProfile;
-  /** A fresh signal bounded by {@link ProviderWorkspaceRetentionPort.timeoutMs}. */
-  readonly signal: AbortSignal;
-}
-/** Durable join from one provider box to the verified bytes retained before cleanup. */
 interface ProviderWorkspaceCaptureReceipt {
   readonly executionId: string;
   /** Durable provider-native identity, separate from the Runtime invocation identity. */
@@ -2321,7 +2223,7 @@ interface ExecutorResult<Out> {
   /** Explicit execution outcome; application output and scoring verdicts do not determine failure.
    *  `errorCode` is the provider's machine code for a failure when it reported one. A retry policy
    *  reads the code, never the human `error` text. */
-  outcome?: Pick<AgentTurnResult, 'success' | 'error'> & {
+  outcome?: Pick<AgentTurnResult, 'success' | 'error' | 'failure'> & {
     errorCode?: string;
     /** Native HTTP failure status, when reported, in the range 400–599. */
     statusCode?: number;
@@ -2616,16 +2518,16 @@ interface ExecutorRegistry {
  *  `reconcile`. Carries the reserved ceilings so reconciliation needs no lookup. */
 interface ReservationTicket {
   readonly id: number;
+  /** Child ceilings, including caps enforced without a corresponding root reservation.
+   * Absent on historical tickets, whose reserved amounts remain their ceilings. */
+  readonly limits?: Pick<Budget, 'maxTokens' | 'maxIterations'>;
   readonly reserved: {
     readonly resources?: Budget['resources'];
     readonly tokens: number;
     readonly usd: number;
     readonly iterations: number;
-    /**
-     * Whether the child's `Budget` declared `maxUsd`. `reserved.usd` is `0` for both an undeclared
-     * ceiling (real dollars are committed as OBSERVED spend) and a declared `$0` (a breach is
-     * fail-loud). An absent flag is read as `true`, the fail-closed reading.
-     */
+    /** Distinguishes an undeclared USD ceiling (observed cost) from a declared zero cap.
+     * Historical absent flags default to capped. */
     readonly usdBudgeted?: boolean;
   };
 }
@@ -2648,9 +2550,8 @@ interface ReservationHolder {
 interface LeakedReservation extends ReservationHolder {
   readonly ticketId: number;
 }
-/** Post-reservation pool readout — the shape `Scope.budget` exposes. `deadlineMs` is the ABSOLUTE
- *  wall-clock deadline (0 when none). `usdCapped` distinguishes a real `usdLeft <= 0` exhaustion
- *  from an uncapped pool (which always reads `usdLeft: 0`). */
+/** `Scope.budget`: absolute deadline (0 when absent), current backing and committed cost.
+ * An uncapped USD channel reads 0; `usdCapped` distinguishes it from exhaustion. */
 type BudgetReadout = Readonly<{
   resources?: Readonly<Record<string, {
     unit: string;
@@ -2661,20 +2562,21 @@ type BudgetReadout = Readonly<{
     known: boolean;
   }>>;
   tokensLeft: number;
-  /** False once the pool recorded work with UNREPORTED tokens (`tokensKnown: false`): `tokensLeft`
-   *  is then a ceiling, and real consumption is at least the debited amount. */
+  /** Explicit false means uncapped; older readouts without this flag were capped. */
+  tokensCapped?: boolean;
+  /** Committed token charge, including conservative unknown-work debits on restore. */
+  committedTokens?: number;
+  /** False means observed token counts are a lower bound and remaining capacity is a ceiling. */
   tokensKnown: boolean;
-  /** False once the pool charged a REPORTED spend whose prompt-cache split it could not read: the
-   *  unclassified prompt tokens were charged in full, so the debit is an upper bound. Separate from
-   *  `tokensKnown` (counts arrived, composition did not); a restored uncertain reservation leaves
-   *  it alone, since a declared ceiling has no composition to misread. */
+  /** False means reported tokens lacked a cache split and were charged in full.
+   * This differs from unreported counts; uncertain restored ceilings do not taint the split. */
   cacheBreakdownKnown: boolean;
   usdLeft: number;
   usdCapped: boolean;
-  /** False once any recorded work reported an unknown dollar cost; the dollar totals are then a
-   *  lower bound on real spend, not a measurement. */
+  /** False means recorded dollars are a lower bound rather than a complete measurement. */
   usdKnown: boolean;
   iterationsLeft: number;
+  iterationsCapped?: boolean;
   deadlineMs: number;
   reservedTokens: number;
 }>;
@@ -2687,8 +2589,7 @@ interface ReservationFloor {
 }
 /** How a caller asks for a reservation. */
 interface ReserveOptions {
-  /** Wait for budget instead of failing, when the reservations still open would return enough.
-   *  The reservation then holds nothing until it is granted. */
+  /** Queue an existing invocation until actual settlements fund it; hold nothing meanwhile. */
   readonly wait?: boolean;
   /** Leave this owner share free after the reservation, less what `observe` already charged. */
   readonly keep?: ReservationFloor;
@@ -2696,41 +2597,29 @@ interface ReserveOptions {
 /** Why a reservation was refused. `usd-unbudgeted`: the root declared no dollar ceiling, so the
  * fix is to budget the root, not to ask for less. */
 type ReservationRejection = 'budget-exhausted' | 'usd-unbudgeted';
-/** One channel a `budget-exhausted` reservation could not fit. A refusal lists every such channel
- * so shrinking one request is not met by a second refusal (a director whose 100-iteration child
- * was refused spent a probe worker to learn the pool admitted 3). `free` is a snapshot, and a
- * driver's metered turns draw from the same pool, so only `iterations` can be requested at exactly
- * `free`. `closedByUnknownSpend`: unmeasured usage ran under that enforced limit, so the channel
- * refuses every reservation for the rest of the run. */
+/** Every unfunded channel in one refusal. `free` is a live snapshot, not a future refund.
+ * Unknown enforced usage closes that channel to new reservations for the rest of the run. */
 interface ReservationShortfall {
   readonly channel: 'tokens' | 'iterations' | 'usd' | `resource:${string}`;
   readonly requested: number;
   readonly free: number;
-  /** What open reservations hold on this channel, when they hold any. A request of at most
-   *  `free + held` can wait for them to settle; a larger one never fits. */
+  /** What open reservations hold now; this is not a prediction of future refunds. */
   readonly held?: number;
   readonly closedByUnknownSpend?: true;
 }
-/** State recovered from a prior process before new work is admitted. `committed` is measured spend
- * already present in the durable journal. Each `uncertainReservation` is a child that was recorded
- * as started but never recorded as settled: its full declared ceiling is charged conservatively,
- * while the public readout remains explicitly unknown. */
+/** Durable spend, unknown-work ceilings and remaining backing restored before new admission. */
 interface BudgetPoolRestore {
   readonly committed?: Spend;
   /** The part of `committed` the owner's own work spent, charged against its kept share. */
   readonly owner?: Spend;
   readonly uncertainReservations?: ReadonlyArray<Budget>;
+  /** Precisely journaled remaining liabilities, separate from historical unmeasured ceilings. */
+  readonly heldReservations?: ReadonlyArray<Budget>;
 }
 interface BudgetPool {
-  /**
-   * Atomically reserve a child's full ceiling from the free balance; fails closed
-   * ({ ok: false }) when the pool can't cover standard or named channels.
-   *
-   * With `wait`, a request that could fit once open reservations return is admitted as a WAITING
-   * ticket: `granted` resolves when reserved and rejects with `ReservationWaitRefused` once
-   * nothing open could return enough. A waiting ticket reserves nothing; reconciling it withdraws
-   * it. New waiting requests queue behind existing waiters, so asking order is grant order.
-   */
+  /** Reserve a complete ceiling from current funds. `wait` holds nothing while funded
+   * tickets remain open; `granted` resolves after actual refunds, or rejects when none
+   * can fund it. Unfunded reservations retain asking order and reconcile withdraws them. */
   reserve(b: Budget, holder?: ReservationHolder, options?: ReserveOptions): {
     ok: true;
     ticket: ReservationTicket;
@@ -2743,30 +2632,23 @@ interface BudgetPool {
   /** Name (or rename) who holds an open reservation, merging into what `reserve` recorded. A
    *  settled or unknown ticket is ignored: attribution is leak EVIDENCE, never a lifecycle guard. */
   attribute(ticket: ReservationTicket, holder: ReservationHolder): void;
-  /**
-   * Release a reservation: commit the actual `spent`, refund the remainder. Throws on an unknown
-   * or already-reconciled ticket (a double refund would break conservation). Returns the
-   * overspend, after committing it; throws, also after committing, when the spend cannot be
-   * verified (unknown dollars under a cap, unknown or overflowing enforced-resource usage).
-   */
+  /** Close the ticket, commit actual cost and refund unused capacity. Unknown/double
+   * tickets throw. Overspend is returned after commit; unverifiable capped usage throws.
+   * Scope-owned custody backing survives execution until its acknowledged release. */
   reconcile(ticket: ReservationTicket, spent: Spend): BudgetViolation | undefined;
   /** Fold a normalized `UsageEvent` stream (or array) into a `Spend`; `ms` is left zero. */
   spendFrom(events: AsyncIterable<UsageEvent> | UsageEvent[]): Promise<Spend>;
   /** The current readout, reflecting all outstanding reservations. */
   readout(): BudgetReadout;
-  /**
-   * Record OBSERVED spend outside reserve/reconcile — the driver's OWN inference. A direct
-   * `free → committed` debit preserving the invariant; `free` may go negative on overspend.
-   * Unknown enforced resource usage is recorded before throwing; partial increments defer
-   * completeness checks until the terminal spend. Unknown dollars under a cap are refused, unless
-   * `alreadySpent` says the work finished with no caller left to refuse (that closes dollar
-   * admission instead). The DURABLE record is the journal's `metered` event (`Scope.meter`).
-   */
+  /** Debit observed owner work; overspend may leave free capacity negative. Unknown
+   * resources are recorded before throwing; partial observations defer completeness.
+   * Unknown capped dollars are refused unless `alreadySpent` requires recording them
+   * and closing admission. `Scope.meter` supplies the corresponding durable record. */
   observe(spend: Spend, options?: {
     partial?: boolean;
     alreadySpent?: boolean;
   }): void;
-  /** Fail loud if any reservation is still open — the leak detector, called at the join barrier. */
+  /** Reject open execution tickets at join; confirmed custody liabilities may remain backed. */
   assertNoOpenTickets(): void;
   /** Every reservation still open, with its holder; lets a failed run REPORT a leak. */
   openReservations(): ReadonlyArray<LeakedReservation>;
@@ -3579,18 +3461,8 @@ interface NodeSnapshot {
   readonly spawnedAt?: number;
   /** Conserved spend so far for this node. */
   readonly spent: Spend;
-  /**
-   * The node's executor has FINISHED and its settlement is queued for the manager to drain with
-   * its next wake/`next()`, but `status` still reads as it did while running because the settle
-   * transition happens at drain time. Present only in that window; absent once drained or while
-   * the executor is still live. Carries the terminal kind so a manager polling `observe_agent`
-   * can tell "still working" from "finished, waiting for you to read it".
-   *
-   * Measured 2026-09-17 (discovery-lab sandbox-a-20260917h): two children finished 30 s after
-   * dispatch; the manager polled `observe_agent` eleven times over 56 minutes, read `running`
-   * each time, stopped draining because the status said work was in flight, and recorded the
-   * opposite of the truth about its own experiment. agent-runtime#1279.
-   */
+  /** Finished execution whose result the manager has not read. Terminal status/failure are
+   * published after durable settlement, independently of this delivery marker. */
   readonly settlementPending?: {
     readonly kind: 'done' | 'down';
   };
@@ -3660,10 +3532,10 @@ interface ResourceSpend {
   readonly amount: number;
   readonly known: boolean;
 }
-/** A budget envelope on a spawn or the root. All ceilings; the pool reserves against them. */
+/** Explicit ceilings on a spawn or root. An omitted channel is uncapped and reserves nothing. */
 interface Budget {
-  readonly maxIterations: number;
-  readonly maxTokens: number;
+  readonly maxIterations?: number;
+  readonly maxTokens?: number;
   readonly maxUsd?: number;
   readonly deadlineMs?: number;
   readonly resources?: Readonly<Record<string, ResourceLimit>>;
@@ -4240,8 +4112,6 @@ interface SupervisorOpts {
    * releases nothing under either value.
    */
   readonly retainedAtSettlement?: 'release' | 'keep';
-  /** @internal Whether provider-backed retained owner cleanup must preserve unreceipted sources. */
-  readonly ownerWorkspaceRetention?: boolean;
   readonly now?: () => number;
   readonly signal?: AbortSignal;
   /** Lifecycle stream sink, threaded into the root `Scope` so every `spawn`/settle emits on the
@@ -4319,6 +4189,8 @@ interface TraceRootReceipt {
 type SpawnEvent = {
   kind: 'spawned';
   id: NodeId;
+  /** Kernel attempt identity also identifies grant-clock admission in crash prefixes. */
+  attemptId?: string;
   parent?: NodeId;
   label: string;
   /** The semantic spawn key (`SpawnOpts.key`), when the spawn carried one — what a resumed
@@ -4355,6 +4227,24 @@ type SpawnEvent = {
   modelSubstitution?: SpawnModelSubstitution;
   seq: number;
   at: string;
+} | {
+  /** An admitted node waits on this gate; this is not provider dispatch evidence. */
+  kind: 'admission-queued';
+  id: NodeId;
+  attemptId: string;
+  gate: 'budget' | 'slot' | 'seat';
+  resumeAt?: string;
+  seq: number;
+  at: string;
+} | {
+  /** The original execution grant and its one absolute deadline, preserved on recovery. */
+  kind: 'admission-granted';
+  id: NodeId;
+  attemptId: string;
+  deadlineArmedAt: string;
+  deadlineAt?: string;
+  seq: number;
+  at: string;
 } | {
   /** Exact task bytes durable before admitting a retained invocation. */
   kind: 'execution-input';
@@ -4601,6 +4491,10 @@ type SpawnEvent = {
   kind: 'reconciled';
   id: NodeId;
   spent: Spend;
+  /** Remaining backing of an active seat-paused allocation, including unacknowledged or
+   * unmeasured liabilities. Execution may already be terminal; only later custody/accounting
+   * evidence reduces this backing. It never grants execution. */
+  reservation?: Budget;
   /** The transcript receipt of a retained-pending child. This record is the ONLY durable home
    *  it has: the node writes no `settled` record while its slot stays open, and these are the
    *  #1244 children exactly — dropped mid-run with a live box the capture read. A later
@@ -4682,8 +4576,8 @@ type SpawnEvent = {
   seq: number;
   at: string;
 } | {
-  /** A `teardown-pending` node whose teardown a retry inside the settlement window confirmed:
-   *  the executor destroyed what it held. Informational, outside the cursor namespace. */
+  /** The executor confirmed its node cleanup, on the first pass or after a pending retry.
+   * Informational, outside the cursor namespace; no provider resource identity is inferred. */
   kind: 'teardown-confirmed';
   id: NodeId;
   seq: number;
@@ -5174,6 +5068,110 @@ declare class InMemorySpawnJournal implements SpawnJournal {
   beginTree(root: NodeId, at: string): Promise<void>;
   appendEvent(root: NodeId, ev: SpawnEvent): Promise<void>;
 }
+/** One durable run-scoped cancel request: cancel the WHOLE run, not one worker. */
+interface RunCancelRequest {
+  /** Caller-minted stable operation identifier — the idempotency key of the whole operation. */
+  readonly operationId: string;
+  /** ISO timestamp of the write. */
+  readonly at: string;
+  /** Who asked — 'human', a brain label, a tool name. Provenance, not authorization. */
+  readonly source: string;
+  /** Requested observation target, measured by the acknowledgement's deadlineExceeded field.
+   * The observer always cascades eagerly. This does not guarantee scheduler latency or cleanup. */
+  readonly deadlineMs?: number;
+  /** Who stops the run. `cancelRun` requires it on every new request; it is optional here only
+   *  so a request written before that rule still reads. The settle record carries it. */
+  readonly operator?: string;
+  readonly reason?: string;
+}
+/**
+ * The durable acknowledgement state for the run-scoped cancel operation, keyed by `operationId`.
+ * The runtime is the ONLY writer; {@link cancelRun} only reads it.
+ *
+ * `effect` is the same {@link RetainedRunEffect} vocabulary the worker-scoped and retained-run
+ * paths use, so the runtime has one spelling of the four cancellation states:
+ *  - `'unknown'`          — no runtime has answered yet. Never a success.
+ *  - `'cancel_requested'` — the root manager issued the run's cascading abort; the run's terminal
+ *                           state is not yet observed.
+ *  - `'cancelled'`        — the run reached its terminal cancelled state with confirmed teardown.
+ *  - `'not_live'`         — the run was not live to cancel: it settled on its own despite the
+ *                           request, or it ended before the request was applied.
+ */
+interface RunCancellation {
+  /** Runtime path that issued the cascade. */
+  readonly path?: 'observer' | 'turn-boundary' | 'fallback';
+  /** Runtime clock elapsed between request timestamp and cascade application. */
+  readonly appliedAfterMs?: number;
+  /** Whether application exceeded the requested deadlineMs; absent when no target was requested. */
+  readonly deadlineExceeded?: boolean;
+  readonly operationId: string;
+  readonly effect: RetainedRunEffect;
+  /** ISO timestamp of the original request. */
+  readonly requestedAt: string;
+  /** ISO timestamp of the runtime's most recent observation of this operation. */
+  readonly observedAt: string;
+  /** The caller's reason, carried verbatim from the request. */
+  readonly reason?: string;
+  /** The caller's operator identity, carried verbatim from the request. */
+  readonly operator?: string;
+  /** The runtime's explanation of how it arrived at `effect`. */
+  readonly detail?: string;
+}
+/** Read the run-scoped cancel request, or `undefined` when none was written. */
+declare function readRunCancelRequest(eventDir: string): RunCancelRequest | undefined;
+/**
+ * Read the acknowledgement for the run-scoped cancel operation. `undefined` when the runtime has
+ * not answered. A record holding a DIFFERENT `operationId` belongs to another operation on the
+ * same run — fail loud rather than answer for it.
+ */
+declare function readRunCancellation(eventDir: string, operationId: string): RunCancellation | undefined;
+/**
+ * Request the cancellation of the WHOLE run, idempotently, and return the operation's current
+ * durable state.
+ *
+ * The run-scoped twin of {@link cancelWorker}: write the request into the run's cancellation
+ * directory, where the run's own root manager applies it — aborting the root through the one
+ * cascade controller the run already has, so every live worker comes down with it. This function
+ * never applies the cancellation itself; writing a request file is not an acknowledgement.
+ *
+ * Idempotency is a lookup: when an acknowledgement for `operationId` already exists it is returned
+ * AS-IS and nothing is written. A retry that changes the source, reason, deadline, or operator
+ * fails closed. A request the runtime has not answered yet returns `effect: 'unknown'` (never a
+ * success); call again with the same `operationId` — or {@link readRunCancellation} — to read the
+ * acknowledged result after a reconnect.
+ *
+ * A run carries ONE run-scoped operation: a second request under a different `operationId` throws
+ * rather than silently replacing the pending one, because both would claim the same single abort.
+ * Reopening a settled run (`supervisePursuit`'s `reopen`) moves that operation aside.
+ *
+ * A NEW request must name its `operator`, so every stop says who made it. A replay of a request
+ * or acknowledgement written before that rule is answered as it was.
+ */
+declare function cancelRun(eventDir: string, operationId: string, options?: {
+  readonly reason?: string;
+  readonly source?: string;
+  readonly deadlineMs?: number;
+  readonly operator?: string;
+}): RunCancellation;
+/** Runtime evidence only. Product-specific launch, checks and trace completeness belong to callers. */
+interface RunState {
+  /** Absent when a recorded holder cannot be verified on this host. */
+  readonly phase?: 'running' | 'parked' | 'cancelling' | 'settled' | 'down';
+  /** A persisted typed root failure; legacy failure messages do not establish a code. */
+  readonly failureCode?: RuntimeFailureCause['code'];
+  readonly settle?: SupervisedResult<unknown>;
+  readonly cancelRequest?: RunCancelRequest;
+  /** Absent when holder liveness is unknown. This is advisory, never ownership authorization. */
+  readonly holderLive?: boolean;
+  /** Latest explicit Runtime timestamp observed, as ISO UTC; never a filesystem mtime. */
+  readonly lastActivityAt?: string;
+}
+/** Compose maintained record readers. Terminal settlement outranks cancellation and parking;
+ * a request remains cancelling until settlement. An unheld run with evidence is down.
+ * No Runtime evidence (including a missing or empty directory) returns undefined. Reads are
+ * advisory snapshots across independently published files, not a transaction or a resume gate.
+ */
+declare function readRunState(runDir: string): Promise<RunState | undefined>;
 /**
  * JSONL on disk. One line per record: the first record is `begin`, subsequent records
  * are `event` or atomic `events` envelopes. `loadTree` replays the whole file,
@@ -5198,6 +5196,45 @@ declare class FileSpawnJournal implements SpawnJournal {
   private serializeAppend;
   private writeRecord;
 }
+/** Serializable checkpoint of a committed byte boundary, bound to one file and its bytes. */
+interface SpawnJournalCursor {
+  readonly file: string;
+  readonly offset: number;
+  readonly boundary: string;
+}
+/** Physical groups expand to event records; the owning tree is preserved for every event. */
+type SpawnJournalReadRecord = {
+  readonly kind: 'begin';
+  readonly root: NodeId;
+  readonly at: string;
+} | {
+  readonly kind: 'event';
+  readonly root: NodeId;
+  readonly event: SpawnEvent;
+};
+interface SpawnJournalReadOptions {
+  readonly after?: SpawnJournalCursor;
+  /** Initial opening-and-tail window, or an incremental page's byte budget. A crossing record
+   * is read whole, so one large record can exceed this budget. Omit for complete history. */
+  readonly tailBytes?: number;
+}
+interface SpawnJournalReadResult {
+  readonly records: ReadonlyArray<SpawnJournalReadRecord>;
+  /** Absent only when the journal does not exist. Treat as opaque and persist unchanged. */
+  readonly cursor?: SpawnJournalCursor;
+  /** The supplied cursor no longer matches; this page starts over. */
+  readonly reset: boolean;
+  /** An initial opening-and-tail window omitted records between its two windows. */
+  readonly truncated: boolean;
+  /** Bytes after the committed cursor in this snapshot, including an incomplete final write. */
+  readonly remainingBytes: number;
+}
+/** Read a fixed journal prefix, with historical envelopes and framing owned by Runtime.
+ * Missing journals return an empty page. Malformed committed records fail; incomplete final
+ * writes remain unread for the next call. Cursors detect replacement, truncation and edits at
+ * their sampled opening/boundary; they are not integrity proofs against arbitrary file edits.
+ */
+declare function readSpawnJournal(runDir: string, options?: SpawnJournalReadOptions): Promise<SpawnJournalReadResult>;
 /**
  * Re-feed a journaled spawn tree in strict `seq` order, rehydrating each settled
  * child's `out` from the blob store by `outRef`, and return the `Settled[]` exactly
@@ -6734,42 +6771,6 @@ interface InPlaceHarnessResult {
   /** The harness subprocess outcome. */
   harness: WorktreeHarnessResult['harness'];
 }
-/** One durable capture before a Sandbox box is removed. */
-interface SandboxEvidenceRetentionPort {
-  readonly timeoutMs: number;
-  readonly limits?: Partial<AgentCandidateWorkspaceArchiveLimits>;
-  readonly artifacts: AgentCandidateArtifactPort;
-  capture(context: SandboxEvidenceContext & {
-    readonly signal: AbortSignal;
-  }): Promise<{
-    readonly snapshot: AgentCandidateWorkspaceSnapshotEvidence;
-    readonly provenance: ProviderWorkspaceCaptureProvenance;
-  }>;
-  /** Must durably record this exact verified receipt before returning. */
-  record(receipt: SandboxEvidenceReceipt): Promise<void>;
-}
-interface SandboxEvidenceContext {
-  readonly box: SandboxInstance;
-  readonly executionId: string;
-  readonly profile: AgentProfile;
-  readonly sandboxSessionIds: ReadonlyArray<string>;
-  readonly nativeSessionIds?: ReadonlyArray<string>;
-  readonly sessionExecutionIds: Readonly<Record<string, ReadonlyArray<string>>>;
-}
-interface SandboxEvidenceReceipt {
-  readonly boxId: string;
-  readonly executionId: string;
-  /** Exact authored profile identity without copying credentials into the receipt. */
-  readonly profileDigest: string;
-  readonly scope: 'box';
-  readonly sandboxSessionIds: ReadonlyArray<string>;
-  readonly nativeSessionIds?: ReadonlyArray<string>;
-  readonly sessionExecutionIds: Readonly<Record<string, ReadonlyArray<string>>>;
-  readonly snapshot: AgentCandidateWorkspaceSnapshotEvidence;
-  readonly provenance: ProviderWorkspaceCaptureProvenance;
-  readonly coverageComplete: boolean;
-  readonly incompleteReason?: string;
-}
 /** @stable */
 interface RunAgentRoundsOptions<Task, Output, Decision> {
   driver: Driver<Task, Output, Decision>;
@@ -6788,8 +6789,6 @@ interface RunAgentRoundsOptions<Task, Output, Decision> {
   validator?: Validator<Output>;
   task: Task;
   ctx: ExecCtx;
-  /** Durable Sandbox evidence capture required before any worker box cleanup. */
-  evidenceRetention?: SandboxEvidenceRetentionPort;
   /** Default 10. Hard cap on total iterations across all `plan()` rounds. */
   maxIterations?: number;
   /** Default 4. In-flight worker cap within a single `plan()` batch. */
@@ -9345,8 +9344,6 @@ interface ProviderExecutorOptions {
    * back to its own settle verdict.
    */
   validator?: Validator<ProviderLeafOut>;
-  /** Capture and verify a portable executable workspace before Runtime destroys the environment. */
-  workspaceRetention?: ProviderWorkspaceRetentionPort;
   /** Transform only the profile sent to `provider.create`. The original profile
    * remains the input to `taskToTurn`, so execution-only normalization cannot
    * rewrite the caller's task mapping. */
@@ -9365,8 +9362,7 @@ interface ProviderExecutorOptions {
    * spawn event, and each continuation as the node's next `execution-input`.
    *
    * Applies to a retained execution under a Scope, the path a supervised leaf takes on a provider
-   * that declares `retainedControl`. Workspace retention verifies each invocation separately;
-   * failed capture or required incomplete coverage preserves the source and stops continuation.
+   * that declares `retainedControl`.
    * `false` ends the execution on the refused turn.
    */
   unavailablePause?: UnavailablePausePolicy | false;
@@ -9600,7 +9596,6 @@ interface SteerableSandboxArgs {
   readonly sandboxClient: SandboxClient;
   /** Require capture failures at box cleanup to fail the supervised worker. */
   readonly failOnDestroyError?: boolean;
-  readonly workspaceCaptures?: () => ReadonlyArray<ProviderWorkspaceCaptureReceipt>;
   readonly inbox: Inbox;
   readonly taskToPrompt: (task: unknown) => string;
   readonly options?: SandboxSteeringOptions;
@@ -9637,8 +9632,6 @@ interface SandboxSeam {
   sandboxClient: SandboxClient;
   /** Surface evidence capture failures from session cleanup. */
   failOnDestroyError?: boolean;
-  /** Verified provider captures collected before session teardown. */
-  workspaceCaptures?: () => ReadonlyArray<ProviderWorkspaceCaptureReceipt>;
   /** Forwarded into the composed `runAgentRounds`'s `ctx` (trace emitter, run handle, etc.). */
   loopCtx?: Partial<Omit<ExecCtx, 'sandboxClient' | 'signal'>>;
   /** PR #150 `RunAgentRoundsOptions.lineage` passthrough — opaque; forwarded, not parsed. */
@@ -10651,91 +10644,6 @@ interface ReentryTaskInput {
 }
 /** Compose the task for one re-entered drive. */
 declare function composeReentryTask(input: ReentryTaskInput): string;
-/** One durable run-scoped cancel request: cancel the WHOLE run, not one worker. */
-interface RunCancelRequest {
-  /** Caller-minted stable operation identifier — the idempotency key of the whole operation. */
-  readonly operationId: string;
-  /** ISO timestamp of the write. */
-  readonly at: string;
-  /** Who asked — 'human', a brain label, a tool name. Provenance, not authorization. */
-  readonly source: string;
-  /** Requested observation target, measured by the acknowledgement's deadlineExceeded field.
-   * The observer always cascades eagerly. This does not guarantee scheduler latency or cleanup. */
-  readonly deadlineMs?: number;
-  /** Who stops the run. `cancelRun` requires it on every new request; it is optional here only
-   *  so a request written before that rule still reads. The settle record carries it. */
-  readonly operator?: string;
-  readonly reason?: string;
-}
-/**
- * The durable acknowledgement state for the run-scoped cancel operation, keyed by `operationId`.
- * The runtime is the ONLY writer; {@link cancelRun} only reads it.
- *
- * `effect` is the same {@link RetainedRunEffect} vocabulary the worker-scoped and retained-run
- * paths use, so the runtime has one spelling of the four cancellation states:
- *  - `'unknown'`          — no runtime has answered yet. Never a success.
- *  - `'cancel_requested'` — the root manager issued the run's cascading abort; the run's terminal
- *                           state is not yet observed.
- *  - `'cancelled'`        — the run reached its terminal cancelled state with confirmed teardown.
- *  - `'not_live'`         — the run was not live to cancel: it settled on its own despite the
- *                           request, or it ended before the request was applied.
- */
-interface RunCancellation {
-  /** Runtime path that issued the cascade. */
-  readonly path?: 'observer' | 'turn-boundary' | 'fallback';
-  /** Runtime clock elapsed between request timestamp and cascade application. */
-  readonly appliedAfterMs?: number;
-  /** Whether application exceeded the requested deadlineMs; absent when no target was requested. */
-  readonly deadlineExceeded?: boolean;
-  readonly operationId: string;
-  readonly effect: RetainedRunEffect;
-  /** ISO timestamp of the original request. */
-  readonly requestedAt: string;
-  /** ISO timestamp of the runtime's most recent observation of this operation. */
-  readonly observedAt: string;
-  /** The caller's reason, carried verbatim from the request. */
-  readonly reason?: string;
-  /** The caller's operator identity, carried verbatim from the request. */
-  readonly operator?: string;
-  /** The runtime's explanation of how it arrived at `effect`. */
-  readonly detail?: string;
-}
-/** Read the run-scoped cancel request, or `undefined` when none was written. */
-declare function readRunCancelRequest(eventDir: string): RunCancelRequest | undefined;
-/**
- * Read the acknowledgement for the run-scoped cancel operation. `undefined` when the runtime has
- * not answered. A record holding a DIFFERENT `operationId` belongs to another operation on the
- * same run — fail loud rather than answer for it.
- */
-declare function readRunCancellation(eventDir: string, operationId: string): RunCancellation | undefined;
-/**
- * Request the cancellation of the WHOLE run, idempotently, and return the operation's current
- * durable state.
- *
- * The run-scoped twin of {@link cancelWorker}: write the request into the run's cancellation
- * directory, where the run's own root manager applies it — aborting the root through the one
- * cascade controller the run already has, so every live worker comes down with it. This function
- * never applies the cancellation itself; writing a request file is not an acknowledgement.
- *
- * Idempotency is a lookup: when an acknowledgement for `operationId` already exists it is returned
- * AS-IS and nothing is written. A retry that changes the source, reason, deadline, or operator
- * fails closed. A request the runtime has not answered yet returns `effect: 'unknown'` (never a
- * success); call again with the same `operationId` — or {@link readRunCancellation} — to read the
- * acknowledged result after a reconnect.
- *
- * A run carries ONE run-scoped operation: a second request under a different `operationId` throws
- * rather than silently replacing the pending one, because both would claim the same single abort.
- * Reopening a settled run (`supervisePursuit`'s `reopen`) moves that operation aside.
- *
- * A NEW request must name its `operator`, so every stop says who made it. A replay of a request
- * or acknowledgement written before that rule is answered as it was.
- */
-declare function cancelRun(eventDir: string, operationId: string, options?: {
-  readonly reason?: string;
-  readonly source?: string;
-  readonly deadlineMs?: number;
-  readonly operator?: string;
-}): RunCancellation;
 /** The read-model a `StopRule` decides from — the run's progress, not its budget. */
 interface ProgressView {
   readonly now: number;
@@ -10992,6 +10900,8 @@ interface DriveHarness {
   harnessTranscript?(): HarnessTranscriptCapture | undefined;
   /** Resolves once {@link harnessTranscript} is final (`Executor.harnessTranscriptSettled`). */
   harnessTranscriptSettled?(): Promise<void>;
+  /** This harness owns the maintained seat chain's rotation and reset wait. */
+  readonly seatChain?: true;
   /** Close the last subscription segment at this logical manager's settlement. */
   closeSeatSegment?(reason: 'completed' | 'failed' | 'cancelled' | 'paused'): Promise<void>;
 }
@@ -11226,11 +11136,13 @@ type RootStreamRecord = {
 declare function readRootStreamReceipt(runDir: string, file?: string): Promise<RootStreamReceipt | undefined>;
 /** Every committed line of the root stream, in order, or `undefined` when there is no file. A
  *  torn final line from a process that died mid-write is not a record and is left out. */
-declare function readRootStream(runDir: string): Promise<RootStreamRecord[] | undefined>;
+declare function readRootStream(runDir: string, options?: {
+  readonly nodeId?: string;
+}): Promise<RootStreamRecord[] | undefined>;
 /** OTLP span attribute values; exported because `SupervisorSpanOptions.attributes` is public. */
 type SupervisorSpanAttributes = Record<string, string | number | boolean>;
 type Attrs = SupervisorSpanAttributes;
-interface SupervisorSpanOptions {
+interface SupervisorSpanOptions extends Pick<RuntimeTelemetryOptions, 'includeMetadata' | 'includeEvalDetails'> {
   /** The supervised run id (`SupervisorOpts.runId`): roots the trace and is the parent key of every depth-0 spawn. */
   readonly runId: string;
   /** Bring your own exporter: FLUSHED but never shut down by `finish()`. Takes precedence over `exportConfig`. */
@@ -11503,86 +11415,6 @@ interface SuperviseRegistry {
     names(): readonly string[];
   };
 }
-/** One re-entry, reported before it waits. */
-interface WorkerSpawnRetryAttempt {
-  /** 1-based: the attempt that just failed. */
-  readonly attempt: number;
-  /** How long this seam waits before re-entering `execute`. */
-  readonly waitMs: number;
-  /** The refused profile's name, when it declares one. */
-  readonly worker?: string;
-  readonly error: string;
-}
-/**
- * How hard a pre-spawn worker refusal is re-entered. Absent from `supervise` means NO retry — the
- * historical behaviour, and the conservative default: a worker failure already has a typed
- * settlement the driver can respond to, so adding silent latency to every run is not the runtime's
- * call to make.
- */
-interface WorkerSpawnRetryPolicy {
-  /** `false` disables the seam while leaving the option in a recorded run configuration. */
-  readonly enabled?: boolean;
-  /** Total wall-clock ms this seam may spend waiting for a slot, backoff included. Default 900000
-   *  — the span measured between saturation and the next free slot on a four-way host executor. */
-  readonly maxTotalMs?: number;
-  /** Wait before the first re-entry, doubling per attempt. Default 5000. */
-  readonly initialBackoffMs?: number;
-  /** Ceiling on the doubling. Default 60000. */
-  readonly maxBackoffMs?: number;
-  /**
-   * Extra PRE-SPAWN signatures a consumer's own admission layer emits, added to the built-in set.
-   *
-   * This widens which messages qualify, and it can only be used safely for a refusal the consumer
-   * knows is emitted before any provider call. The second proof — that the attempt yielded no
-   * execution event — still applies to every added signature, so a mistake here cannot cause a
-   * double-spend on a stream that had already started.
-   */
-  readonly additionalPreSpawnSignatures?: ReadonlyArray<RegExp>;
-}
-interface WorkerSpawnRetryHooks {
-  readonly onRetry?: (attempt: WorkerSpawnRetryAttempt) => void;
-  readonly now?: () => number;
-  readonly sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
-}
-/** A policy with every bound decided — what {@link retryPreSpawnRefusals} acts on. Produced by
- *  {@link resolveWorkerSpawnRetry}, never written by hand, so one reading of the defaults serves
- *  the `supervise` option and a caller-owned seam alike. */
-interface ResolvedWorkerSpawnRetry {
-  readonly maxTotalMs: number;
-  readonly initialBackoffMs: number;
-  readonly maxBackoffMs: number;
-  readonly signatures: ReadonlyArray<RegExp>;
-}
-/**
- * True when `error` is a backend refusal issued before anything ran.
- *
- * This answers "did this fail BEFORE any provider call", which is a strictly narrower question
- * than "is this an infrastructure hiccup". The broader question admits `ECONNRESET` and a bare
- * `fetch failed`, both of which can arrive after a metered call, and answering the broad question
- * where the narrow one is required is what makes a retry double-spend.
- */
-declare function isPreSpawnExecutorFailure(error: unknown, additionalSignatures?: ReadonlyArray<RegExp>): boolean;
-/** Read the policy, refusing a number a run cannot act on rather than silently clamping it. */
-declare function resolveWorkerSpawnRetry(policy: WorkerSpawnRetryPolicy | undefined): ResolvedWorkerSpawnRetry | undefined;
-/**
- * Wrap a worker seam so a leaf whose spawn is refused before it runs is re-entered instead of
- * settling dead.
- *
- * The wrapper composes the agent's `executorFactory`, which is where a leaf executor is built with
- * the real child signal and node context, and it never replaces the executor object the factory
- * returned: the retry lives in one `execute` wrapper that carries the inner executor's attestation
- * forward and delegates every other surface to it.
- */
-declare function withWorkerSpawnRetry(make: MakeWorkerAgent, policy: WorkerSpawnRetryPolicy | undefined, hooks?: WorkerSpawnRetryHooks): MakeWorkerAgent;
-/**
- * Re-enter `execute` on one executor while a pre-spawn refusal keeps proving nothing ran.
- *
- * Exported so an owner of `makeLeafAgent` — which builds its own executors — gets the same seam
- * without reimplementing the two proofs.
- */
-declare function retryPreSpawnRefusals<Out>(inner: Executor<Out>, policy: ResolvedWorkerSpawnRetry, hooks?: WorkerSpawnRetryHooks & {
-  worker?: string;
-}): Executor<Out>;
 interface SuperviseOptions {
   /** Whole-run persistence and ownership. SQL contexts are acquired before replay and compute. */
   readonly runContext?: RunContext;
@@ -11780,29 +11612,6 @@ interface SuperviseOptions {
   /** Per-attempt record for every external driver in the tree — what makes "failed after N
    *  attempts, last cause X" visible instead of one backend's last words. */
   readonly onDriverAttempt?: (record: DriverAttemptRecord) => void | Promise<void>;
-  /**
-   * How a BACKEND-DERIVED WORKER whose spawn was refused before it ran is re-entered, instead of
-   * settling dead with a slot free seconds later.
-   *
-   * `driverRetry` guards the root only. A worker that dies is typed into a `down` settlement,
-   * which is the right shape when the worker RAN — and the wrong shape for
-   * `host-executor: acquire timeout after 60000ms (in_flight=4/4, queued=1)`, a queue refusal the
-   * bridge emits before any harness child exists. Measured 2026-08-22 on discovery-lab cells
-   * oscnp s2/s3: ten live agents on one bridge that admits four, and every worker refused at the
-   * 60 s acquire deadline was lost for the whole run.
-   *
-   * Fail-closed on two proofs that the attempt did no work: the error carries a pre-spawn
-   * signature, AND the attempt yielded no execution event. An attempt that streamed anything may
-   * have metered usage, so a blind re-run would double-spend and stays fatal.
-   *
-   * Omit = no retry, the historical behaviour. Applies to backend-derived leaves, including those
-   * a `makeLeafAgent` builds; a caller-owned `makeWorkerAgent` composes
-   * {@link runtime.withWorkerSpawnRetry} itself.
-   */
-  readonly workerRetry?: WorkerSpawnRetryPolicy;
-  /** Per-re-entry record for every retried worker spawn — what makes a saturated executor visible
-   *  as waiting rather than as a worker that silently took longer. */
-  readonly onWorkerRetry?: (attempt: WorkerSpawnRetryAttempt) => void;
   /**
    * How an EXTERNAL-harness manager with a completion check is sent back when its turn ends with
    * the check unmet: `maxBarren`, an optional deadline, and the continuation note's profile and
@@ -12163,14 +11972,14 @@ declare const superviseFleetCapabilities: Readonly<{
 /** One-call supervisor: build + run a supervisor from its exact profile. @stable */
 declare function supervise(profile: SupervisorProfile, task: unknown, opts: SuperviseOptions): Promise<{
   execution?: AgentExecutionRef;
-  continuation?: DriverContinuationRecord;
-  rootHarnessTranscript?: HarnessTranscriptEvidence;
-  rootStream?: RootStreamReceipt;
   rootProviderModel: ProviderModelExecutionEvidence;
   kind: "no-winner";
   tree: TreeView;
   downCount: number;
   spentTotal: Spend;
+  rootStream?: RootStreamReceipt;
+  rootHarnessTranscript?: HarnessTranscriptEvidence;
+  continuation?: DriverContinuationRecord;
   providerModel?: ProviderModelExecutionEvidence;
   teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
   leakedReservations?: ReadonlyArray<LeakedReservation>;
@@ -12180,14 +11989,14 @@ declare function supervise(profile: SupervisorProfile, task: unknown, opts: Supe
   reason: "all-children-down" | "no-children-spawned" | "no-result-selected" | "stopped" | "budget-exhausted" | "deadline" | "aborted";
 } | {
   execution?: AgentExecutionRef;
-  continuation?: DriverContinuationRecord;
-  rootHarnessTranscript?: HarnessTranscriptEvidence;
-  rootStream?: RootStreamReceipt;
   rootProviderModel: ProviderModelExecutionEvidence;
   kind: "no-winner";
   tree: TreeView;
   downCount: number;
   spentTotal: Spend;
+  rootStream?: RootStreamReceipt;
+  rootHarnessTranscript?: HarnessTranscriptEvidence;
+  continuation?: DriverContinuationRecord;
   providerModel?: ProviderModelExecutionEvidence;
   teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
   leakedReservations?: ReadonlyArray<LeakedReservation>;
@@ -12201,15 +12010,15 @@ declare function supervise(profile: SupervisorProfile, task: unknown, opts: Supe
   operator?: string;
 } | {
   execution?: AgentExecutionRef;
-  continuation?: DriverContinuationRecord;
-  rootHarnessTranscript?: HarnessTranscriptEvidence;
-  rootStream?: RootStreamReceipt;
   rootProviderModel: ProviderModelExecutionEvidence;
   kind: "no-winner";
   reason: "driver-failed";
   tree: TreeView;
   downCount: number;
   spentTotal: Spend;
+  rootStream?: RootStreamReceipt;
+  rootHarnessTranscript?: HarnessTranscriptEvidence;
+  continuation?: DriverContinuationRecord;
   providerModel?: ProviderModelExecutionEvidence;
   teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
   leakedReservations?: ReadonlyArray<LeakedReservation>;
@@ -12218,9 +12027,6 @@ declare function supervise(profile: SupervisorProfile, task: unknown, opts: Supe
   error: NoWinnerError;
 } | {
   execution?: AgentExecutionRef;
-  continuation?: DriverContinuationRecord;
-  rootHarnessTranscript?: HarnessTranscriptEvidence;
-  rootStream?: RootStreamReceipt;
   rootProviderModel: ProviderModelExecutionEvidence;
   kind: "winner";
   out: unknown;
@@ -12228,6 +12034,9 @@ declare function supervise(profile: SupervisorProfile, task: unknown, opts: Supe
   verdict?: import("@tangle-network/agent-eval").DefaultVerdict;
   tree: TreeView;
   spentTotal: Spend;
+  rootStream?: RootStreamReceipt;
+  rootHarnessTranscript?: HarnessTranscriptEvidence;
+  continuation?: DriverContinuationRecord;
   providerModel?: ProviderModelExecutionEvidence;
   teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
   spendGaps?: ReadonlyArray<SpendGap>;
@@ -12240,14 +12049,14 @@ declare function supervise(profile: SupervisorProfile, task: unknown, opts: Supe
 /** Deterministic scripted-brain path for tests. Not exported from Runtime's main entry. */
 declare function superviseWithTestBrain(profile: SupervisorProfile, task: unknown, opts: SuperviseTestOptions): Promise<{
   execution?: AgentExecutionRef;
-  continuation?: DriverContinuationRecord;
-  rootHarnessTranscript?: HarnessTranscriptEvidence;
-  rootStream?: RootStreamReceipt;
   rootProviderModel: ProviderModelExecutionEvidence;
   kind: "no-winner";
   tree: TreeView;
   downCount: number;
   spentTotal: Spend;
+  rootStream?: RootStreamReceipt;
+  rootHarnessTranscript?: HarnessTranscriptEvidence;
+  continuation?: DriverContinuationRecord;
   providerModel?: ProviderModelExecutionEvidence;
   teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
   leakedReservations?: ReadonlyArray<LeakedReservation>;
@@ -12257,14 +12066,14 @@ declare function superviseWithTestBrain(profile: SupervisorProfile, task: unknow
   reason: "all-children-down" | "no-children-spawned" | "no-result-selected" | "stopped" | "budget-exhausted" | "deadline" | "aborted";
 } | {
   execution?: AgentExecutionRef;
-  continuation?: DriverContinuationRecord;
-  rootHarnessTranscript?: HarnessTranscriptEvidence;
-  rootStream?: RootStreamReceipt;
   rootProviderModel: ProviderModelExecutionEvidence;
   kind: "no-winner";
   tree: TreeView;
   downCount: number;
   spentTotal: Spend;
+  rootStream?: RootStreamReceipt;
+  rootHarnessTranscript?: HarnessTranscriptEvidence;
+  continuation?: DriverContinuationRecord;
   providerModel?: ProviderModelExecutionEvidence;
   teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
   leakedReservations?: ReadonlyArray<LeakedReservation>;
@@ -12278,15 +12087,15 @@ declare function superviseWithTestBrain(profile: SupervisorProfile, task: unknow
   operator?: string;
 } | {
   execution?: AgentExecutionRef;
-  continuation?: DriverContinuationRecord;
-  rootHarnessTranscript?: HarnessTranscriptEvidence;
-  rootStream?: RootStreamReceipt;
   rootProviderModel: ProviderModelExecutionEvidence;
   kind: "no-winner";
   reason: "driver-failed";
   tree: TreeView;
   downCount: number;
   spentTotal: Spend;
+  rootStream?: RootStreamReceipt;
+  rootHarnessTranscript?: HarnessTranscriptEvidence;
+  continuation?: DriverContinuationRecord;
   providerModel?: ProviderModelExecutionEvidence;
   teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
   leakedReservations?: ReadonlyArray<LeakedReservation>;
@@ -12295,9 +12104,6 @@ declare function superviseWithTestBrain(profile: SupervisorProfile, task: unknow
   error: NoWinnerError;
 } | {
   execution?: AgentExecutionRef;
-  continuation?: DriverContinuationRecord;
-  rootHarnessTranscript?: HarnessTranscriptEvidence;
-  rootStream?: RootStreamReceipt;
   rootProviderModel: ProviderModelExecutionEvidence;
   kind: "winner";
   out: unknown;
@@ -12305,6 +12111,9 @@ declare function superviseWithTestBrain(profile: SupervisorProfile, task: unknow
   verdict?: import("@tangle-network/agent-eval").DefaultVerdict;
   tree: TreeView;
   spentTotal: Spend;
+  rootStream?: RootStreamReceipt;
+  rootHarnessTranscript?: HarnessTranscriptEvidence;
+  continuation?: DriverContinuationRecord;
   providerModel?: ProviderModelExecutionEvidence;
   teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
   spendGaps?: ReadonlyArray<SpendGap>;
@@ -12595,7 +12404,7 @@ declare class GraphEdgeCapError extends Error {
  * Forwarded to the root `supervise()` VERBATIM. Everything not owned, transformed, or refused
  * above belongs here — the default is "a graph honors it", not "someone remembered to add it".
  */
-declare const GRAPH_FORWARDED_SUPERVISE_OPTIONS: readonly ["parking", "backend", "profileGuidance", "escalateQuestion", "rootHandle", "signal", "execution", "resolveDeliverable", "coordination", "peerMail", "peerAudit", "traceTools", "driverBackend", "profileSecurity", "authorizeSpawn", "router", "driveHarness", "selectSeat", "driverRetry", "onDriverAttempt", "workerRetry", "onWorkerRetry", "continuation", "childSettleGraceMs", "teardownConfirmMs", "retainedAtSettlement", "resolveDriveHarness", "driveHarnessMaterialization", "resolveSupervisorTools", "extraTools", "executeExtraTool", "recoverExecutor", "perWorker", "reservationPolicy", "deadlineCheckIn", "budgetStopHoldMs", "workerSlots", "watchWorkers", "stallAfterMs", "wake", "runDir", "resume", "segment", "runContext", "steerDir", "stopRule", "onProgressStop", "maxDepth", "maxTurns", "compaction", "now", "allowedModels", "finalizer", "otel", "graphRegistry"];
+declare const GRAPH_FORWARDED_SUPERVISE_OPTIONS: readonly ["parking", "backend", "profileGuidance", "escalateQuestion", "rootHandle", "signal", "execution", "resolveDeliverable", "coordination", "peerMail", "peerAudit", "traceTools", "driverBackend", "profileSecurity", "authorizeSpawn", "router", "driveHarness", "selectSeat", "driverRetry", "onDriverAttempt", "continuation", "childSettleGraceMs", "teardownConfirmMs", "retainedAtSettlement", "resolveDriveHarness", "driveHarnessMaterialization", "resolveSupervisorTools", "extraTools", "executeExtraTool", "recoverExecutor", "perWorker", "reservationPolicy", "deadlineCheckIn", "budgetStopHoldMs", "workerSlots", "watchWorkers", "stallAfterMs", "wake", "runDir", "resume", "segment", "runContext", "steerDir", "stopRule", "onProgressStop", "maxDepth", "maxTurns", "compaction", "now", "allowedModels", "finalizer", "otel", "graphRegistry"];
 /** `backend` and `driverBackend` keep graph-specific documentation below.
  *
  * Do not inherit and redeclare them through an indexed access type.
@@ -13658,16 +13467,6 @@ interface ProviderAsSandboxClientOptions {
   requireTerminalEvent?: boolean;
   /** Require declared live continuation plus concrete session controls. */
   requireSession?: boolean;
-  /** Verified workspace capture before every environment delete, including steerable sessions. */
-  workspaceRetention?: ProviderWorkspaceRetentionPort;
-  /** Supervised identity assigned before the environment is created. */
-  retentionIdentity?: {
-    executionId: string;
-    profile: AgentProfile;
-    node?: ExecutorNodeContext;
-  };
-  /** Called after verification and before deletion so the run result can retain the exact join. */
-  onWorkspaceCaptured?: (receipt: ProviderWorkspaceCaptureReceipt) => void | Promise<void>;
   /** Translate unsupported Sandbox controls while preserving requested custody. */
   mapCreateOptions?: (options: CreateSandboxOptions | undefined) => Partial<CreateAgentEnvironmentInput>;
 }
@@ -15763,10 +15562,6 @@ interface AcquireOptions {
   now?: () => number;
   /** Sleep override for deterministic tests. */
   sleep?: (ms: number) => Promise<void>;
-  /** Register the live source before readiness polling can destroy it. */
-  onAcquire?: (box: SandboxInstance) => void;
-  /** Capture and persist evidence before failed-readiness cleanup. */
-  beforeDelete?: (box: SandboxInstance) => Promise<void>;
 }
 /**
  * Cold-start-resilient sandbox acquisition: create by name, observe readiness from the sandbox's own status (not the create call), and re-attach after gateway timeouts.
@@ -15774,6 +15569,21 @@ interface AcquireOptions {
  * @experimental
  */
 declare function acquireSandbox(client: SandboxClient, options: CreateSandboxOptions, acquire?: AcquireOptions): Promise<SandboxInstance>;
+/** Historical receipt written by the retired client capture port. */
+interface SandboxEvidenceReceipt {
+  readonly boxId: string;
+  readonly executionId: string;
+  /** Exact authored profile identity without copying credentials into the receipt. */
+  readonly profileDigest: string;
+  readonly scope: 'box';
+  readonly sandboxSessionIds: ReadonlyArray<string>;
+  readonly nativeSessionIds?: ReadonlyArray<string>;
+  readonly sessionExecutionIds: Readonly<Record<string, ReadonlyArray<string>>>;
+  readonly snapshot: AgentCandidateWorkspaceSnapshotEvidence;
+  readonly provenance: ProviderWorkspaceCaptureProvenance;
+  readonly coverageComplete: boolean;
+  readonly incompleteReason?: string;
+}
 /**
  * A live box plus the session that threads its iterations together. Handed back
  * by `start`/`fork`, passed into `continue`/`fork` to descend from. Opaque to
@@ -15860,9 +15670,6 @@ declare function createSandboxLineage(client: SandboxClient, options?: {
   recordMount?: MountRecorder;
   /** A failed delete must surface and leave the box available for evidence recovery. */
   failOnDestroyError?: boolean;
-  /** Capture and durably record evidence before the box is deleted. */
-  beforeDelete?: (box: SandboxInstance) => Promise<void>;
-  onAcquire?: (box: SandboxInstance, profile: AgentProfile) => void;
 }): SandboxLineage;
 /**
  * How a typed deliverable `Out` is materialized from a finished turn.
@@ -16960,8 +16767,8 @@ declare const graphFileSchema: z.ZodObject<{
   edges: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
   gates: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
   budget: z.ZodObject<{
-    maxIterations: z.ZodNumber;
-    maxTokens: z.ZodNumber;
+    maxIterations: z.ZodOptional<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
     maxUsd: z.ZodOptional<z.ZodNumber>;
     deadlineMs: z.ZodOptional<z.ZodNumber>;
     resources: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -18943,6 +18750,8 @@ interface DriverAttemptRecord {
   readonly durationMs: number;
   /** Absent when the attempt completed. */
   readonly error?: string;
+  /** Validated producer attribution, including its reset hint when supplied. */
+  readonly failure?: AgentTurnFailure;
   readonly classification?: DriverFailureClass;
   /** For a `transient` failure: `infra` (bounded as an outage) or `deterministic` (stops at the
    *  second invocation that fails alike with no progress). */
@@ -19763,5 +19572,5 @@ interface KnowledgeReadinessDecision {
   blockingGapIds: string[];
   nonBlockingGapIds: string[];
 }
-export { AgentEnvironmentStatus as $, RuntimeRunRow as $S, PeerMailSendInput as $_, ClaimRetainedInteractiveControlOptions as $a, RootMaterialization as $b, ShapeRegistry as $c, readRunCancelRequest as $d, DelegateResult as $f, WorktreeProfileMaterializationReceipt as $g, CodexRolloutStoreRef as $h, StructuralRolloutResult as $i, PursuitRunTotals as $l, DelegateUiAuditConfig as $m, safeWorkerFile as $n, loopCampaignDispatch as $o, SandboxLeafOut as $p, graphDigest as $r, HarvestReport as $s, settledWorkerOut as $t, RunContextLease as $u, InMemoryResultBlobStore as $v, HarnessTranscriptReadLimits as $x, NodeId as $y, DriverContinuationRecord as A, RetainedRunEventOptions as AC, LoopPlanDescription as AS, questionEscalationTargets as A_, Deliverable as Aa, LeakedReservation as Ab, ScopeWidenGate as Ac, ResolveDriveHarness as Ad, ContinuationProfile as Af, renderLeaderboardSvg as Ag, FileDelegationStoreOptions as Ah, ChatWorkerSeamOptions as Ai, PursuitVersionChain as Al, FleetHandle as Am, SearchSpecOwnedOption as An, assertTraceDerivedFindings as Ao, ROUTER_CLIENT_HEADER as Ap, workerFromInteractiveProvider as Ar, SurfaceScore as As, boxSurfaceReader as At, AuthorizedSpawn as Au, DefinedAnalystRecord as Av, RecoverRetainedInteractiveRunOptions as Ax, RuntimeTelemetryOptions as Ay, PeerAuditAccess as B, MountManifestEntry as BS, MapItemFailurePolicy as B_, createSandboxLineage as Ba, ExecutorContext as Bb, WidenSpec as Bc, AllWorkersStalledOptions as Bd, SpawnResourceRead as Bf, WaterfallCollector as Bg, verdictFromJudgeScore as Bh, profileRichnessFinding as Bi, SupervisedPursuitResult as Bl, DelegationResumeContext as Bm, TraceRootArtifact as Bn, BenchmarkConfig as Bo, providerAsExecutor as Bp, LoadGraphFileOptions as Br, StrategyArtifacts as Bs, WorktreePatchArtifact as Bt, retryPreSpawnRefusals as Bu, openSqlRunStore as Bv, HarnessTranscriptEvidence as Bx, RunParkedError as By, RuntimeFailureCause as C, RetainedRunAdmission as CC, Iteration as CS, QuestionEscalationRecord as C_, EvolutionStrategy as Ca, WidenGate as Cb, PanelJudge as Cc, supervisorAgent as Cd, CheckRead as Cf, PairwiseVerdict as Cg, ResearcherProfileOptions as Ch, DelegateOptions as Ci, IsolatedCheckBoxEvidence as Cl, CoderReviewer as Cm, FencedSqlRunContext as Cn, panel as Co, DEFAULT_SHARED_BOX_WORKERS as Cp, profileRegistry as Cr, AgenticTask as Cs, BoxSurfaceReaderOptions as Ct, GraphRouteError as Cu, AnalystKind as Cv, ExecutorProgress as Cx, buildLoopOtelSpans as Cy, RetainedPendingCause as D, RetainedRunDispatchedAdmission as DC, LoopIterationEndedPayload as DS, QuestionPolicy as D_, TournamentRow as Da, BudgetPool as Db, RenderCorpusToInstructionsOptions as Dc, DriveHarness as Dd, ContinuationPanelInput as Df, pairwiseSignificance as Dg, DelegationPersistenceError as Dh, ChatSessionStore as Di, JudgedPursuitVersion as Dl, UiAuditorDelegate as Dm, SEARCH_SPEC_CORRELATION_KEY as Dn, widen as Do, SharedBoxStats as Dp, InteractiveWorkerKeyInput as Dr, RunAgenticOptions as Ds, SurfaceReadOutcome as Dt, superviseFleetCapabilities as Du, AnalyzeOnSettleRoute as Dv, createActivityLog as Dx, RuntimeStreamEventCollector as Dy, EvidencePendingEvent as E, RetainedRunCancellation as EC, LoopIterationDispatchPayload as ES, QuestionOption as E_, TournamentCell as Ea, WorkerEventPage as Eb, PipelineStage as Ec, CoordinationVerbs as Ed, ContinuationPanel as Ef, leaderboard as Eg, composeLoopTraceEmitters as Eh, ChatCompletionsTransport as Ei, runIsolatedCheck as El, DetachedWinnerSelection as Em, CompiledSearchSpec as En, verify as Eo, SharedBoxPlacementOptions as Ep, InteractiveWorkerEnvironment as Er, CorpusReadbackOptions as Es, SurfaceReadBox as Et, supervise as Eu, AnalystRunContext as Ev, WorkerProgress as Ex, RuntimeEventCollector as Ey, CoordinationTools as F, RetainedRunStartMaterial as FC, LoopTeardownFailedPayload as FS, DownMessageAuthorizationInput as F_, SandboxRunAbortError as Fa, ReservationStage as Fb, Verify as Fc, SupervisorNodeContextSeed as Fd, DriverReentry as Ff, anytimeReport as Fg, CompletionCheckContext as Fh, ProfileRichness as Fi, VersionVerdict as Fl, DetachedTurn as Fm, settledToIteration as Fn, McpEndpoint as Fo, createAgentEnvironmentProviderRegistry as Fp, graphFromSessionFacts as Fr, sample as Fs, failuresAnalyst as Ft, WorkerSpawnRetryAttempt as Fu, LOCAL_HARNESSES as Fv, StartRetainedInteractiveRunOptions as Fx, sanitizeKnowledgeReadinessReport as Fy, SpawnRefusalCause as G, SelectionReceipt as GS, DEFAULT_PEER_MAIL_LIMITS as G_, createS3PrivateCasStore as Ga, ExecutionBindingReceipt as Gb, Outcome as Gc, StopRule as Gd, McpServerOptions as Gf, runAgentRounds as Gg, completionAuthorizes as Gh, CheckRunContext as Gi, PursuitCostProvenance as Gl, DelegationTaskQueueOptions as Gm, WorkerSteerAcknowledgement as Gn, Environment as Go, BridgeSeam as Gp, GraphRegistryDir as Gr, authorStrategy as Gs, attachWorker as Gt, SeatSelection as Gu, SpawnForestInDoubtNode as Gv, captureBoundHarnessTranscript as Gx, BudgetOverspend as Gy, SpawnPreflight as H, OutputAdapter as HS, MapSpawnMarker as H_, acquireSandbox as Ha, ExecutorRegistry as Hb, DefinePersona as Hc, PlateauOptions as Hd, environmentReader as Hf, WaterfallSpan as Hg, CompletionEvidence as Hh, RunCancellationReason as Hi, supervisePursuit as Hl, DelegationResumeTick as Hm, RunTraceSources as Hn, BenchmarkReport as Ho, ProviderPlacement as Hp, loadGraphFile as Hr, StrategyResult as Hs, AttachWorkerOptions as Ht, SuperviseRegistry as Hu, materializeTreeView as Hv, HarnessTranscriptUnavailable as Hx, RunParkingRecord as Hy, CoordinationToolsOptions as I, RetainedRunTurnInput as IC, LoopTokenUsage as IS, DownMessageDeliveryAttempt as I_, TurnResult as Ia, ReservationTicket as Ib, VerifySpec as Ic, SupervisorToolDescriptor as Id, DriverRetryPolicy as If, areaUnderCurve as Ig, DeliverableSpec as Ih, ProfileRichnessThresholds as Ii, assertPursuitVersions as Il, RunDetachedTurnOptions as Im, createScope as In, McpEnvironmentOptions as Io, resolveAgentEnvironmentProvider as Ip, graphFileSchema as Ir, AuthorStrategyOptions as Is, AuthoredHarness as It, WorkerSpawnRetryHooks as Iu, LocalHarness as Iv, HARNESS_TRANSCRIPT_SETTLE_TIMEOUT_MS as Ix, DeadlineCheckIn as Iy, AgentEnvironment$1 as J, RuntimeRunCompleteInput as JS, PeerMailEvent as J_, PrivateCasNamespaceRetirement as Ja, ExecutorNodeContext as Jb, PersonaExecutors as Jc, noProgressFor as Jd, EventSubscriptionStore as Jf, SandboxEvidenceRetentionPort as Jg, stopSentinel as Jh, CheckSourceCtx as Ji, PursuitNodeProjection as Jl, DelegateCodeArgs as Jm, cancelWorker as Jn, LoopCampaignDispatchOptions as Jo, envKeyProvider as Jp, GraphSelection as Jr, strategyAuthorContract as Js, NOTE_MAX_CHARS as Jt, SelectSeat as Ju, SpawnForestTree as Jv, persistHarnessTranscript as Jx, ResourceSpend as Jy, SuperviseProfileEntry as K, ValidationCtx as KS, PEER_MAIL_WIRE_KEY as K_, PrivateCasNamespaceInventory as Ka, ExecutorExecutionBinding as Kb, Persona as Kc, allWorkersStalled as Kd, createMcpServer as Kf, SandboxEvidenceContext as Kg, deterministicCompletion as Kh, CheckRunner as Ki, PursuitNodeCost as Kl, SubmitInput as Km, WorkerSteerRequest as Kn, printBenchmarkReport as Ko, KeyProvider as Kp, GraphRunQuery as Kr, defineStrategy as Ks, readWorkerInteractiveBinding as Kt, SeatSelectionInput as Ku, SpawnForestMissingTree as Kv, captureHarnessTranscript as Kx, BudgetViolation as Ky, GraphSubtaskPreparation as L, StartRetainedRunInEnvironmentOptions as LC, LoopTraceEmitter as LS, DownMessageDeliveryOutcome as L_, openSandboxRun as La, ReserveOptions as Lb, Widen as Lc, SupervisorToolInvocationContext as Ld, ResolveSpawnResourcePathsResult as Lf, bestSoFar as Lg, ExecutorResultMapping as Lh, asAuthoredProfile as Li, SuperviseGraphPursuitOptions as Ll, runDetachedTurn as Lm, ScopeArgs as Ln, createMcpEnvironment as Lo, ProviderExecutorOptions as Lp, graphRouteWhenSchema as Lr, AuthoredStrategy as Ls, WorktreeFanoutOptions as Lt, WorkerSpawnRetryPolicy as Lu, CodexTokenUsage as Lv, HarnessTranscriptArtifact as Lx, WorkerSlots as Ly, DriverRepromptRefusal as M, RetainedRunIntentAdmission as MC, LoopResult as MS, AuthorizedDownMessage as M_, OpenSandboxRunOptions as Ma, ReservationHolder as Mb, TrajectoryNode as Mc, SupervisorAgentDeps as Md, VerdictSummary as Mf, AnytimeReport as Mg, CoderTask as Mh, chatWorkerSeam as Mi, PursuitVersions as Ml, SiblingSandboxExecutorOptions as Mm, compileSearchSpec as Mn, createScopeAnalyst as Mo, sharedWorkerClientName as Mp, createInPlaceCliExecutor as Mr, depthStrategy as Ms, harvestSurfaceDiffs as Mt, SuperviseOptions as Mu, LocalHarnessResult as Mv, RetainedInteractiveEnvironmentInput as Mx, SanitizedKnowledgeRequirement as My, BlockedToolReport as N, RetainedRunReplayPoint as NC, LoopSandboxPlacement as NS, ContinuationInstruction as N_, OpenSandboxRunPromptOptions as Na, ReservationRejection as Nb, TrajectoryReport as Nc, SupervisorAgentTestDeps as Nd, admitContinuationPolicy as Nf, AnytimeStrategySummary as Ng, CheckUnavailableError as Nh, createChatSessionStore as Ni, SettledPursuitVersion as Nl, createFleetWorkspaceExecutor as Nm, searchPresets as Nn, registryScopeAnalyst as No, AgentEnvironmentProviderRef as Np, GraphSessionObservationOptions as Nr, refine as Ns, AnalystAuthoring as Nt, SuperviseTestOptions as Nu, RunLocalHarnessOptions as Nv, RetainedInteractiveRunHandle as Nx, createRuntimeEventCollector as Ny, DriverAttemptRecord as O, RetainedRunEffect as OC, LoopIterationStartedPayload as OS, QuestionRecord as O_, runStrategyEvolution as Oa, BudgetPoolRestore as Ob, ScopeAnalyst as Oc, DriveHarnessOwnerContext as Od, ContinuationPanelResult as Of, renderLeaderboardHtml as Og, DelegationStore as Oh, ChatTransportExecutorOptions as Oi, NextPursuitVersion as Ol, detachedSessionDelegate as Om, SearchSpec as On, CreateScopeAnalystOptions as Oo, SharedWorkerIdentity as Op, InteractiveWorkerOptions as Or, StrategyMessage as Os, SurfaceReader as Ot, superviseWithTestBrain as Ou, AuthoredAnalystDefinition as Ov, readWorkerProgress as Ox, RuntimeStreamEventSink as Oy, CoordinationStats as P, RetainedRunSnapshot as PC, LoopStartedPayload as PS, ContinuityMode as P_, SandboxRun as Pa, ReservationShortfall as Pb, TrajectoryReportOptions as Pc, SupervisorNodeContext as Pd, DriverContractState as Pf, AnytimeTaskCurve as Pg, CheckVerdict as Ph, AuthoredProfile as Pi, VersionJudge as Pl, createSiblingSandboxExecutor as Pm, searchSpecDigest as Pn, observationFromRegistry as Po, AgentEnvironmentProviderRegistry as Pp, ObservedSessionFacts as Pr, runAgentic as Ps, analystsFromRegistry as Pt, ResolvedWorkerSpawnRetry as Pu, runLocalHarness as Pv, RetainedInteractiveStartMaterial as Px, createRuntimeStreamEventCollector as Py, AgentEnvironmentQuery as Q, RuntimeRunPersistenceAdapter as QS, PeerMailRefusal as Q_, startRetainedRunInEnvironment as Qa, ProfileMaterializationReceipt as Qb, ShapeContext as Qc, cancelRun as Qd, DelegateHandlerOptions as Qf, WorktreeHarnessResult as Qg, CodexRolloutStoreReader as Qh, StructuralRolloutPolicy as Qi, PursuitRunProjection as Ql, DelegateUiAuditArgs as Qm, readWorkerSteerRequests as Qn, SuperviseOptionsForDispatch as Qo, secretEnvOfMcpServer as Qp, graphCorpusSummary as Qr, HarvestFailure as Qs, composeWorkerEvidence as Qt, RunContext as Qu, FileSpawnJournal as Qv, HarnessTranscriptMetadata as Qx, Handle as Qy, GraphSubtasks as R, StartRetainedRunOptions as RC, LoopTraceEvent as RS, DownMessageEvent as R_, SandboxLineage as Ra, createBudgetPool as Rb, WidenDecision as Rc, ManagerWakePolicy as Rd, ResolvedSpawnResourcePath as Rf, plateauLength as Rg, gateOnDeliverable as Rh, assessAuthoredProfile as Ri, SupervisePursuitError as Rl, DelegationArgs as Rm, TRACE_ROOT_SCHEMA as Rn, sanitizeMcpToolSchema as Ro, ProviderLeafOut as Rp, GraphFileResolutionError as Rr, ShotSpec as Rs, worktreeFanout as Rt, isPreSpawnExecutorFailure as Ru, CodexExecutionPolicy as Rv, HarnessTranscriptBinding as Rx, createWorkerSlots as Ry, RuntimeStreamEvent as S, RetainedInteractiveStartedAdmission as SC, ExecCtx as SS, QuestionEscalationOutcome as S_, EvolutionReport as Sa, UnconfirmedTeardown as Sb, Panel as Sc, readRootStreamReceipt as Sd, PriorCoordination as Sf, PairwiseOptions as Sg, ResearchTask as Sh, graphDesignerExtraTools as Si, IsolatedCheckBox as Sl, CoderReview as Sm, validateStoredGraph as Sn, loopUntil as So, DEFAULT_SHARED_BOX_RESOURCES as Sp, pickBestProfile as Sr, AgenticSurface as Ss, createVerifierEnvironment as St, defaultEdgeTraversalCap as Su, AnalystFindingEvent as Sv, DEFAULT_STALL_AFTER_MS as Sx, OtelSpan as Sy, RuntimeFailureOwner as T, RetainedRunCancelOptions as TC, LoopEndedPayload as TS, QuestionLevel as T_, StrategyTournament as Ta, WorkerEventEntry as Tb, PanelVerdict as Tc, CoordinationToolFace as Td, ContinuationEntry as Tf, ScoreOf as Tg, DelegationTraceSpan as Th, delegate as Ti, IsolatedCheckResult as Tl, DetachedSessionDelegateOptions as Tm, createFencedSqlRunContext as Tn, selectValidWinner as To, SharedBoxPlacement as Tp, recordProfileRun as Tr, ArtifactHandle as Ts, SurfaceDiff as Tt, RUN_FORK_CORRELATION_KEYS as Tu, AnalystRegistry$1 as Tv, TeamProgress as Tx, loopEventToOtelSpan as Ty, SpawnPreflightContext as U, RunProvenance as US, MapTraversalEvent as U_, S3PrivateCasStore as Ua, SpawnModelSubstitution as Ub, DefinePersonaInput as Uc, ProgressView as Ud, resolveSpawnResourcePaths as Uf, createWaterfallCollector as Ug, CompletionPolicy as Uh, CheckExecChannel as Ui, RunReopen as Ul, DelegationRunContext as Um, runToolSpans as Un, BenchmarkStrategySummary as Uo, BridgeHarnessStore as Up, GraphCorpusGroup as Ur, adaptiveRefine as Us, WorkerInteractiveBinding as Ut, SuperviseRegistryTable as Uu, SpawnForest as Uv, HarnessTranscriptUnavailableReason as Ux, readRunParking as Uy, SettledWorker as V, MountRecorder as VS, MapOnSettleRoute as V_, AcquireOptions as Va, ExecutorFactory as Vb, WinnerStrategy as Vc, NoProgressForOptions as Vd, SpawnResourceReader as Vf, WaterfallReport as Vg, CompletionAnalyst as Vh, supervisorInstructions as Vi, superviseGraphPursuit as Vl, DelegationResumeDriver as Vm, TraceSummary as Vn, BenchmarkLift as Vo, UnavailablePausePolicy as Vp, LoadedGraphFile as Vr, StrategyCtx as Vs, createWorktreeCliExecutor as Vt, withWorkerSpawnRetry as Vu, SqlAdapter as Vv, HarnessTranscriptFile as Vx, RunParkingPolicy as Vy, SpawnRefusal as W, SandboxClient as WS, AUTHORITY_MARKERS as W_, S3PrivateCasStoreOptions as Wa, AgentExecutionRef as Wb, LoopShape as Wc, StopDecision as Wd, McpServer as Wf, RunAgentRoundsOptions as Wg, CompletionVerdict as Wh, CheckOutcome as Wi, PursuitObserverDelivery as Wl, DelegationTaskQueue as Wm, WorkerCancellation as Wn, BenchmarkTaskRow as Wo, BridgeModelCredential as Wp, GraphCorpusSummary as Wr, assertStrategyContract as Ws, WorkerInteractiveProviderSource as Wt, SeatSegment as Wu, SpawnForestEvent as Wv, ReadableEnvironment as Wx, Budget as Wy, AgentEnvironmentEvent$1 as X, RuntimeRunHandle as XS, PeerMailOutcome as X_, recoverRetainedRun as Xa, MaterializedModelIdentity as Xb, RunPersonifiedOptions as Xc, RunCancelRequest as Xd, McpEventSource as Xf, WorktreeCheckRunner as Xg, CodexRolloutIdentity as Xh, StructuralRolloutConfig as Xi, PursuitNodeUsage as Xl, DelegateResearchArgs as Xm, readWorkerCancellation as Xn, LoopOptionsForDispatch as Xo, resolveMcpServerLaunch as Xp, StoredGraphInput as Xr, HarvestCorpusOptions as Xs, WorkerEvidenceInput as Xt, InMemoryRunContext as Xu, FileResultBlobStore as Xv, HARNESS_TRANSCRIPT_READ_LIMITS as Xx, SpendChannel as Xy, AgentEnvironmentCapabilities$1 as Y, RuntimeRunCost as YS, PeerMailLimits as Y_, reconnectRetainedRun as Ya, MaterializedExecutionIdentity as Yb, RunPersonified as Yc, plateau as Yd, McpEventRecord as Yf, InPlaceHarnessResult as Yg, CodexForkBoundary as Yh, RepairStop as Yi, PursuitNodeTiming as Yl, DelegateCodeConfig as Ym, legacySupervisorRunDir as Yn, LoopDispatchOptions as Yo, mcpSecretEnvMetadataKey as Yp, StoredGraph as Yr, strategyAuthorSystemPrompt as Ys, VERIFY_TAIL_CHARS as Yt, subscriptionUsageLimitSignal as Yu, loadSpawnForest as Yv, BoundHarnessSession as Yx, Spend as Yy, AgentEnvironmentProvider$1 as Z, RuntimeRunOptions as ZS, PeerMailReadout as Z_, startRetainedRun as Za, NodeExecutionIdentity as Zb, ShapeBudget as Zc, RunCancellation as Zd, DelegateError as Zf, WorktreeCommandResult as Zg, CodexRolloutSession as Zh, StructuralRolloutMessage as Zi, PursuitProjection as Zl, DelegateResearchConfig as Zm, readWorkerSteerAcknowledgement as Zn, SuperviseDispatchOptions as Zo, resolveSecretEnv as Zp, digestOfGraph as Zr, HarvestError as Zs, closingWorkerNote as Zt, InMemoryRunContextOptions as Zu, replaySpawnTree as Zv, HarnessFileBinding as Zx, SpendGap as Zy, RunAgentTaskOptions as _, RecoverRetainedRunOptions as _C, TokenUsageProvenance as _S, RouteWhen as __, CollectedAgentTurn as _a, Agent as _b, FanoutOptions as _c, SupervisorSpanOutcome as _d, CoordinationHttpAudit as _f, GroupOf as _g, UiLens as _h, queueOf as _i, checkProgramDigest as _l, ToolLoopMessageRecord as _m, parseWorkerToolTraceArtifact as _n, FileCorpus as _o, AuthorityInboxMessage as _p, provisionSupervisor as _r, StdioMcpServerSpec as _s, SandboxInstance$1 as _t, TraversalContinuity as _u, createEventBus as _v, ToolStepInput as _x, readTraceContextFromEnv as _y, AgentKnowledgeProvider as a, AgentEvalError$1 as aC, retainHarnessTranscript as aS, ManagerReentryState as a_, defaultStructuralRolloutPolicy as aa, SpawnPrior as ab, ObserveOptions as ac, RegisteredPrompt as ad, DeliveredOutput as af, readCodexRolloutSession as ag, DelegationProgress as ah, lookupGraph as ai, LeaderboardBenchmarkAdapter as al, SandboxServedBackend as am, GitWorkspaceOptions as an, resolveSandboxClient as ao, CliSeam as ap, RemoteSupervisorCancelResult as ar, defaultSelectWinner as as, AgentTurnResult$2 as at, ObserverRecordKind as au, peerMailTools as av, ExecutorCancellationRequest as ax, WorkspaceCheckpointMarker as ay, RuntimeSession as b, RetainedInteractiveEnvironmentAdmission as bC, DefaultVerdict$2 as bS, Question as b_, streamAgentTurn as ba, ResumedWork as bb, LoopUntilSpec as bc, RootStreamRecord as bd, CoordinationLog as bf, LeaderboardOptions as bg, ResearchOutput as bh, DesignerToolsEnv as bi, declaredCheckJudge as bl, FeedbackStore as bm, createRootHandle as bn, fanout as bo, InboxMessage as bp, bestProfileFor as br, AgenticOptions as bs, makeFinding$1 as bt, GraphCommandCheck as bu, watchTrace as bv, ActivityLog as bx, OtelExportStats as by, AgentTaskContext as c, ConfigError as cC, ProviderWorkspaceAttemptProvenance as cS, WorkerWatchOptions as c_, officialChecksFromMeta as ca, SubtreeSummary as cb, renderReport as cc, delegatesWorkerBriefPrompt as cd, SupervisorFinalizer as cf, CodeModeStore as cg, DelegationStatusResult as ch, recordStoredGraphRun as ci, LeaderboardRunContext as cl, sumSandboxUsage as cm, WorkspaceCommit as cn, PrivateCasArtifactPort as co, ProviderSeam as cp, RemoteSupervisorSteerResult as cr, InProcessPromptCtx as cs, CheckpointRequest as ct, EdgeDeliveryOutcome as cu, JsonRpcResponse as cv, HeldEnvironment as cx, RootSegment as cy, AgentTaskStatus as d, ValidationError as dC, ProviderWorkspaceCaptureResult as dS, GateRequest as d_, selectBestIndex as da, NoWinnerError as db, Corpus as dc, formatPromptHandle as dd, CoordinationControlAccess as df, CodeModeToolsOptions as dg, ResearchOutputShape as dh, GraphTriggerBinding as di, LeaderboardSpec as dl, RouterRouting as dm, jjWorkspace as dn, PrivateCasOptions as do, SandboxSeam as dp, connectRemoteSupervisor as dr, HttpMcpServerSpec as ds, ExecRequest as dt, GraphEdgeCapError as du, McpTransport as dv, Runtime as dx, SteerableRootHandle as dy, RuntimeRunStatus as eC, HarnessTranscriptReadOptions as eS, GitRunner as e_, VisibleCheck as ea, NodeSnapshot as eb, harvestCorpus as ec, createFileRunContext as ed, readRunCancellation as ef, CodexRolloutTurn as eg, DelegateUiAuditRoute as eh, graphFromStored as ei, ProviderAsSandboxClientOptions as el, SandboxOutputMarker as em, spendFromUsageEvents as en, claimRetainedInteractiveControl as eo, createDelegateHandler as ep, supervisorRunDir as er, loopDispatch as es, AgentEnvironmentSummary as et, PursuitStatus as eu, PeerMailbox as ev, UnknownMaterializationReason as ex, InMemorySpawnJournal as ey, BackendErrorDetail as f, NativeContextContinuationExecution as fC, ProviderWorkspaceEntryMetadata as fS, JsonScalar as f_, structuralRollout as fa, ProviderModelAttemptEvidence as fb, CorpusFilter as fc, kernelPromptRegistry as fd, CoordinationMcpHandle as ff, CodeModeToolset as fg, UiAuditLensFilter as fh, DispatchReport as fi, defineLeaderboard as fl, ToolSpec as fm, localShell as fn, createPrivateCasArtifactPort as fo, DEFAULT_SANDBOX_STEERING_MAX_TURNS as fp, connectRemoteSupervisorControl as fr, LocalMcpMaterialization as fs, ExecResult as ft, GraphNode as fu, BusEvent as fv, WorkerInteractiveSession as fx, Supervisor as fy, OpenAIChatToolChoice as g, RecoverRetainedRunIntentOptions as gC, ExecutorToolCall as gS, RouteMatch as g_, AgentTurnUsage as ga, SupervisedResult as gb, EqualKVerdict as gc, SupervisorSpanOptions as gd, serveCoordinationMcp as gf, AxisScoresOf as gg, UiFindingSeverity as gh, freeSlots as gi, assertDeclaredCheck as gl, ToolLoopCompactionOptions as gm, WorkerToolTraceArtifact as gn, runPersonified as go, createSteerableSandboxSession as gp, SupervisorCleanupReceipt as gr, StdioMcpConnection as gs, SandboxEvent$1 as gt, RunGraphTestOptions as gu, PublishOptions as gv, SessionMessageLike as gx, createPropagatingTraceEmitter as gy, OpenAIChatTool as h, ReconnectRetainedRunOptions as hC, ExecutorProgressEvent as hS, RouteGate as h_, AgentTurnInput$1 as ha, RootStreamReceipt as hb, EqualKOnCostOptions as hc, SupervisorSpanAttributes as hd, CoordinationTransportOptions as hf, runCodeMode as hg, UiFindingScreenshot as hh, RollingDispatchOptions as hi, DeclaredCheckStateCapture as hl, ToolLoopCompaction as hm, analyzeTrace as hn, definePersona as ho, SteerableSandboxSession as hp, ProvisionedSupervisor as hr, McpSpawnFault as hs, ResourceRequest as ht, RunGraphOptions as hu, EventBus as hv, WorkerTraceUnavailableReason as hx, TraceContext as hy, AgentExecutionBackend as i, defaultRedactor as iC, resolveHarnessTranscriptCapture as iS, LeadMessage as i_, defaultExtractCandidate as ia, SpawnOpts as ib, ObserveInput as ic, PromptRegistry as id, composeReentryTask as if, harnessUsageIsEmpty as ig, DelegationHistoryEntry as ih, loadGraph as ii, LeaderboardBenchTask as il, mapSandboxToolEvent as im, withUntrackedArtifacts as in, ResolveSandboxClientOptions as io, CliInPlaceSeam as ip, RemoteSupervisorAgent as ir, TerminalDecision as is, AgentSessionStatus$1 as it, ObserverRecord as iu, isPeerMailEnvelope as iv, ExecutorCancellation as ix, TraceRootReceipt as iy, DriverFailureClass as j, RetainedRunHandle as jC, LoopPlanPayload as jS, AuthorizeDownMessage as j_, OpenSandboxRunBeforeStartContext as ja, ReservationFloor as jb, SteerContext as jc, ResolveSupervisorTools as jd, PanelFinding as jf, renderPairwiseMarkdown as jg, CoderOutput as jh, chatTransportExecutor as ji, PursuitVersionStop as jl, FleetWorkspaceExecutorOptions as jm, assertSearchSpec as jn, buildSteerContext as jo, sharedBoxRefusal as jp, InPlaceCliExecutorOptions as jr, breadthStrategy as js, fsSurfaceReader as jt, AuthorizedSpawnContext as ju, CodexExecutionEvidence as jv, RetainedInteractiveAdmissionHook as jx, SanitizedKnowledgeReadinessReport as jy, DriverAttemptStop as k, RetainedRunEnvironmentAdmission as kC, LoopLineageOptions as kS, QuestionUrgency as k_, strategyTournament as ka, BudgetReadout as kb, ScopeAnalyzeInput as kc, ObserveSupervisorNodeEvent as kd, ContinuationPolicy as kf, renderLeaderboardMarkdown as kg, FileDelegationStore as kh, ChatTransportTool as ki, NextPursuitVersionInput as kl, DelegationExecutor as km, SearchSpecInputs as kn, RegistryAnalyzeProjection as ko, sharedBoxPlacement as kp, InteractiveWorkerResult as kr, StrategyShotResult as ks, WatchedSurface as kt, workerFromBackend as ku, AuthoredAnalystLimits as kv, ReconnectRetainedInteractiveRunOptions as kx, RuntimeStreamEventSummary as ky, AgentTaskRunResult as l, JudgeError as lC, ProviderWorkspaceCaptureProvenance as lS, DecideGate as l_, resolveEntrySymbol as la, TreeView as lb, AssertTraceDerivedFindings as lc, dumbContinuationFailPrompt as ld, bestDelivered as lf, CodeModeTool as lg, FeedbackRating as lh, storedGraphDigests as li, LeaderboardScenario as ll, RouterResponseReceipt as lm, WorkspaceRun as ln, PrivateCasDurableStore as lo, RouterSeam as lp, RemoteSupervisorTree as lr, InProcessSandboxClientOptions as ls, CreateAgentEnvironmentInput$1 as lt, EdgeTraversal as lu, McpToolAnnotations as lv, HeldForContinuation as lx, RootSegmentEntry as ly, OpenAIChatResponseFormat as m, NativeContextContinuationInput as mC, ProviderWorkspaceRetentionPort as mS, RouteFlowEvent as m_, AgentTurnBackend as ma, RootProviderModelEvidence as mb, EqualKArm as mc, promptHandle as md, CoordinationReadAccess as mf, createCodeModeTools as mg, UiFinding as mh, DispatchUnit as mi, DeclaredCheckPlacement as ml, ToolLoopChat as mm, TrajectoryAnalysis as mn, trajectoryReport as mo, SteerableSandboxArgs as mp, ProvisionSupervisorRequest as mr, McpListedTool as ms, PlacementInfo as mt, GraphTopology as mu, BusStats as mv, WorkerTraceEvidence as mx, WorkerTraceResolver as my, AgentBackendContext as n, contentAddress as nC, RetainedHarnessTranscriptDescriptor as nS, CoordinationEvent as n_, compareCheckOutcomes as na, RetainedExecutionState as nb, ObservationAnalysis as nc, withRunContext as nd, ReentryTaskInput as nf, addHarnessUsage as ng, DelegationFeedbackSnapshot as nh, graphRunsFor as ni, DefinedLeaderboard as nl, createSandboxToolPartState as nm, UntrackedCopyStats as nn, recoverRetainedInteractiveRun as no, ExecutorConfig as np, workerInboxFileFromEventDir as nr, LocalSandboxClientOptions as ns, AgentSession as nt, FileObserverJournal as nu, claimsAuthority as nv, Executor as nx, SpawnEvent as ny, AgentRuntimeEvent as o, AgentEvalErrorCode as oC, ProviderCheckpointCaptureContext as oS, ManagerWake as o_, filterAuthoredAsserts as oa, SpawnRejection as ob, defaultAnalystInstruction as oc, analyzesFindingsReportPrompt as od, FinalizeContext as of, HarnessUsage as og, DelegationResultPayload as oh, pickBestGraph as oi, LeaderboardFlagSpec as ol, SandboxUsageLedger as om, Shell as on, profileChatClient as oo, CliWorktreeBridgeSeam as op, RemoteSupervisorControl as or, inlineSandboxClient as os, AnalystFinding$1 as ot, observerRecordDigest as ou, peerMailVerbNames as ov, ExecutorResult as ox, RecursiveReservationPolicy as oy, KnowledgeReadinessDecision as p, NativeContextContinuationHandle as pC, ProviderWorkspaceRetentionContext as pS, RouteFlow as p_, visibleCheckScore as pa, ProviderModelExecutionEvidence as pb, CorpusRecord as pc, naiveContinuationPrompt as pd, CoordinationPublicAddress as pf, RunCodeModeOptions as pg, UiAuditorDelegationOutput as ph, DispatchStopReason as pi, DeclaredCheck as pl, ToolLoopCallContext as pm, runInWorkspace as pn, equalKOnCost as po, SandboxSteeringOptions as pp, ProvisionSupervisorConnection as pr, MaterializeLocalMcpOptions as ps, ForkRequest as pt, GraphResult as pu, BusRecord as pv, WorkerInteractiveUnavailableReason as px, SupervisorOpts as py, WorkerSpawnContext as q, Validator as qS, PeerMailEnvelope as q_, PrivateCasNamespaceObject as qa, ExecutorMaterialization as qb, PersonaContext as qc, anyOf as qd, EventSubscription as qf, SandboxEvidenceReceipt as qg, sentinelCompletion as qh, CheckSource as qi, PursuitNodePlatform as ql, SubmitOutput as qm, WriteWorkerSteerOptions as qn, runBenchmark as qo, ResolvedMcpServerLaunch as qp, GraphRunRecord as qr, sampleThenRefine as qs, EVIDENCE_MAX_CHARS as qt, SeatStage as qu, SpawnForestNode as qv, harnessTranscriptArtifact as qx, ResourceLimit as qy, AgentBackendInput as r, Redactor as rC, readBoundHarnessSessions as rS, EventAcknowledgement as r_, composeCheckSources as ra, Settled as rb, ObservationError as rc, PromptHandle as rd, UNPROVEN_CONTINUITY as rf, createCodexRolloutStoreReader as rg, DelegationHistoryArgs as rh, listGraphRuns as ri, LeaderboardBenchScore as rl, mapSandboxEvent as rm, copyUntrackedIntoClone as rn, startRetainedInteractiveRun as ro, createExecutor as rp, writeWorkerSteer as rr, TERMINAL_DECISIONS as rs, AgentSessionRef as rt, ObserverJournal as ru, createPeerMailbox as rv, ExecutorAccounting as rx, SpawnJournal as ry, AgentRuntimeEventSink as s, BackendTransportError as sC, ProviderNativeCapturePhase as sS, ToolOutcomeEvent as s_, modelAuthoredChecks as sa, SubtreeResult as sb, observe as sc, createPromptRegistry as sd, FinalizerSettled as sf, decodeHarnessUsage as sg, DelegationStatus as sh, recordGraphRun as si, LeaderboardIterationInfo as sl, extractLlmCallEvent as sm, Workspace as sn, profileOptimizerModelCall as so, CliWorktreeSeam as sp, RemoteSupervisorReader as sr, InProcessOnPrompt as ss, CheckpointRef as st, AgentGraph as su, JsonRpcMessage as sv, ExecutorTeardownWarning as sx, RootHandle as sy, AgentAdapter as t, startRuntimeRun as tC, RetainedHarnessTranscriptCapture as tS, AwaitWakeInput as t_, canDisplace as ta, NodeStatus as tb, Observation as tc, createInMemoryRunContext as td, ReentryContinuity as tf, CodexStoreDelta as tg, DelegationError as th, graphRegistry as ti, providerAsSandboxClient as tl, SandboxToolPartState as tm, CopyOptions as tn, reconnectRetainedInteractiveRun as to, createExecutorRegistry as tp, supervisorRunsRoot as tr, superviseDispatch as ts, AgentProfile$2 as tt, projectPursuit as tu, PeerMailboxOptions as tv, EnvironmentTeardownReceipt as tx, ResultBlobStore as ty, AgentTaskSpec as u, NotFoundError as uC, ProviderWorkspaceCaptureReceipt as uS, GateDecision as u_, sandboxCheckRunner as ua, FleetYield as ub, CombinatorShape as uc, dumbContinuationPassPrompt as ud, CoordinationAuthentication as uf, CodeModeToolContext as ug, FeedbackRefersTo as uh, taskShapeDigest as ui, LeaderboardScore as ul, RouterTransportConfig as um, gitWorkspace as un, PrivateCasOffloadReport as uo, RouterToolsSeam as up, RemoteWorkerEvents as ur, inProcessSandboxClient as us, CreateSandboxOptions$1 as ut, GraphEdge as uu, McpToolDescriptor as uv, HeldRelease as ux, RootSignal as uy, RunAgentTaskStreamOptions as v, RecoverRetainedRunResult as vC, UsageEvent as vS, ChildQuestionInbox as v_, StreamAgentTurnOptions as va, ReenteredWorkers as vb, FanoutSynthesis as vc, SupervisorSpanRecorder as vd, CoordinationRejectReason as vf, Interval as vg, KnowledgeItem as vh, rollingDispatch as vi, declaredCheckDeliverable as vl, ToolLoopToolCall as vm, DEFAULT_MAX_DEPTH as vn, InMemoryCorpus as vo, Inbox as vp, ProfileRegistryDir as vr, connectStdioMcp as vs, WorkspaceRequest as vt, runGraph as vu, WatchTraceOptions as vv, TraceSource as vx, OtelAttribute as vy, RuntimeFailureCode as w, RetainedRunAdmissionHook as wC, LoopDecisionPayload as wS, QuestionEscalationTarget as w_, StrategyEvolutionConfig as wa, WorkerEventCursor as wb, PanelSpec as wc, supervisorAgentWithTestBrain as wd, ContinuationAppend as wf, ProfileKeyOf as wg, researcherProfile as wh, defaultDelegateBudget as wi, IsolatedCheckOptions as wl, DelegateRunCtx as wm, SqlRunContextOptions as wn, pipeline as wo, SharedBoxCloseReceipt as wp, profileRunsForName as wr, AgenticTool as ws, HarvestSurfaceDiffsOptions as wt, PursuitFork as wu, AnalystLensOutput as wv, ScopeProgressInput as wx, createOtelExporter as wy, RuntimeSessionStore as x, RetainedInteractiveIntentAdmission as xC, Driver as xS, QuestionDecision as x_, EvolutionAuthor as xa, Scope as xb, LoopUntilState as xc, readRootStream as xd, FileCoordinationLog as xf, LeaderboardRow as xg, ResearchSource as xh, GraphDesignerExtraTools as xi, readDeclaredCheck as xl, CoderDelegate as xm, ValidateStoredGraphOptions as xn, flatWidenGate as xo, PeerInboxMessage as xp, loadProfile as xr, AgenticRunResult as xs, VerifierEnvironmentOptions as xt, GraphFromStoredOptions as xu, AnalystAssignmentRecord as xv, ActivityNote as xx, OtelExporter as xy, RuntimeCanonicalStreamEvent as y, RetainedInteractiveAdmission as yC, AgentRunSpec as yS, EscalateQuestion as y_, collectAgentTurn as ya, ResumedKeyState as yb, FanoutWinnerSelector as yc, createSupervisorSpanRecorder as yd, CoordinationDeliveryEvidence as yf, Leaderboard as yg, KnowledgeUpdate as yh, DesignerRunGraphEnv as yi, declaredCheckDigest as yl, FeedbackEvent as ym, createSupervisor as yn, renderCorpusToInstructions as yo, InboxLease as yp, ProfileRunRecord as yr, materializeLocalMcp as ys, computeFindingId$1 as yt, runGraphWithTestBrain as yu, defaultToolDetectors as yv, createPushTraceSource as yx, OtelExportConfig as yy, MakeWorkerAgent as z, LoopWinner as zS, WorkerResumeContext as z_, SandboxLineageHandle as za, AgentSpec as zb, WidenLineage as zc, SupervisorProfile as zd, SpawnResourceBytes as zf, renderAnytimeTable as zg, mapExecutorResult as zh, defaultProfileRichnessThresholds as zi, SupervisePursuitOptions as zl, DelegationRecord as zm, TRACE_SUMMARY_SCHEMA as zn, BenchmarkCell as zo, ProviderPromptOptions as zp, GraphFileSeat as zr, Strategy as zs, WorktreeCliExecutorOptions as zt, resolveWorkerSpawnRetry as zu, SqlRunOwnershipError as zv, HarnessTranscriptCapture as zx, ParkedRun as zy };
-//# sourceMappingURL=types-ooyUaxq_.d.ts.map
+export { AgentEnvironmentStatus as $, AgentEvalErrorCode as $S, BusStats as $_, startRetainedRunInEnvironment as $a, Executor as $b, ShapeContext as $c, CoordinationControlAccess as $d, SandboxSeam as $f, RouteFlowEvent as $g, CodeModeToolsOptions as $h, StructuralRolloutResult as $i, PursuitRunProjection as $l, ResearchOutputShape as $m, safeWorkerFile as $n, SuperviseOptionsForDispatch as $o, RouterRouting as $p, graphDigest as $r, HarvestFailure as $s, settledWorkerOut as $t, analyzesFindingsReportPrompt as $u, SpawnEvent as $v, RetainedHarnessTranscriptDescriptor as $x, RetainedExecutionState as $y, DriverContinuationRecord as A, StartRetainedRunInEnvironmentOptions as AC, LoopTraceEmitter as AS, DEFAULT_PEER_MAIL_LIMITS as A_, Deliverable as Aa, ReservationRejection as Ab, ScopeAnalyzeInput as Ac, SupervisorToolInvocationContext as Ad, environmentReader as Af, WaterfallSpan as Ag, CompletionEvidence as Ah, ChatWorkerSeamOptions as Ai, NextPursuitVersionInput as Al, DelegationResumeTick as Am, SearchSpecOwnedOption as An, RegistryAnalyzeProjection as Ao, ProviderPlacement as Ap, workerFromInteractiveProvider as Ar, StrategyShotResult as As, boxSurfaceReader as At, workerFromBackend as Au, SpawnForestInDoubtNode as Av, RetainedInteractiveRunHandle as Ax, createRuntimeEventCollector as Ay, PeerAuditAccess as B, Validator as BS, PeerMailboxOptions as B_, createSandboxLineage as Ba, SpawnModelSubstitution as Bb, WidenLineage as Bc, anyOf as Bd, DelegateHandlerOptions as Bf, AwaitWakeInput as Bg, CodexRolloutStoreReader as Bh, profileRichnessFinding as Bi, SupervisePursuitOptions as Bl, DelegateUiAuditArgs as Bm, TraceRootArtifact as Bn, BenchmarkCell as Bo, secretEnvOfMcpServer as Bp, LoadGraphFileOptions as Br, Strategy as Bs, WorktreePatchArtifact as Bt, SeatStage as Bu, SpawnJournalReadResult as Bv, HarnessTranscriptUnavailableReason as Bx, readRunParking as By, RuntimeFailureCause as C, RetainedRunEventOptions as CC, LoopPlanDescription as CS, DownMessageEvent as C_, EvolutionStrategy as Ca, WorkerEventPage as Cb, Panel as Cc, ResolveDriveHarness as Cd, DriverReentry as Cf, anytimeReport as Cg, CompletionCheckContext as Ch, DelegateOptions as Ci, IsolatedCheckBox as Cl, DetachedTurn as Cm, FencedSqlRunContext as Cn, loopUntil as Co, createAgentEnvironmentProviderRegistry as Cp, profileRegistry as Cr, AgenticSurface as Cs, BoxSurfaceReaderOptions as Ct, defaultEdgeTraversalCap as Cu, CodexExecutionPolicy as Cv, WorkerProgress as Cx, RuntimeEventCollector as Cy, RetainedPendingCause as D, RetainedRunSnapshot as DC, LoopStartedPayload as DS, MapSpawnMarker as D_, TournamentRow as Da, LeakedReservation as Db, PipelineStage as Dc, SupervisorNodeContext as Dd, SpawnResourceBytes as Df, renderAnytimeTable as Dg, mapExecutorResult as Dh, ChatSessionStore as Di, runIsolatedCheck as Dl, DelegationRecord as Dm, SEARCH_SPEC_CORRELATION_KEY as Dn, verify as Do, ProviderPromptOptions as Dp, InteractiveWorkerKeyInput as Dr, CorpusReadbackOptions as Ds, SurfaceReadOutcome as Dt, supervise as Du, materializeTreeView as Dv, RecoverRetainedInteractiveRunOptions as Dx, RuntimeTelemetryOptions as Dy, EvidencePendingEvent as E, RetainedRunReplayPoint as EC, LoopSandboxPlacement as ES, MapOnSettleRoute as E_, TournamentCell as Ea, BudgetReadout as Eb, PanelVerdict as Ec, SupervisorAgentTestDeps as Ed, ResolvedSpawnResourcePath as Ef, plateauLength as Eg, gateOnDeliverable as Eh, ChatCompletionsTransport as Ei, IsolatedCheckResult as El, DelegationArgs as Em, CompiledSearchSpec as En, selectValidWinner as Eo, ProviderLeafOut as Ep, InteractiveWorkerEnvironment as Er, ArtifactHandle as Es, SurfaceReadBox as Et, RUN_FORK_CORRELATION_KEYS as Eu, SqlAdapter as Ev, ReconnectRetainedInteractiveRunOptions as Ex, RuntimeStreamEventSummary as Ey, CoordinationTools as F, OutputAdapter as FS, PeerMailOutcome as F_, SandboxRunAbortError as Fa, createBudgetPool as Fb, TrajectoryReportOptions as Fc, PlateauOptions as Fd, EventSubscription as Ff, WorktreeCheckRunner as Fg, sentinelCompletion as Fh, ProfileRichness as Fi, VersionJudge as Fl, SubmitOutput as Fm, settledToIteration as Fn, observationFromRegistry as Fo, ResolvedMcpServerLaunch as Fp, graphFromSessionFacts as Fr, runAgentic as Fs, failuresAnalyst as Ft, SuperviseRegistry as Fu, FileResultBlobStore as Fv, HarnessTranscriptBinding as Fx, createWorkerSlots as Fy, SpawnRefusalCause as G, RuntimeRunPersistenceAdapter as GS, peerMailVerbNames as G_, S3PrivateCasStoreOptions as Ga, ExecutorNodeContext as Gb, LoopShape as Gc, UNPROVEN_CONTINUITY as Gd, createExecutor as Gf, ManagerWake as Gg, createCodexRolloutStoreReader as Gh, CheckRunContext as Gi, PursuitObserverDelivery as Gl, DelegationHistoryArgs as Gm, WorkerSteerAcknowledgement as Gn, BenchmarkTaskRow as Go, mapSandboxEvent as Gp, GraphRegistryDir as Gr, assertStrategyContract as Gs, attachWorker as Gt, RunContext as Gu, RunCancelRequest as Gv, persistHarnessTranscript as Gx, ResourceSpend as Gy, SpawnPreflight as H, RuntimeRunCost as HS, createPeerMailbox as H_, AcquireOptions as Ha, ExecutionBindingReceipt as Hb, WinnerStrategy as Hc, plateau as Hd, createDelegateHandler as Hf, EventAcknowledgement as Hg, CodexRolloutTurn as Hh, RunCancellationReason as Hi, superviseGraphPursuit as Hl, DelegateUiAuditRoute as Hm, RunTraceSources as Hn, BenchmarkLift as Ho, SandboxOutputMarker as Hp, loadGraphFile as Hr, StrategyCtx as Hs, AttachWorkerOptions as Ht, subscriptionUsageLimitSignal as Hu, FileSpawnJournal as Hv, captureBoundHarnessTranscript as Hx, BudgetOverspend as Hy, CoordinationToolsOptions as I, RunProvenance as IS, PeerMailReadout as I_, TurnResult as Ia, AgentSpec as Ib, Verify as Ic, ProgressView as Id, EventSubscriptionStore as If, WorktreeCommandResult as Ig, stopSentinel as Ih, ProfileRichnessThresholds as Ii, VersionVerdict as Il, DelegateCodeArgs as Im, createScope as In, McpEndpoint as Io, envKeyProvider as Ip, graphFileSchema as Ir, sample as Is, AuthoredHarness as It, SuperviseRegistryTable as Iu, replaySpawnTree as Iv, HarnessTranscriptCapture as Ix, ParkedRun as Iy, AgentEnvironment$1 as J, startRuntimeRun as JS, McpToolAnnotations as J_, PrivateCasNamespaceObject as Ja, NodeExecutionIdentity as Jb, PersonaContext as Jc, FinalizeContext as Jd, CliWorktreeBridgeSeam as Jf, DecideGate as Jg, HarnessUsage as Jh, CheckSourceCtx as Ji, PursuitNodePlatform as Jl, DelegationResultPayload as Jm, cancelWorker as Jn, runBenchmark as Jo, SandboxUsageLedger as Jp, GraphSelection as Jr, sampleThenRefine as Js, NOTE_MAX_CHARS as Jt, createInMemoryRunContext as Ju, readRunCancelRequest as Jv, HarnessFileBinding as Jx, SpendGap as Jy, SuperviseProfileEntry as K, RuntimeRunRow as KS, JsonRpcMessage as K_, createS3PrivateCasStore as Ka, MaterializedExecutionIdentity as Kb, Outcome as Kc, composeReentryTask as Kd, CliInPlaceSeam as Kf, ToolOutcomeEvent as Kg, harnessUsageIsEmpty as Kh, CheckRunner as Ki, PursuitCostProvenance as Kl, DelegationHistoryEntry as Km, WorkerSteerRequest as Kn, Environment as Ko, mapSandboxToolEvent as Kp, GraphRunQuery as Kr, authorStrategy as Ks, readWorkerInteractiveBinding as Kt, RunContextLease as Ku, RunCancellation as Kv, BoundHarnessSession as Kx, Spend as Ky, GraphSubtaskPreparation as L, SandboxClient as LS, PeerMailRefusal as L_, openSandboxRun as La, ExecutorContext as Lb, VerifySpec as Lc, StopDecision as Ld, McpEventRecord as Lf, WorktreeHarnessResult as Lg, CodexForkBoundary as Lh, asAuthoredProfile as Li, assertPursuitVersions as Ll, DelegateCodeConfig as Lm, ScopeArgs as Ln, McpEnvironmentOptions as Lo, mcpSecretEnvMetadataKey as Lp, graphRouteWhenSchema as Lr, AuthorStrategyOptions as Ls, WorktreeFanoutOptions as Lt, SeatSegment as Lu, SpawnJournalCursor as Lv, HarnessTranscriptEvidence as Lx, RunParkedError as Ly, DriverRepromptRefusal as M, LoopWinner as MS, PeerMailEnvelope as M_, OpenSandboxRunOptions as Ma, ReservationStage as Mb, SteerContext as Mc, SupervisorProfile as Md, McpServer as Mf, RunAgentRoundsOptions as Mg, CompletionVerdict as Mh, chatWorkerSeam as Mi, PursuitVersionStop as Ml, DelegationTaskQueue as Mm, compileSearchSpec as Mn, buildSteerContext as Mo, BridgeModelCredential as Mp, createInPlaceCliExecutor as Mr, breadthStrategy as Ms, harvestSurfaceDiffs as Mt, AuthorizedSpawnContext as Mu, SpawnForestNode as Mv, StartRetainedInteractiveRunOptions as Mx, sanitizeKnowledgeReadinessReport as My, BlockedToolReport as N, MountManifestEntry as NS, PeerMailEvent as N_, OpenSandboxRunPromptOptions as Na, ReservationTicket as Nb, TrajectoryNode as Nc, AllWorkersStalledOptions as Nd, McpServerOptions as Nf, runAgentRounds as Ng, completionAuthorizes as Nh, createChatSessionStore as Ni, PursuitVersions as Nl, DelegationTaskQueueOptions as Nm, searchPresets as Nn, createScopeAnalyst as No, BridgeSeam as Np, GraphSessionObservationOptions as Nr, depthStrategy as Ns, AnalystAuthoring as Nt, SuperviseOptions as Nu, SpawnForestTree as Nv, HARNESS_TRANSCRIPT_SETTLE_TIMEOUT_MS as Nx, DeadlineCheckIn as Ny, DriverAttemptRecord as O, RetainedRunStartMaterial as OC, LoopTeardownFailedPayload as OS, MapTraversalEvent as O_, runStrategyEvolution as Oa, ReservationFloor as Ob, RenderCorpusToInstructionsOptions as Oc, SupervisorNodeContextSeed as Od, SpawnResourceRead as Of, WaterfallCollector as Og, verdictFromJudgeScore as Oh, ChatTransportExecutorOptions as Oi, JudgedPursuitVersion as Ol, DelegationResumeContext as Om, SearchSpec as On, widen as Oo, providerAsExecutor as Op, InteractiveWorkerOptions as Or, RunAgenticOptions as Os, SurfaceReader as Ot, superviseFleetCapabilities as Ou, SpawnForest as Ov, RetainedInteractiveAdmissionHook as Ox, SanitizedKnowledgeReadinessReport as Oy, CoordinationStats as P, MountRecorder as PS, PeerMailLimits as P_, SandboxRun as Pa, ReserveOptions as Pb, TrajectoryReport as Pc, NoProgressForOptions as Pd, createMcpServer as Pf, InPlaceHarnessResult as Pg, deterministicCompletion as Ph, AuthoredProfile as Pi, SettledPursuitVersion as Pl, SubmitInput as Pm, searchSpecDigest as Pn, registryScopeAnalyst as Po, KeyProvider as Pp, ObservedSessionFacts as Pr, refine as Ps, analystsFromRegistry as Pt, SuperviseTestOptions as Pu, loadSpawnForest as Pv, HarnessTranscriptArtifact as Px, WorkerSlots as Py, AgentEnvironmentQuery as Q, AgentEvalError$1 as QS, BusRecord as Q_, startRetainedRun as Qa, EnvironmentTeardownReceipt as Qb, ShapeBudget as Qc, CoordinationAuthentication as Qd, RouterToolsSeam as Qf, RouteFlow as Qg, CodeModeToolContext as Qh, StructuralRolloutPolicy as Qi, PursuitProjection as Ql, FeedbackRefersTo as Qm, readWorkerSteerRequests as Qn, SuperviseDispatchOptions as Qo, RouterTransportConfig as Qp, graphCorpusSummary as Qr, HarvestError as Qs, composeWorkerEvidence as Qt, RegisteredPrompt as Qu, ResultBlobStore as Qv, RetainedHarnessTranscriptCapture as Qx, NodeStatus as Qy, GraphSubtasks as R, SelectionReceipt as RS, PeerMailSendInput as R_, SandboxLineage as Ra, ExecutorFactory as Rb, Widen as Rc, StopRule as Rd, McpEventSource as Rf, WorktreeProfileMaterializationReceipt as Rg, CodexRolloutIdentity as Rh, assessAuthoredProfile as Ri, SuperviseGraphPursuitOptions as Rl, DelegateResearchArgs as Rm, TRACE_ROOT_SCHEMA as Rn, createMcpEnvironment as Ro, resolveMcpServerLaunch as Rp, GraphFileResolutionError as Rr, AuthoredStrategy as Rs, worktreeFanout as Rt, SeatSelection as Ru, SpawnJournalReadOptions as Rv, HarnessTranscriptFile as Rx, RunParkingPolicy as Ry, RuntimeStreamEvent as S, RetainedRunEnvironmentAdmission as SC, LoopLineageOptions as SS, DownMessageDeliveryOutcome as S_, EvolutionReport as Sa, WorkerEventEntry as Sb, LoopUntilState as Sc, ObserveSupervisorNodeEvent as Sd, DriverContractState as Sf, AnytimeTaskCurve as Sg, CheckVerdict as Sh, graphDesignerExtraTools as Si, readDeclaredCheck as Sl, createSiblingSandboxExecutor as Sm, validateStoredGraph as Sn, flatWidenGate as So, AgentEnvironmentProviderRegistry as Sp, pickBestProfile as Sr, AgenticRunResult as Ss, createVerifierEnvironment as St, GraphFromStoredOptions as Su, CodexTokenUsage as Sv, TeamProgress as Sx, loopEventToOtelSpan as Sy, RuntimeFailureOwner as T, RetainedRunIntentAdmission as TC, LoopResult as TS, MapItemFailurePolicy as T_, StrategyTournament as Ta, BudgetPoolRestore as Tb, PanelSpec as Tc, SupervisorAgentDeps as Td, ResolveSpawnResourcePathsResult as Tf, bestSoFar as Tg, ExecutorResultMapping as Th, delegate as Ti, IsolatedCheckOptions as Tl, runDetachedTurn as Tm, createFencedSqlRunContext as Tn, pipeline as To, ProviderExecutorOptions as Tp, recordProfileRun as Tr, AgenticTool as Ts, SurfaceDiff as Tt, PursuitFork as Tu, openSqlRunStore as Tv, readWorkerProgress as Tx, RuntimeStreamEventSink as Ty, SpawnPreflightContext as U, RuntimeRunHandle as US, isPeerMailEnvelope as U_, acquireSandbox as Ua, ExecutorExecutionBinding as Ub, DefinePersona as Uc, ReentryContinuity as Ud, createExecutorRegistry as Uf, LeadMessage as Ug, CodexStoreDelta as Uh, CheckExecChannel as Ui, supervisePursuit as Ul, DelegationError as Um, runToolSpans as Un, BenchmarkReport as Uo, SandboxToolPartState as Up, GraphCorpusGroup as Ur, StrategyResult as Us, WorkerInteractiveBinding as Ut, InMemoryRunContext as Uu, RunState as Uv, captureHarnessTranscript as Ux, BudgetViolation as Uy, SettledWorker as V, RuntimeRunCompleteInput as VS, claimsAuthority as V_, SandboxEvidenceReceipt as Va, AgentExecutionRef as Vb, WidenSpec as Vc, noProgressFor as Vd, DelegateResult as Vf, CoordinationEvent as Vg, CodexRolloutStoreRef as Vh, supervisorInstructions as Vi, SupervisedPursuitResult as Vl, DelegateUiAuditConfig as Vm, TraceSummary as Vn, BenchmarkConfig as Vo, SandboxLeafOut as Vp, LoadedGraphFile as Vr, StrategyArtifacts as Vs, createWorktreeCliExecutor as Vt, SelectSeat as Vu, readSpawnJournal as Vv, ReadableEnvironment as Vx, Budget as Vy, SpawnRefusal as W, RuntimeRunOptions as WS, peerMailTools as W_, S3PrivateCasStore as Wa, ExecutorMaterialization as Wb, DefinePersonaInput as Wc, ReentryTaskInput as Wd, ExecutorConfig as Wf, ManagerReentryState as Wg, addHarnessUsage as Wh, CheckOutcome as Wi, RunReopen as Wl, DelegationFeedbackSnapshot as Wm, WorkerCancellation as Wn, BenchmarkStrategySummary as Wo, createSandboxToolPartState as Wp, GraphCorpusSummary as Wr, adaptiveRefine as Ws, WorkerInteractiveProviderSource as Wt, InMemoryRunContextOptions as Wu, readRunState as Wv, harnessTranscriptArtifact as Wx, ResourceLimit as Wy, AgentEnvironmentEvent$1 as X, Redactor as XS, McpTransport as X_, reconnectRetainedRun as Xa, RootMaterialization as Xb, RunPersonified as Xc, SupervisorFinalizer as Xd, ProviderSeam as Xf, GateRequest as Xg, CodeModeStore as Xh, StructuralRolloutConfig as Xi, PursuitNodeTiming as Xl, DelegationStatusResult as Xm, readWorkerCancellation as Xn, LoopDispatchOptions as Xo, sumSandboxUsage as Xp, StoredGraphInput as Xr, strategyAuthorSystemPrompt as Xs, WorkerEvidenceInput as Xt, PromptHandle as Xu, InMemoryResultBlobStore as Xv, HarnessTranscriptReadLimits as Xx, NodeId as Xy, AgentEnvironmentCapabilities$1 as Y, contentAddress as YS, McpToolDescriptor as Y_, PrivateCasNamespaceRetirement as Ya, ProfileMaterializationReceipt as Yb, PersonaExecutors as Yc, FinalizerSettled as Yd, CliWorktreeSeam as Yf, GateDecision as Yg, decodeHarnessUsage as Yh, RepairStop as Yi, PursuitNodeProjection as Yl, DelegationStatus as Ym, legacySupervisorRunDir as Yn, LoopCampaignDispatchOptions as Yo, extractLlmCallEvent as Yp, StoredGraph as Yr, strategyAuthorContract as Ys, VERIFY_TAIL_CHARS as Yt, withRunContext as Yu, readRunCancellation as Yv, HarnessTranscriptMetadata as Yx, Handle as Yy, AgentEnvironmentProvider$1 as Z, defaultRedactor as ZS, BusEvent as Z_, recoverRetainedRun as Za, UnknownMaterializationReason as Zb, RunPersonifiedOptions as Zc, bestDelivered as Zd, RouterSeam as Zf, JsonScalar as Zg, CodeModeTool as Zh, StructuralRolloutMessage as Zi, PursuitNodeUsage as Zl, FeedbackRating as Zm, readWorkerSteerAcknowledgement as Zn, LoopOptionsForDispatch as Zo, RouterResponseReceipt as Zp, digestOfGraph as Zr, HarvestCorpusOptions as Zs, closingWorkerNote as Zt, PromptRegistry as Zu, InMemorySpawnJournal as Zv, HarnessTranscriptReadOptions as Zx, NodeSnapshot as Zy, RunAgentTaskOptions as _, RetainedRunAdmissionHook as _C, LoopDecisionPayload as _S, AuthorizedDownMessage as __, CollectedAgentTurn as _a, ResumedWork as _b, EqualKVerdict as _c, supervisorAgentWithTestBrain as _d, ContinuationPolicy as _f, renderLeaderboardMarkdown as _g, FileDelegationStore as _h, queueOf as _i, assertDeclaredCheck as _l, DelegationExecutor as _m, parseWorkerToolTraceArtifact as _n, runPersonified as _o, sharedBoxPlacement as _p, provisionSupervisor as _r, StdioMcpConnection as _s, SandboxInstance$1 as _t, RunGraphTestOptions as _u, LocalHarnessResult as _v, ActivityLog as _x, OtelExportStats as _y, AgentKnowledgeProvider as a, NativeContextContinuationExecution as aC, ProviderWorkspaceCaptureReceipt as aS, Question as a_, defaultStructuralRolloutPolicy as aa, SubtreeSummary as ab, ObserveInput as ac, kernelPromptRegistry as ad, CoordinationHttpAudit as af, GroupOf as ag, UiLens as ah, lookupGraph as ai, LeaderboardBenchTask as al, ToolLoopMessageRecord as am, GitWorkspaceOptions as an, ResolveSandboxClientOptions as ao, AuthorityInboxMessage as ap, RemoteSupervisorCancelResult as ar, TerminalDecision as as, AgentTurnResult$2 as at, ObserverRecord as au, watchTrace as av, HeldEnvironment as ax, RootSegment as ay, RuntimeSession as b, RetainedRunDispatchedAdmission as bC, LoopIterationEndedPayload as bS, DownMessageAuthorizationInput as b_, streamAgentTurn as ba, WidenGate as bb, FanoutWinnerSelector as bc, DriveHarness as bd, VerdictSummary as bf, AnytimeReport as bg, CoderTask as bh, DesignerToolsEnv as bi, declaredCheckDigest as bl, SiblingSandboxExecutorOptions as bm, createRootHandle as bn, renderCorpusToInstructions as bo, sharedWorkerClientName as bp, bestProfileFor as br, materializeLocalMcp as bs, makeFinding$1 as bt, runGraphWithTestBrain as bu, LOCAL_HARNESSES as bv, ExecutorProgress as bx, buildLoopOtelSpans as by, AgentTaskContext as c, ReconnectRetainedRunOptions as cC, ExecutorProgressEvent as cS, QuestionEscalationRecord as c_, officialChecksFromMeta as ca, NoWinnerError as cb, observe as cc, SupervisorSpanAttributes as cd, CoordinationLog as cf, LeaderboardOptions as cg, ResearchOutput as ch, recordStoredGraphRun as ci, LeaderboardIterationInfo as cl, FeedbackStore as cm, WorkspaceCommit as cn, profileOptimizerModelCall as co, InboxMessage as cp, RemoteSupervisorSteerResult as cr, InProcessOnPrompt as cs, CheckpointRequest as ct, AgentGraph as cu, AnalystKind as cv, Runtime as cx, SteerableRootHandle as cy, AgentTaskStatus as d, RecoverRetainedRunResult as dC, UsageEvent as dS, QuestionOption as d_, selectBestIndex as da, RootProviderModelEvidence as db, CombinatorShape as dc, SupervisorSpanRecorder as dd, CheckRead as df, PairwiseVerdict as dg, ResearcherProfileOptions as dh, GraphTriggerBinding as di, LeaderboardScore as dl, CoderReviewer as dm, jjWorkspace as dn, PrivateCasOffloadReport as do, DEFAULT_SHARED_BOX_WORKERS as dp, connectRemoteSupervisor as dr, inProcessSandboxClient as ds, ExecRequest as dt, GraphEdge as du, AnalystRunContext as dv, WorkerTraceEvidence as dx, WorkerTraceResolver as dy, BackendTransportError as eC, readBoundHarnessSessions as eS, RouteGate as e_, VisibleCheck as ea, Settled as eb, HarvestReport as ec, createPromptRegistry as ed, CoordinationMcpHandle as ef, CodeModeToolset as eg, UiAuditLensFilter as eh, graphFromStored as ei, ShapeRegistry as el, ToolSpec as em, spendFromUsageEvents as en, ClaimRetainedInteractiveControlOptions as eo, DEFAULT_SANDBOX_STEERING_MAX_TURNS as ep, supervisorRunDir as er, loopCampaignDispatch as es, AgentEnvironmentSummary as et, PursuitRunTotals as eu, EventBus as ev, ExecutorAccounting as ex, SpawnJournal as ey, BackendErrorDetail as f, RetainedInteractiveAdmission as fC, AgentRunSpec as fS, QuestionPolicy as f_, structuralRollout as fa, RootStreamReceipt as fb, Corpus as fc, createSupervisorSpanRecorder as fd, ContinuationAppend as ff, ProfileKeyOf as fg, researcherProfile as fh, DispatchReport as fi, LeaderboardSpec as fl, DelegateRunCtx as fm, localShell as fn, PrivateCasOptions as fo, SharedBoxCloseReceipt as fp, connectRemoteSupervisorControl as fr, HttpMcpServerSpec as fs, ExecResult as ft, GraphEdgeCapError as fu, AnalyzeOnSettleRoute as fv, WorkerTraceUnavailableReason as fx, TraceContext as fy, OpenAIChatToolChoice as g, RetainedRunAdmission as gC, Iteration as gS, AuthorizeDownMessage as g_, AgentTurnUsage as ga, ResumedKeyState as gb, EqualKOnCostOptions as gc, supervisorAgent as gd, ContinuationPanelResult as gf, renderLeaderboardHtml as gg, DelegationStore as gh, freeSlots as gi, DeclaredCheckStateCapture as gl, detachedSessionDelegate as gm, WorkerToolTraceArtifact as gn, definePersona as go, SharedWorkerIdentity as gp, SupervisorCleanupReceipt as gr, McpSpawnFault as gs, SandboxEvent$1 as gt, RunGraphOptions as gu, CodexExecutionEvidence as gv, createPushTraceSource as gx, OtelExportConfig as gy, OpenAIChatTool as h, RetainedInteractiveStartedAdmission as hC, ExecCtx as hS, questionEscalationTargets as h_, AgentTurnInput$1 as ha, ReenteredWorkers as hb, EqualKArm as hc, readRootStreamReceipt as hd, ContinuationPanelInput as hf, pairwiseSignificance as hg, DelegationPersistenceError as hh, RollingDispatchOptions as hi, DeclaredCheckPlacement as hl, UiAuditorDelegate as hm, analyzeTrace as hn, trajectoryReport as ho, SharedBoxStats as hp, ProvisionedSupervisor as hr, McpListedTool as hs, ResourceRequest as ht, GraphTopology as hu, DefinedAnalystRecord as hv, TraceSource as hx, OtelAttribute as hy, AgentExecutionBackend as i, ValidationError as iC, ProviderWorkspaceCaptureProvenance as iS, EscalateQuestion as i_, defaultExtractCandidate as ia, SubtreeResult as ib, ObservationError as ic, formatPromptHandle as id, serveCoordinationMcp as if, AxisScoresOf as ig, UiFindingSeverity as ih, loadGraph as ii, LeaderboardBenchScore as il, ToolLoopCompactionOptions as im, withUntrackedArtifacts as in, startRetainedInteractiveRun as io, createSteerableSandboxSession as ip, RemoteSupervisorAgent as ir, TERMINAL_DECISIONS as is, AgentSessionStatus$1 as it, ObserverJournal as iu, defaultToolDetectors as iv, ExecutorTeardownWarning as ix, RootHandle as iy, DriverFailureClass as j, StartRetainedRunOptions as jC, LoopTraceEvent as jS, PEER_MAIL_WIRE_KEY as j_, OpenSandboxRunBeforeStartContext as ja, ReservationShortfall as jb, ScopeWidenGate as jc, ManagerWakePolicy as jd, resolveSpawnResourcePaths as jf, createWaterfallCollector as jg, CompletionPolicy as jh, chatTransportExecutor as ji, PursuitVersionChain as jl, DelegationRunContext as jm, assertSearchSpec as jn, assertTraceDerivedFindings as jo, BridgeHarnessStore as jp, InPlaceCliExecutorOptions as jr, SurfaceScore as js, fsSurfaceReader as jt, AuthorizedSpawn as ju, SpawnForestMissingTree as jv, RetainedInteractiveStartMaterial as jx, createRuntimeStreamEventCollector as jy, DriverAttemptStop as k, RetainedRunTurnInput as kC, LoopTokenUsage as kS, AUTHORITY_MARKERS as k_, strategyTournament as ka, ReservationHolder as kb, ScopeAnalyst as kc, SupervisorToolDescriptor as kd, SpawnResourceReader as kf, WaterfallReport as kg, CompletionAnalyst as kh, ChatTransportTool as ki, NextPursuitVersion as kl, DelegationResumeDriver as km, SearchSpecInputs as kn, CreateScopeAnalystOptions as ko, UnavailablePausePolicy as kp, InteractiveWorkerResult as kr, StrategyMessage as ks, WatchedSurface as kt, superviseWithTestBrain as ku, SpawnForestEvent as kv, RetainedInteractiveEnvironmentInput as kx, SanitizedKnowledgeRequirement as ky, AgentTaskRunResult as l, RecoverRetainedRunIntentOptions as lC, ExecutorToolCall as lS, QuestionEscalationTarget as l_, resolveEntrySymbol as la, ProviderModelAttemptEvidence as lb, renderReport as lc, SupervisorSpanOptions as ld, FileCoordinationLog as lf, LeaderboardRow as lg, ResearchSource as lh, storedGraphDigests as li, LeaderboardRunContext as ll, CoderDelegate as lm, WorkspaceRun as ln, PrivateCasArtifactPort as lo, PeerInboxMessage as lp, RemoteSupervisorTree as lr, InProcessPromptCtx as ls, CreateAgentEnvironmentInput$1 as lt, EdgeDeliveryOutcome as lu, AnalystLensOutput as lv, WorkerInteractiveSession as lx, Supervisor as ly, OpenAIChatResponseFormat as m, RetainedInteractiveIntentAdmission as mC, Driver as mS, QuestionUrgency as m_, AgentTurnBackend as ma, Agent as mb, CorpusRecord as mc, readRootStream as md, ContinuationPanel as mf, leaderboard as mg, composeLoopTraceEmitters as mh, DispatchUnit as mi, DeclaredCheck as ml, DetachedWinnerSelection as mm, TrajectoryAnalysis as mn, equalKOnCost as mo, SharedBoxPlacementOptions as mp, ProvisionSupervisorRequest as mr, MaterializeLocalMcpOptions as ms, PlacementInfo as mt, GraphResult as mu, AuthoredAnalystLimits as mv, ToolStepInput as mx, readTraceContextFromEnv as my, AgentBackendContext as n, JudgeError as nC, retainHarnessTranscript as nS, RouteWhen as n_, compareCheckOutcomes as na, SpawnPrior as nb, Observation as nc, dumbContinuationFailPrompt as nd, CoordinationReadAccess as nf, createCodeModeTools as ng, UiFinding as nh, graphRunsFor as ni, providerAsSandboxClient as nl, ToolLoopChat as nm, UntrackedCopyStats as nn, reconnectRetainedInteractiveRun as no, SteerableSandboxArgs as np, workerInboxFileFromEventDir as nr, superviseDispatch as ns, AgentSession as nt, projectPursuit as nu, createEventBus as nv, ExecutorCancellationRequest as nx, WorkspaceCheckpointMarker as ny, AgentRuntimeEvent as o, NativeContextContinuationHandle as oC, ProviderWorkspaceCaptureResult as oS, QuestionDecision as o_, filterAuthoredAsserts as oa, TreeView as ob, ObserveOptions as oc, naiveContinuationPrompt as od, CoordinationRejectReason as of, Interval as og, KnowledgeItem as oh, pickBestGraph as oi, LeaderboardBenchmarkAdapter as ol, ToolLoopToolCall as om, Shell as on, resolveSandboxClient as oo, Inbox as op, RemoteSupervisorControl as or, defaultSelectWinner as os, AnalystFinding$1 as ot, ObserverRecordKind as ou, AnalystAssignmentRecord as ov, HeldForContinuation as ox, RootSegmentEntry as oy, KnowledgeReadinessDecision as p, RetainedInteractiveEnvironmentAdmission as pC, DefaultVerdict$2 as pS, QuestionRecord as p_, visibleCheckScore as pa, SupervisedResult as pb, CorpusFilter as pc, RootStreamRecord as pd, ContinuationEntry as pf, ScoreOf as pg, DelegationTraceSpan as ph, DispatchStopReason as pi, defineLeaderboard as pl, DetachedSessionDelegateOptions as pm, runInWorkspace as pn, createPrivateCasArtifactPort as po, SharedBoxPlacement as pp, ProvisionSupervisorConnection as pr, LocalMcpMaterialization as ps, ForkRequest as pt, GraphNode as pu, AuthoredAnalystDefinition as pv, SessionMessageLike as px, createPropagatingTraceEmitter as py, WorkerSpawnContext as q, RuntimeRunStatus as qS, JsonRpcResponse as q_, PrivateCasNamespaceInventory as qa, MaterializedModelIdentity as qb, Persona as qc, DeliveredOutput as qd, CliSeam as qf, WorkerWatchOptions as qg, readCodexRolloutSession as qh, CheckSource as qi, PursuitNodeCost as ql, DelegationProgress as qm, WriteWorkerSteerOptions as qn, printBenchmarkReport as qo, SandboxServedBackend as qp, GraphRunRecord as qr, defineStrategy as qs, EVIDENCE_MAX_CHARS as qt, createFileRunContext as qu, cancelRun as qv, HARNESS_TRANSCRIPT_READ_LIMITS as qx, SpendChannel as qy, AgentBackendInput as r, NotFoundError as rC, ProviderWorkspaceAttemptProvenance as rS, ChildQuestionInbox as r_, composeCheckSources as ra, SpawnRejection as rb, ObservationAnalysis as rc, dumbContinuationPassPrompt as rd, CoordinationTransportOptions as rf, runCodeMode as rg, UiFindingScreenshot as rh, listGraphRuns as ri, DefinedLeaderboard as rl, ToolLoopCompaction as rm, copyUntrackedIntoClone as rn, recoverRetainedInteractiveRun as ro, SteerableSandboxSession as rp, writeWorkerSteer as rr, LocalSandboxClientOptions as rs, AgentSessionRef as rt, FileObserverJournal as ru, WatchTraceOptions as rv, ExecutorResult as rx, RecursiveReservationPolicy as ry, AgentRuntimeEventSink as s, NativeContextContinuationInput as sC, ProviderWorkspaceEntryMetadata as sS, QuestionEscalationOutcome as s_, modelAuthoredChecks as sa, FleetYield as sb, defaultAnalystInstruction as sc, promptHandle as sd, CoordinationDeliveryEvidence as sf, Leaderboard as sg, KnowledgeUpdate as sh, recordGraphRun as si, LeaderboardFlagSpec as sl, FeedbackEvent as sm, Workspace as sn, profileChatClient as so, InboxLease as sp, RemoteSupervisorReader as sr, inlineSandboxClient as ss, CheckpointRef as st, observerRecordDigest as su, AnalystFindingEvent as sv, HeldRelease as sx, RootSignal as sy, AgentAdapter as t, ConfigError as tC, resolveHarnessTranscriptCapture as tS, RouteMatch as t_, canDisplace as ta, SpawnOpts as tb, harvestCorpus as tc, delegatesWorkerBriefPrompt as td, CoordinationPublicAddress as tf, RunCodeModeOptions as tg, UiAuditorDelegationOutput as th, graphRegistry as ti, ProviderAsSandboxClientOptions as tl, ToolLoopCallContext as tm, CopyOptions as tn, claimRetainedInteractiveControl as to, SandboxSteeringOptions as tp, supervisorRunsRoot as tr, loopDispatch as ts, AgentProfile$2 as tt, PursuitStatus as tu, PublishOptions as tv, ExecutorCancellation as tx, TraceRootReceipt as ty, AgentTaskSpec as u, RecoverRetainedRunOptions as uC, TokenUsageProvenance as uS, QuestionLevel as u_, sandboxCheckRunner as ua, ProviderModelExecutionEvidence as ub, AssertTraceDerivedFindings as uc, SupervisorSpanOutcome as ud, PriorCoordination as uf, PairwiseOptions as ug, ResearchTask as uh, taskShapeDigest as ui, LeaderboardScenario as ul, CoderReview as um, gitWorkspace as un, PrivateCasDurableStore as uo, DEFAULT_SHARED_BOX_RESOURCES as up, RemoteWorkerEvents as ur, InProcessSandboxClientOptions as us, CreateSandboxOptions$1 as ut, EdgeTraversal as uu, AnalystRegistry$1 as uv, WorkerInteractiveUnavailableReason as ux, SupervisorOpts as uy, RunAgentTaskStreamOptions as v, RetainedRunCancelOptions as vC, LoopEndedPayload as vS, ContinuationInstruction as v_, StreamAgentTurnOptions as va, Scope as vb, FanoutOptions as vc, CoordinationToolFace as vd, ContinuationProfile as vf, renderLeaderboardSvg as vg, FileDelegationStoreOptions as vh, rollingDispatch as vi, checkProgramDigest as vl, FleetHandle as vm, DEFAULT_MAX_DEPTH as vn, FileCorpus as vo, ROUTER_CLIENT_HEADER as vp, ProfileRegistryDir as vr, StdioMcpServerSpec as vs, WorkspaceRequest as vt, TraversalContinuity as vu, RunLocalHarnessOptions as vv, ActivityNote as vx, OtelExporter as vy, RuntimeFailureCode as w, RetainedRunHandle as wC, LoopPlanPayload as wS, WorkerResumeContext as w_, StrategyEvolutionConfig as wa, BudgetPool as wb, PanelJudge as wc, ResolveSupervisorTools as wd, DriverRetryPolicy as wf, areaUnderCurve as wg, DeliverableSpec as wh, defaultDelegateBudget as wi, IsolatedCheckBoxEvidence as wl, RunDetachedTurnOptions as wm, SqlRunContextOptions as wn, panel as wo, resolveAgentEnvironmentProvider as wp, profileRunsForName as wr, AgenticTask as ws, HarvestSurfaceDiffsOptions as wt, GraphRouteError as wu, SqlRunOwnershipError as wv, createActivityLog as wx, RuntimeStreamEventCollector as wy, RuntimeSessionStore as x, RetainedRunEffect as xC, LoopIterationStartedPayload as xS, DownMessageDeliveryAttempt as x_, EvolutionAuthor as xa, WorkerEventCursor as xb, LoopUntilSpec as xc, DriveHarnessOwnerContext as xd, admitContinuationPolicy as xf, AnytimeStrategySummary as xg, CheckUnavailableError as xh, GraphDesignerExtraTools as xi, declaredCheckJudge as xl, createFleetWorkspaceExecutor as xm, ValidateStoredGraphOptions as xn, fanout as xo, AgentEnvironmentProviderRef as xp, loadProfile as xr, AgenticOptions as xs, VerifierEnvironmentOptions as xt, GraphCommandCheck as xu, LocalHarness as xv, ScopeProgressInput as xx, createOtelExporter as xy, RuntimeCanonicalStreamEvent as y, RetainedRunCancellation as yC, LoopIterationDispatchPayload as yS, ContinuityMode as y_, collectAgentTurn as ya, UnconfirmedTeardown as yb, FanoutSynthesis as yc, CoordinationVerbs as yd, PanelFinding as yf, renderPairwiseMarkdown as yg, CoderOutput as yh, DesignerRunGraphEnv as yi, declaredCheckDeliverable as yl, FleetWorkspaceExecutorOptions as ym, createSupervisor as yn, InMemoryCorpus as yo, sharedBoxRefusal as yp, ProfileRunRecord as yr, connectStdioMcp as ys, computeFindingId$1 as yt, runGraph as yu, runLocalHarness as yv, DEFAULT_STALL_AFTER_MS as yx, OtelSpan as yy, MakeWorkerAgent as z, ValidationCtx as zS, PeerMailbox as z_, SandboxLineageHandle as za, ExecutorRegistry as zb, WidenDecision as zc, allWorkersStalled as zd, DelegateError as zf, GitRunner as zg, CodexRolloutSession as zh, defaultProfileRichnessThresholds as zi, SupervisePursuitError as zl, DelegateResearchConfig as zm, TRACE_SUMMARY_SCHEMA as zn, sanitizeMcpToolSchema as zo, resolveSecretEnv as zp, GraphFileSeat as zr, ShotSpec as zs, WorktreeCliExecutorOptions as zt, SeatSelectionInput as zu, SpawnJournalReadRecord as zv, HarnessTranscriptUnavailable as zx, RunParkingRecord as zy };
+//# sourceMappingURL=types-niKnm6ux.d.ts.map