@tangle-network/agent-runtime 0.300.0 → 0.306.1

package/dist/{types-C73caP0U.d.ts → types-DeuEkBhI.d.ts}

@@ -1,5 +1,5 @@
 import { l as RuntimeHooks } from "./runtime-hooks-Bj6wJHlH.js";
-import { c as AgentCandidateArtifactPort, t as AgentCandidateWorkspaceArchiveLimits } from "./workspace-archive-pz8YJ1fr.js";
+import { g as AgentCandidateArtifactPort, l as AgentCandidateWorkspaceArchiveLimits, n as AgentCandidateWorkspaceTree } from "./workspace-streams-CpSmt3zx.js";
 import { AgentCandidateArtifactRef, AgentCandidateWorkspaceSnapshotEvidence, AgentExactRunControlRef, AgentInteractiveSession, AgentInteractiveSessionPromptAcknowledgement, AgentInteractiveSessionPromptCommand, AgentInteractiveSessionRef, AgentInteractiveSessionStart, AgentInteractiveSessionStatus, AgentNativeContextContinuationOptions, AgentNativeContextContinuationResult, AgentProfile, AgentSessionStatus, AgentTurnResult, ChildTaskEvent, ContextTransferRequest, HarnessType, InputPart, InteractionAcknowledgement, InteractionRequest, InteractionResponseCommand, NativeContextBoundaryProof, NativeContextContinuationRequest, NativeContextContinuationTurn, RequestedInteractions, RuntimeEventEnvelope, Sha256Digest, StreamEvent, WorkspaceCheckpointRef, WorkspaceCheckpointRequest } from "@tangle-network/agent-interface";
 import { AgentEvalError, AgentEvalError as AgentEvalError$1, AgentEvalErrorCode, ConfigError, ControlBudget, ControlDecision, ControlEvalResult, ControlRunResult, ControlStep, DataAcquisitionPlan, DefaultVerdict, DefaultVerdict as DefaultVerdict$1, JudgeError, KnowledgeReadinessReport, KnowledgeRequirement, NotFoundError, RunRecord, ToolSpan, TraceAnalysisStore, TraceStore, UserQuestion, ValidationError } from "@tangle-network/agent-eval";
 import { AgentRunOutcome } from "@tangle-network/sandbox/runtime";
@@ -991,21 +991,6 @@ interface LoopResult<Task, Output, Decision> {
 interface SandboxClient {
   create(options?: CreateSandboxOptions, requestOptions?: CreateRequestOptions): Promise<SandboxInstance>;
   describePlacement?(box: SandboxInstance): LoopSandboxPlacement;
-  /**
-   * Optional legacy CRIU capability probe. When present and it resolves
-   * `{ available: true }`, the loop's `lineage.fork` seam may checkpoint and fork
-   * a parent box when live `branch(count)` is unavailable. Current Sandbox boxes
-   * expose live branching directly. The kernel reads this ONLY through the
-   * capability probe — it never branches on backend kind.
-   * The raw `Sandbox` SDK class satisfies it; the loop's test fakes omit it
-   * (⇒ `canFork = false`).
-   * @experimental
-   */
-  criuStatus?(): Promise<{
-    available: boolean;
-    criuVersion?: string;
-    reason?: string;
-  }>;
 }
 /**
  * Opt-in box-lineage controls for `runAgentRounds`. Default OFF — with both flags
@@ -1791,20 +1776,24 @@ interface RecoverRetainedRunOptions {
   readonly now?: () => number;
 }
 /**
- * Outcome of one recovery attempt from pre-dispatch admission coordinates.
+ * Outcome of one recovery attempt.
  *
- * `not_found`: the provider no longer holds the environment; nothing remains
- * to destroy. `recovered`: the provider self-identified the session with a
- * strict exact reference matching the recorded coordinates. `unverifiable`:
- * the environment exists but the provider cannot self-identify the session;
- * never destroy on this outcome — keep the environment, retry
- * `reconnectRetainedRun` with a dispatched admission record, or inspect it
- * with provider-native tools.
+ * `recovered` with `via: 'reattached'`: the provider self-identified the
+ * original session with a strict exact reference matching the recorded
+ * environment coordinates. `recovered` with `via: 'resumed'`: a pre-create
+ * intent was replayed through the exact, idempotent create and dispatch; the
+ * handle controls the admitted run, whether this call or the crashed one
+ * dispatched it. `not_found`: the provider no longer holds the environment;
+ * nothing remains to destroy. `unverifiable`: the environment exists but the
+ * provider cannot self-identify the session. Never destroy on this outcome:
+ * keep the environment, retry `reconnectRetainedRun` with a dispatched
+ * admission record, or inspect it with provider-native tools.
  *
  * @stable
  */
 type RecoverRetainedRunResult = {
   readonly outcome: 'recovered';
+  readonly via: 'reattached' | 'resumed';
   readonly handle: RetainedRunHandle;
 } | {
   readonly outcome: 'not_found';
@@ -2273,11 +2262,6 @@ interface ContinuationNoteInput {
   /** Whether the check's score comes from cases the director cannot see. */
   readonly sealed?: boolean;
 }
-/**
- * Write one continuation note, sections 1 to 8 of docs/38. Section 9, the run's state, is
- * `composeReentryTask`, which wraps this text. Pure: the same input writes the same note.
- */
-declare function composeContinuationNote(input: ContinuationNoteInput): string;
 /** One continuation as the settle record carries it (`DriverContinuationRecord.continuations`). */
 interface ContinuationEntry {
   /** 1-based. */
@@ -2314,9 +2298,6 @@ interface VerdictSummary {
   readonly failed?: number;
   readonly total?: number;
 }
-/** A run directory's continuation files: the root's at `<runDir>/continuations/<n>/`, a nested
- *  manager's at `<runDir>/continuations/managers/<owner>/<n>/`. */
-declare const CONTINUATIONS_DIR = "continuations";
 /** The readout a continuation is composed from. */
 interface ContinuationContext {
   /** The attempt that just completed, 1-based. */
@@ -2403,6 +2384,9 @@ interface DriverAttemptRecord {
   readonly contract?: DriverContractState;
   /** True when this COMPLETED attempt's unmet contract sent the loop back with a continuation. */
   readonly reprompted?: boolean;
+  /** For a completed attempt that left work open: how long the manager then waited, with no
+   *  model turn, before the wake that started the next attempt. */
+  readonly waitedMs?: number;
   /** Why an unmet contract did NOT re-enter the session. Absent when the contract was met, when
    *  the manager has no continuation policy, or when the continuation was sent. */
   readonly repromptRefusedBy?: DriverRepromptRefusal;
@@ -2453,6 +2437,14 @@ type DriverReentry = {
   readonly failure: string;
   /** 1-based: which failure retry this is. */
   readonly retry: number;
+} | {
+  /** The previous turn ended with work open, and Runtime woke the manager when something
+   *  happened. Not a continuation: the manager chose to wait, and `input` is what it waited for. */
+  readonly reason: 'wake';
+  /** The wake input: every event since the last turn, or the heartbeat or deadline notice. */
+  readonly input: string;
+  /** 1-based: which wake this is. */
+  readonly wake: number;
 } | {
   /** The upstream refused the previous drive for capacity, or the check could not run, and the
    *  loop paused before this one. Re-entered like a failure, with the original task and the
@@ -2523,6 +2515,10 @@ interface DriverLoopRecord {
   readonly unavailableMs: number;
   /** Re-entered drives, in a row at the end, that completed without a delivery. */
   readonly barrenReentries: number;
+  /** Turns started by a wake: the manager ended its turn with work open and Runtime resumed it. */
+  readonly wakes: number;
+  /** Time the manager waited between turns with no model turn, summed over its wakes. */
+  readonly waitedMs: number;
   /** Why the loop ended: its last record's stop, or `unrecorded` when it ended without one (an
    *  admission refusal before the first attempt, or a throw from outside the loop). */
   readonly ended: DriverAttemptStop | 'unrecorded';
@@ -2587,6 +2583,23 @@ interface ProviderWorkspaceRetentionPort {
    * 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>;
   /** 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. */
@@ -2734,6 +2747,20 @@ interface ProviderWorkspaceRetentionContext {
   /** 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;
@@ -3280,149 +3307,6 @@ declare function sandboxSessionTraceSource(box: SessionTraceBox, sessionId: stri
   now?: () => number;
 }): TraceSource;
 //#endregion
-//#region src/runtime/supervise/wait.d.ts
-/**
- *
- * WAIT-STATES — a supervision-tree node that waits on wall-clock time or an external condition
- * without holding a worker, an executor, a sandbox, or a single LLM turn.
- *
- * A long-horizon run spends most of its wall-clock NOT computing: waiting for CI to finish,
- * for a nightly job to land, for a human to reply, for a rate-limit window to reopen. Before
- * this, the only way to express that was to keep something alive and re-ask — which spends
- * driver tokens per re-ask and pins a process to the wait.
- *
- * Two node kinds, both first-class:
- *   - `timer` — wake at an ABSOLUTE wall-clock instant (`untilMs`).
- *   - `poll`  — re-run a named predicate every `intervalMs` until it returns true, or until an
- *               absolute `timeoutAtMs` passes (CI status, file existence, an HTTP probe, an
- *               inbox message).
- *
- * ── How this differs from `await_event`'s 45s poll fence (`DEFAULT_AWAIT_EVENT_TIMEOUT_MS`) ──
- *
- * They look similar and are not the same mechanism. `await_event` is an IN-RUN RENDEZVOUS: the
- * driver blocks on the coordination bus for the next event from a live worker, and the 45s fence
- * exists only so a remote MCP request does not exceed the client's timeout — the caller re-polls.
- * Every re-poll is another driver inference turn (real tokens) against a process that must stay
- * up, and nothing about that wait is recorded: kill the process and the wait is simply gone.
- *
- * A wait-state is a NODE, not a call. It has a node id in the tree, a journal record carrying its
- * ABSOLUTE deadline, and it settles through the same `Scope.next()` cursor as any worker. Nobody
- * is blocked on it — the driver can stop reasoning entirely, and the process can die. Cost while
- * waiting: zero LLM calls, zero executor, zero sandbox, zero conserved budget (a wait reserves
- * nothing from the pool). The only in-process residue is one timer entry.
- *
- * ── Why probes are NAMED, not passed as closures ────────────────────────────────────────────
- *
- * A wait must survive a process restart with its original deadline intact, and a closure cannot
- * be journaled. So a `poll` names its predicate (`probe: 'ci-green'`) and the run resolves it
- * through a `WaitProbeRegistry`. A brand-new process re-resolves the SAME name against its own
- * registry and re-arms the wait — which is what makes "kill the box, the wait keeps waiting"
- * true rather than aspirational.
- *
- * Absolute instants for the same reason: `untilMs` / `timeoutAtMs` are epoch ms, not durations,
- * so a resumed wait counts down from the original arm, not from the restart. `timerAt`/`pollFor`
- * build them from a duration when that is what the caller has.
- *
- * @experimental
- */
-/** What a wait node is waiting for. Both variants carry ABSOLUTE epoch-ms instants so a wait
- *  re-armed by a later process keeps the deadline the first process set. */
-type WaitSpec = {
-  readonly kind: 'timer';
-  /** Absolute epoch ms to wake at. A past instant fires immediately. */
-  readonly untilMs: number;
-} | {
-  /** A graph-engine suspension: the host holds the content-addressed token and wakes it via
-   *  `resume`/`expire`; the engine owns the transition table (agent-runtime#976). */
-  readonly kind: 'token';
-  readonly token: string;
-  /** Absent ⇒ `onExpire: 'wait'` (never expires). */
-  readonly expiresAtMs?: number;
-  readonly onExpire: 'wait' | 'fail' | 'default';
-  /** `onExpire: 'default'`: the pre-admitted payload the expiry resolves with. */
-  readonly defaultRef?: string;
-} | {
-  readonly kind: 'poll';
-  /** Name of the predicate in the run's `WaitProbeRegistry`. Named (not a closure) so a
-   *  resumed process can re-resolve it — see the module header. */
-  readonly probe: string;
-  /** How often to re-run the predicate, in ms. Must be > 0. */
-  readonly intervalMs: number;
-  /** Absolute epoch ms after which an unfired poll settles `timeout`. Omit = no timeout
-   *  (then the run's own deadline is the only bound, and a run WITH a deadline refuses an
-   *  unbounded poll — see `assertWaitWithinDeadline`). */
-  readonly timeoutAtMs?: number;
-  /** Opaque JSON handed to the probe on every check. Journaled with the spec, so a resumed
-   *  probe gets the same arguments. */
-  readonly args?: Record<string, unknown>;
-};
-/** Build a `timer` spec from a DURATION. The instant is resolved once, at arm time — a resumed
- *  wait re-uses the journaled instant, never a fresh `now + ms`. */
-declare function timerAt(ms: number, now: number): WaitSpec;
-/** Build a bounded `poll` spec from a duration. */
-declare function pollFor(probe: string, opts: {
-  readonly intervalMs: number;
-  readonly timeoutMs?: number;
-  readonly args?: Record<string, unknown>;
-}, now: number): WaitSpec;
-/**
- * A named predicate a `poll` node re-checks. Returns true when the condition it watches has
- * flipped. A throw is treated as "not yet" (an unreachable CI endpoint is not a settled answer),
- * and is counted in the outcome's `probeErrors` so a probe that never works is visible rather
- * than silently polling forever.
- */
-type WaitProbe = (args: Record<string, unknown> | undefined, signal: AbortSignal) => boolean | Promise<boolean>;
-/** Resolves a `poll` spec's `probe` name to its predicate. Threaded through `SupervisorOpts` so
- *  the SAME registry a fresh run used is what a resumed run re-resolves against. */
-interface WaitProbeRegistry {
-  resolve(name: string): WaitProbe | undefined;
-}
-/** Registry over a plain name→predicate record. */
-declare function createWaitProbes(entries: Record<string, WaitProbe>): WaitProbeRegistry;
-/** The `out` a settled wait node delivers through `Scope.next()`. `settled` is the outcome the
- *  caller branches on: `'fired'` = the timer reached its instant or the predicate flipped;
- *  `'timeout'` = a bounded poll gave up. A timeout is a first-class ANSWER, not a failure — a
- *  wait only settles `down` when it is cancelled or aborted. */
-interface WaitOutcome {
-  /** Tag for `isWaitOutcome` — a wait outcome arrives on the same cursor as worker outputs. */
-  readonly waitOutcome: true;
-  readonly kind: WaitSpec['kind'];
-  readonly settled: 'fired' | 'timeout';
-  readonly label: string;
-  /** The absolute instant this wait was armed for (timer `untilMs` / poll `timeoutAtMs`); absent
-   *  for an unbounded poll. */
-  readonly untilMs?: number;
-  /** Epoch ms the wait was FIRST armed — preserved across a resume, so `wokenAt - armedAt` is
-   *  the true end-to-end wait even when it spanned several processes. */
-  readonly armedAt: number;
-  readonly wokenAt: number;
-  /** Predicate checks performed in the process that settled it (a resume restarts this count). */
-  readonly polls: number;
-  /** Probe checks that threw (counted, not fatal). */
-  readonly probeErrors: number;
-  /** True when a later process re-armed this wait from the journal instead of creating it. */
-  readonly resumed: boolean;
-}
-/** Narrow a settlement's `out` to a wait outcome — a wait settles on the SAME cursor as workers,
- *  so a driver that mixes them tags them apart with this. */
-declare function isWaitOutcome(value: unknown): value is WaitOutcome;
-/** A wait recorded in the journal that never woke — what a resumed run re-arms. */
-interface PendingWait {
-  readonly id: string;
-  readonly label: string;
-  readonly spec: WaitSpec;
-  /** The ORIGINAL arm instant. A re-armed wait keeps it, so its deadline never slides. */
-  readonly armedAt: number;
-  /** The wait ordinal in its parent scope, so a resumed scope continues past it. */
-  readonly ordinal: number;
-}
-/** Reject reasons for `Scope.wait`, mirroring `Scope.spawn`'s fail-closed admission shape. */
-type WaitRejection = 'invalid-spec' | 'unknown-probe' | 'deadline-exceeded';
-/** The absolute instant a spec is bounded by, or `undefined` for an unbounded wait. */
-declare function waitUntil(spec: WaitSpec): number | undefined;
-/** Structural validation, independent of the run. Returns null when the spec is usable. */
-declare function validateWaitSpec(spec: WaitSpec): string | null;
-//#endregion
 //#region src/sanitize.d.ts
 /** @stable */
 interface RuntimeTelemetryOptions {
@@ -3823,12 +3707,6 @@ declare function workerTraceEnv(ctx: WorkerTraceSeamCarrier): Record<string, str
 declare function workerTraceHeaders(ctx: WorkerTraceSeamCarrier): Record<string, string>;
 //#endregion
 //#region src/runtime/supervise/types.d.ts
-/** Options for `Scope.wait`. `label` is the wait's identity within its parent scope — it is what
- *  a resumed run matches to re-adopt a journaled, still-unfired wait, so it must be stable across
- *  processes (a label derived from wall-clock would resume as a NEW wait). */
-interface WaitOpts {
-  readonly label: string;
-}
 /**
  * One self-similar atom. A leaf is an `Agent` that never calls `scope.spawn`; a driver
  * is an `Agent` whose `act` spawns children and reacts to them via `scope.next()`. An
@@ -3859,6 +3737,13 @@ interface Agent<Task, Out> {
    */
   harnessTranscript?(): HarnessTranscriptCapture | undefined; /** Forwarded the same way: resolves once {@link harnessTranscript} is final (see `Executor`). */
   harnessTranscriptSettled?(): Promise<void>;
+  /**
+   * True once this agent's result is committed: its completion check accepted a submission and
+   * the coordination record holds it. `act` then resolves with that result once the turn that
+   * submitted it has ended, so an abort that arrives after acceptance waits for it, bounded,
+   * instead of discarding it (see `Executor.resultAccepted`).
+   */
+  resultAccepted?(): boolean;
 }
 /**
  * The leaf runtime — ONE open interface, not a closed union. `execute` returns a
@@ -4033,9 +3918,18 @@ interface Executor<Out> {
    * Never rejects. An executor whose transcript is final when `execute` ends omits it.
    */
   harnessTranscriptSettled?(): Promise<void>;
+  /**
+   * True once this execution's result is committed and `execute` will resolve with it: a
+   * manager whose completion check accepted its submission. The scope does not settle such a node
+   * `down` when its deadline or an abort arrives while the accepted turn is still ending; it waits
+   * for `execute` to resolve, and the executor bounds that wait itself. Measured on Discovery Lab
+   * run terraform-economics-20261005f: 5 of 20 nodes with accepted results were settled `down` by
+   * deadlines that fell while their turns were still ending.
+   */
+  resultAccepted?(): boolean;
 }
 /** Why Runtime cannot provide structured tool-call evidence for one settled execution. */
-type WorkerTraceUnavailableReason = 'execution-did-not-start' | 'executor-did-not-expose-trace-source' | 'trace-source-unavailable' | 'no-tool-spans-captured' | 'invalid-tool-spans' | 'trace-collection-failed' | 'trace-persistence-failed' | 'legacy-settlement-without-trace-evidence' | 'not-an-executor';
+type WorkerTraceUnavailableReason = 'execution-did-not-start' | 'executor-did-not-expose-trace-source' | 'trace-source-unavailable' | 'no-tool-spans-captured' | 'invalid-tool-spans' | 'trace-collection-failed' | 'trace-persistence-failed' | 'legacy-settlement-without-trace-evidence';
 /** Durable proof of a worker's structured tool trace, or the exact reason it is unavailable. */
 type WorkerTraceEvidence = {
   readonly status: 'available';
@@ -4050,7 +3944,7 @@ type WorkerTraceEvidence = {
 type WorkerInteractiveUnavailableReason =
 /** No child of this scope carries that node id. */
 'unknown-node' |
-/** The child settled, was cancelled, or is a wait-state node: there is no process to attach to. */
+/** The child settled or was cancelled: there is no process to attach to. */
 'not-live' |
 /** The worker runs headless. Its executor exposes no interactive session, so there is no
  *  terminal — a headless execution is never converted into an attachment. */
@@ -4612,11 +4506,8 @@ interface Spend {
 /** `'queued'` is an admitted child that holds its budget slice and waits for a worker slot
  *  (`workerSlots`); it runs nothing until the allocator grants one. `'acquiring'` is first-class
  *  (M1): a node spends real time + reaps an orphan box during sandbox acquire BEFORE it is
- *  `running`, so abort must be defined over it.
- *  `'waiting'` is first-class for the opposite reason: a wait-state node holds NO executor, NO
- *  box, and no conserved budget — it is neither in flight nor settled, so neither `inFlight` nor
- *  a terminal status describes it (see `Scope.wait`). */
-type NodeStatus = 'pending' | 'queued' | 'acquiring' | 'running' | 'waiting' | 'done' | 'failed' | 'cancelled';
+ *  `running`, so abort must be defined over it. */
+type NodeStatus = 'pending' | 'queued' | 'acquiring' | 'running' | 'done' | 'failed' | 'cancelled';
 /** Deterministic node id — `${parent}:s${seq}` from the cursor order, never wall-clock. */
 type NodeId = string;
 interface SpawnOpts {
@@ -4857,32 +4748,6 @@ interface Scope<Out> {
    * is a direct call; the sandbox/Agent-Bus transports surface the SAME verb as an MCP tool.
    */
   send(nodeId: NodeId, msg: unknown): boolean;
-  /**
-   * Arm a WAIT-STATE node: a first-class tree node that waits on wall-clock time (`timer`) or on
-   * a named external predicate (`poll`) and settles through THIS scope's `next()` cursor like any
-   * other child — but holds no executor, no sandbox, and no conserved budget. Waiting costs zero
-   * tokens and zero dollars by construction.
-   *
-   * It is journaled (`waiting` → `woken`) with its ABSOLUTE deadline, so a run that dies mid-wait
-   * resumes still waiting: the supervisor surfaces the un-woken waits on `Scope.resume.waits`, and
-   * re-arming the same `label` adopts the recorded node id and original instant instead of
-   * restarting the countdown.
-   *
-   * Fail-closed admission, mirroring `spawn`: `invalid-spec`, `unknown-probe` (a `poll` naming a
-   * predicate this run's registry cannot resolve), or `deadline-exceeded` (the wait would outlive
-   * the pool's hard wall-clock ceiling — a wait never extends a budget guard).
-   *
-   * NOT `await_event`: that is an in-run rendezvous on the coordination bus whose 45s fence makes
-   * the caller re-poll — each re-poll a driver inference turn against a process that must stay up,
-   * and nothing about it survives a restart. See `supervise/wait.ts`.
-   */
-  wait(spec: WaitSpec, opts: WaitOpts): {
-    ok: true;
-    handle: Handle<WaitOutcome>;
-  } | {
-    ok: false;
-    reason: WaitRejection;
-  };
   /**
    * The LIVE read-model of one child, valid WHILE it runs: last-activity timestamp, idle time,
    * a derived `stalled` flag, tokens/turns spent so far, whether a steer can even reach it
@@ -4994,13 +4859,6 @@ interface UnconfirmedTeardown {
 interface ResumedWork<Out> {
   readonly settled: ReadonlyArray<Settled<Out>>;
   readonly view: TreeView;
-  /**
-   * Wait-state nodes the journal shows as ARMED but never woken — the run died mid-wait. Each
-   * carries the ORIGINAL arm instant and absolute deadline, so re-arming the same `label` through
-   * `Scope.wait` resumes the countdown instead of restarting it. Empty on a fresh run and on a
-   * resumed run that was not waiting.
-   */
-  readonly waits: ReadonlyArray<PendingWait>;
   /**
    * Keyed assignments from the prior journal: `SpawnOpts.key` → what the journal proves about it.
    * `completed`/`down` carry the rehydrated settlement; `in-doubt` means the spawn was journaled
@@ -5058,7 +4916,7 @@ interface NodeSnapshot {
   readonly spent: Spend;
   /**
    * The node's executor has FINISHED and its settlement is queued for the manager to drain with
-   * `await_event`/`next()`, but `status` still reads as it did while running because the settle
+   * 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".
@@ -5093,10 +4951,6 @@ interface TreeView {
   readonly nodes: ReadonlyArray<NodeSnapshot>;
   /** Count of nodes in `queued`, `acquiring`, or `running` — the "what's in flow?" answer. */
   readonly inFlight: number;
-  /** Count of nodes in `waiting` — armed wait-states. Deliberately NOT folded into `inFlight`:
-   *  a wait burns no executor and no budget, so counting it as flow would misreport both idle
-   *  capacity and how much work is actually running. */
-  readonly waiting: number;
 }
 /** Journaled spawn-tree events (B1/B2). `seq` is the cursor order; `at` is an ISO
  *  timestamp for human inspection only (NOT a replay input). */
@@ -5300,33 +5154,6 @@ type SpawnEvent = {
   instance: string;
   seq: number;
   at: string;
-} | {
-  /** A wait-state node was ARMED. Lives in the SPAWN-ORDINAL namespace (`seq` is the wait
-   *  ordinal within its parent scope), exactly like `spawned` — it creates a node, it does not
-   *  settle one. It carries the whole `spec` and the original `armedAt` so a brand-new process
-   *  re-arms the identical wait with the identical ABSOLUTE deadline. */
-  kind: 'waiting';
-  id: NodeId;
-  parent?: NodeId;
-  label: string;
-  spec: WaitSpec;
-  armedAt: number;
-  seq: number;
-  at: string;
-} | {
-  /** A wait-state node SETTLED — the cursor-namespace twin of `settled`, kept distinct so a
-   *  reader can tell zero-cost waiting apart from paid work without inspecting payloads. A
-   *  wait carries no `spent` (it is free by construction, not by measurement); `outRef`
-   *  rehydrates its `WaitOutcome`, absent when the wait was cancelled. */
-  kind: 'woken';
-  id: NodeId;
-  /** `expired`: a graph suspension whose `onExpire: 'fail'` deadline passed — distinct from
-   *  `timeout` (a poll wait's own deadline), so a consumer can tell "the human never
-   *  answered" from "the probe never fired". */
-  by: 'fired' | 'timeout' | 'cancelled' | 'expired';
-  outRef?: string;
-  seq: number;
-  at: string;
 } | {
   /** A driver's OWN inference spend, journaled separately from spawned-child work — the journal
    *  TWIN of `BudgetPool.observe`, exactly as `settled` is the twin of `reconcile`. So every
@@ -5511,15 +5338,77 @@ type SpawnEvent = {
   marker?: WorkspaceCheckpointMarker;
   seq: number;
   at: string;
+} | {
+  /** Runtime is about to ask the provider for a fork of a checkpoint, to read its files. The
+   *  record comes first, so a fork that a crash left alive is found by this key and destroyed
+   *  at the owner's release. Informational, like `workspace-checkpoint`. */
+  kind: 'workspace-checkpoint-fork-requested';
+  id: NodeId;
+  provider: string;
+  /** The environment the checkpoint was taken from. */
+  environmentId: string;
+  checkpointId: string;
+  idempotencyKey: string;
+  requestDigest: Sha256Digest;
+  seq: number;
+  at: string;
+} | {
+  /** Whether the provider confirmed destroying a checkpoint capture's fork. A fork without a
+   *  `destroyed` record is asked for again at the owner's release. Informational, like
+   *  `workspace-checkpoint`. */
+  kind: 'workspace-checkpoint-fork-teardown';
+  id: NodeId;
+  provider: string;
+  /** The environment the checkpoint was taken from. */
+  environmentId: string;
+  checkpointId: string;
+  fork: {
+    idempotencyKey: string;
+    environmentId: string;
+  };
+  destroyed: boolean;
+  seq: number;
+  at: string;
+} | {
+  /** A checkpoint's files, read from a fork of it, stored in the run's content-addressed
+   *  store as a tree before the checkpoint may be deleted. `tree.digest` names the manifest;
+   *  every file it lists is an object of the same store. Informational, like
+   *  `workspace-checkpoint`. */
+  kind: 'workspace-checkpoint-capture';
+  id: NodeId;
+  provider: string;
+  /** The environment the checkpoint was taken from. */
+  environmentId: string;
+  checkpointId: string;
+  /** The fork the capture read, by its request key and environment; destroyed once this
+   *  record is written. */
+  fork: {
+    idempotencyKey: string;
+    environmentId: string;
+  };
+  tree: {
+    digest: Sha256Digest;
+    manifest: AgentCandidateArtifactRef;
+    files: number;
+    bytes: number;
+    storedBytes: number;
+  };
+  seq: number;
+  at: string;
 } | {
   /** Exact checkpoint cleanup outcome; unconfirmed resources remain pending across resume.
-   * Informational, like `workspace-checkpoint`. */
+   *  `capturedDigest` is the tree of the checkpoint's files that a `workspace-checkpoint-capture`
+   *  stored before the delete was asked for. `refused` says why the checkpoint was kept
+   *  without a delete: its files are in no capture, so deleting it would lose them.
+   *  Informational, like `workspace-checkpoint`. */
   kind: 'workspace-checkpoint-cleanup';
   id: NodeId;
   provider: string;
   environmentId: string;
   checkpointId: string;
   confirmed: boolean;
+  capturedDigest?: Sha256Digest;
+  refused?: string;
   seq: number;
   at: string;
 } | {
@@ -5539,6 +5428,27 @@ type SpawnEvent = {
   detail?: string;
   seq: number;
   at: string;
+} | {
+  /** One end-of-turn workspace capture of this node's environment and where its time went.
+   *  Captures queue on one port that every recursive environment shares, so `queuedMs` is
+   *  the wait behind other nodes' captures and `captureMs` the capture and its verification.
+   *  Informational, like `workspace-checkpoint`; `seq` counts this node's records. */
+  kind: 'workspace-capture';
+  id: NodeId;
+  /** The Runtime invocation the capture belongs to. */
+  executionId: string;
+  environmentId: string;
+  /** Captures holding or waiting for a slot when this one was requested. */
+  ahead: number;
+  queuedMs: number;
+  /** Absent when the capture never held a slot. */
+  captureMs?: number;
+  /** Bytes of the verified workspace archive. */
+  archiveBytes?: number;
+  outcome: 'captured' | 'failed';
+  error?: string;
+  seq: number;
+  at: string;
 } | {
   /** One GRAPH-EDGE traversal (`runGraph`): what the runtime actually DELIVERED across a
    *  delegates/analyzes edge, with byte counts — the observability that makes an edge's
@@ -5622,7 +5532,7 @@ type SpawnEvent = {
   at: string;
 };
 /**
- * The spawn-tree event source (mirrors `ConversationJournal`'s begin/append/load shape).
+ * The spawn-tree event source (begin/append/load).
  * `loadTree` returns events for inspection and completed-settlement replay, not live process
  * recovery; `appendEvent` runs only AFTER the event is observed-committed (never speculative).
  */
@@ -5674,10 +5584,6 @@ interface SupervisorOpts {
   readonly executors: ExecutorRegistry;
   /** Reconstruct configured executors for interrupted children before resuming the driver. */
   readonly recoverExecutor?: ExecutorFactory<unknown>;
-  /** Predicate resolution for `poll` wait-states (`Scope.wait`). A `poll` names its predicate so
-   *  the wait can be journaled and re-armed by a later process; this is what the name resolves
-   *  against. Unset ⇒ `poll` waits are refused (`unknown-probe`); `timer` waits are unaffected. */
-  readonly probes?: WaitProbeRegistry;
   /** Recursion ceiling (root = 0). The conserved pool bounds depth; this only stops a runaway
    *  recursion. Omit = `DEFAULT_MAX_DEPTH` (16). */
   readonly maxDepth?: number;
@@ -6167,5 +6073,5 @@ interface WidenGate<Out> {
   readonly judgeExempt?: boolean;
 }
 //#endregion
-export { SpawnJournal as $, AgentRuntimeEventSink as $a, LeakedReservation as $i, ReadableEnvironment as $n, checkVerdictOf as $r, RuntimeStreamEventCollector as $t, NodeExecutionIdentity as A, LoopWinner as Aa, RetainedInteractiveEnvironmentAdmission as Ai, RetainedPendingCause as An, classifyDriverFailure as Ar, TraceContext as At, ResultBlobStore as B, RuntimeRunCost as Ba, RetainedRunEventOptions as Bi, ReconnectRetainedInteractiveRunOptions as Bn, ContinuationAppend as Br, OtelSpan as Bt, ExecutorToolCall as C, LoopResult as Ca, NativeContextContinuationHandle as Ci, SessionTraceBox as Cn, DriverContractState as Cr, WorkspaceCheckpointMarker as Ct, MaterializedExecutionIdentity as D, LoopTokenUsage as Da, RecoverRetainedRunOptions as Di, decodeToolPart as Dn, DriverReentry as Dr, workerTraceEnv as Dt, HeldEnvironment as E, LoopTeardownFailedPayload as Ea, RecoverRetainedRunIntentOptions as Ei, createPushTraceSource as En, DriverProgressMark as Er, readWorkerTraceContext as Et, ProviderModelAttemptEvidence as F, SandboxClient as Fa, RetainedRunCancelOptions as Fi, ScopeProgressInput as Fn, CONTINUATIONS_DIR as Fr, LoopSpanNode as Ft, RootMaterialization as G, RuntimeRunStatus as Ga, RetainedRunStartMaterial as Gi, RetainedInteractiveStartMaterial as Gn, ContinuationPanelInput as Gr, createOpenInferenceFileExporter as Gt, ResumedWork as H, RuntimeRunOptions as Ha, RetainedRunIntentAdmission as Hi, RetainedInteractiveAdmissionHook as Hn, ContinuationEntry as Hr, buildLoopOtelSpans as Ht, ProviderModelExecutionEvidence as I, SelectionReceipt as Ia, RetainedRunCancellation as Ii, TeamProgress as In, CONTINUATION_FACTS as Ir, OtelAttribute as It, RootStreamReceipt as J, AgentBackendContext as Ja, StartRetainedRunOptions as Ji, HarnessTranscriptCapture as Jn, ContinuationProfile as Jr, loopEventToOtelSpan as Jt, RootProviderModelEvidence as K, startRuntimeRun as Ka, RetainedRunTurnInput as Ki, StartRetainedInteractiveRunOptions as Kn, ContinuationPanelResult as Kr, createOtelExporter as Kt, RecursiveReservationPolicy as L, ValidationCtx as La, RetainedRunDispatchedAdmission as Li, WorkerProgress as Ln, CheckRead as Lr, OtelExportConfig as Lt, NodeSnapshot as M, MountRecorder as Ma, RetainedInteractiveStartedAdmission as Mi, ActivityNote as Mn, upstreamUnavailableSignal as Mr, mergeTraceEnv as Mt, NodeStatus as N, OutputAdapter as Na, RetainedRunAdmission as Ni, DEFAULT_STALL_AFTER_MS as Nn, UnavailablePausePolicy as Nr, readTraceContextFromEnv as Nt, MaterializedModelIdentity as O, LoopTraceEmitter as Oa, RecoverRetainedRunResult as Oi, sandboxSessionTraceSource as On, DriverRepromptRefusal as Or, workerTraceHeaders as Ot, ProfileMaterializationReceipt as P, RunProvenance as Pa, RetainedRunAdmissionHook as Pi, ExecutorProgress as Pn, AdmittedFinding as Pr, traceContextToEnv as Pt, SpawnEvent as Q, AgentRuntimeEvent as Qa, BudgetReconcileFault as Qi, HarnessTranscriptUnavailableReason as Qn, admitFinding as Qr, RuntimeEventCollector as Qt, ResourceLimit as R, Validator as Ra, RetainedRunEffect as Ri, createActivityLog as Rn, CheckUnavailableError as Rr, OtelExportStats as Rt, ExecutorTeardownWarning as S, LoopPlanPayload as Sa, NativeContextContinuationExecution as Si, SessionMessageLike as Sn, DriverContinuationRecord as Sr, WorkerTraceUnavailableReason as St, Handle as T, LoopStartedPayload as Ta, ReconnectRetainedRunOptions as Ti, TraceSource as Tn, DriverLoopRecord as Tr, WorkerTraceSeamCarrier as Tt, RetainedExecutionState as U, RuntimeRunPersistenceAdapter as Ua, RetainedRunReplayPoint as Ui, RetainedInteractiveEnvironmentInput as Un, ContinuationNoteInput as Ur, buildLoopSpanNodes as Ut, ResumedKeyState as V, RuntimeRunHandle as Va, RetainedRunHandle as Vi, RecoverRetainedInteractiveRunOptions as Vn, ContinuationContext as Vr, RuntimeEventOtelOptions as Vt, RootHandle as W, RuntimeRunRow as Wa, RetainedRunSnapshot as Wi, RetainedInteractiveRunHandle as Wn, ContinuationPanel as Wr, buildRuntimeEventOtelSpans as Wt, Scope as X, AgentExecutionBackend as Xa, BudgetPoolRestore as Xi, HarnessTranscriptFile as Xn, VerdictSummary as Xr, padTraceId as Xt, Runtime as Y, AgentBackendInput as Ya, BudgetPool as Yi, HarnessTranscriptEvidence as Yn, PanelFinding as Yr, padSpanId as Yt, Settled as Z, AgentKnowledgeProvider as Za, BudgetReadout as Zi, HarnessTranscriptUnavailable as Zn, admitContinuationPolicy as Zr, toOtelAttributes as Zt, ExecutorMaterialization as _, LoopIterationDispatchPayload as _a, RuntimeRunStateError as _i, isWaitOutcome as _n, ProviderWorkspaceRetentionPort as _r, WaitOpts as _t, BudgetOverspend as a, ReservationTicket as aa, verdictFromJudgeScore as ai, createRuntimeEventCollector as an, KnowledgeReadinessDecision as ao, HarnessTranscriptReadOptions as ar, SpendGap as at, ExecutorRegistry as b, LoopLineageOptions as ba, WorkerSlots as bi, validateWaitSpec as bn, DriverAttemptsExhaustedError as br, WorkerInteractiveUnavailableReason as bt, EnvironmentTeardownReceipt as c, createBudgetPool as ca, BackendTransportError as ci, sanitizeKnowledgeReadinessReport as cn, OpenAIChatToolChoice as co, resolveHarnessTranscriptCapture as cr, SubtreeSummary as ct, ExecutorAccounting as d, DefaultVerdict$1 as da, NotFoundError as di, WaitOutcome as dn, RuntimeCanonicalStreamEvent as do, ProviderWorkspaceAttemptProvenance as dr, SupervisorOpts as dt, ReservationFloor as ea, composeContinuationNote as ei, RuntimeStreamEventSink as en, AgentTaskContext as eo, captureHarnessTranscript as er, SpawnOpts as et, ExecutorCancellation as f, Driver as fa, PlannerError as fi, WaitProbe as fn, RuntimeSession as fo, ProviderWorkspaceCaptureProvenance as fr, TokenUsageProvenance as ft, ExecutorFactory as g, LoopEndedPayload as ga, RetainedRunDispatchBindingError as gi, createWaitProbes as gn, ProviderWorkspaceRetentionContext as gr, UsageEvent as gt, ExecutorExecutionBinding as h, LoopDecisionPayload as ha, RetainedRunAdmissionError as hi, WaitSpec as hn, ProviderWorkspaceEntryMetadata as hr, UnknownMaterializationReason as ht, Budget as i, ReservationStage as ia, passedItems as ii, SanitizedKnowledgeRequirement as in, BackendErrorDetail as io, HarnessTranscriptReadLimits as ir, SpendChannel as it, NodeId as j, MountManifestEntry as ja, RetainedInteractiveIntentAdmission as ji, ActivityLog as jn, summarizeDriverAttempts as jr, createPropagatingTraceEmitter as jt, NoWinnerError as k, LoopTraceEvent as ka, RetainedInteractiveAdmission as ki, RetainedChildRecovery as kn, DriverRetryPolicy as kr, workerTraceSeamKey as kt, ExecutionBindingReceipt as l, spendFromUsageEvents as la, ConfigError as li, sanitizeRuntimeStreamEvent as ln, RunAgentTaskOptions as lo, retainHarnessTranscript as lr, SupervisedResult as lt, ExecutorContext as m, Iteration as ma, RetainedInteractiveBindingError as mi, WaitRejection as mn, RuntimeStreamEvent as mo, ProviderWorkspaceCaptureResult as mr, UnconfirmedTeardown as mt, AgentExecutionRef as n, ReservationRejection as na, expandQuestions as ni, RuntimeTelemetryOptions as nn, AgentTaskSpec as no, persistHarnessTranscript as nr, SpawnRejection as nt, BudgetViolation as o, ReservationWaitRefused as oa, AgentEvalError$1 as oi, createRuntimeStreamEventCollector as on, OpenAIChatResponseFormat as oo, RetainedHarnessTranscriptCapture as or, SteerableRootHandle as ot, ExecutorCancellationRequest as p, ExecCtx as pa, RetainedInteractiveAdmissionError as pi, WaitProbeRegistry as pn, RuntimeSessionStore as po, ProviderWorkspaceCaptureReceipt as pr, TreeView as pt, RootSignal as q, AgentAdapter as qa, StartRetainedRunInEnvironmentOptions as qi, HarnessTranscriptArtifact as qn, ContinuationPolicy as qr, generateSpanId as qt, AgentSpec as r, ReservationShortfall as ra, failedItems as ri, SanitizedKnowledgeReadinessReport as rn, AgentTaskStatus as ro, HarnessTranscriptMetadata as rr, Spend as rt, DefaultVerdict as s, ReserveOptions as sa, AgentEvalErrorCode as si, sanitizeAgentRuntimeEvent as sn, OpenAIChatTool as so, RetainedHarnessTranscriptDescriptor as sr, SubtreeResult as st, Agent as t, ReservationHolder as ta, distillFindings as ti, RuntimeStreamEventSummary as tn, AgentTaskRunResult as to, harnessTranscriptArtifact as tr, SpawnPrior as tt, Executor as u, AgentRunSpec as ua, JudgeError as ui, PendingWait as un, RunAgentTaskStreamOptions as uo, ProviderNativeCapturePhase as ur, Supervisor as ut, ExecutorNodeContext as v, LoopIterationEndedPayload as va, ValidationError as vi, pollFor as vn, DriverAttemptRecord as vr, WidenGate as vt, FleetYield as w, LoopSandboxPlacement as wa, NativeContextContinuationInput as wi, ToolStepInput as wn, DriverFailureClass as wr, WorkerTraceResolver as wt, ExecutorResult as x, LoopPlanDescription as xa, createWorkerSlots as xi, waitUntil as xn, DriverBudgetReadout as xr, WorkerTraceEvidence as xt, ExecutorProgressEvent as y, LoopIterationStartedPayload as ya, SlotPermit as yi, timerAt as yn, DriverAttemptStop as yr, WorkerInteractiveSession as yt, ResourceSpend as z, RuntimeRunCompleteInput as za, RetainedRunEnvironmentAdmission as zi, readWorkerProgress as zn, CheckVerdict as zr, OtelExporter as zt };
-//# sourceMappingURL=types-C73caP0U.d.ts.map
+export { SpawnJournal as $, RuntimeSessionStore as $a, ExecCtx as $i, ProviderWorkspaceAttemptProvenance as $n, RetainedInteractiveAdmissionError as $r, RuntimeStreamEventSink as $t, NodeExecutionIdentity as A, RuntimeRunRow as Aa, RetainedRunSnapshot as Ai, RetainedInteractiveEnvironmentInput as An, ContinuationNoteInput as Ar, createPropagatingTraceEmitter as At, ResultBlobStore as B, AgentTaskContext as Ba, ReservationFloor as Bi, ReadableEnvironment as Bn, checkVerdictOf as Br, RuntimeEventOtelOptions as Bt, ExecutorToolCall as C, ValidationCtx as Ca, RetainedRunDispatchedAdmission as Ci, TeamProgress as Cn, CONTINUATION_FACTS as Cr, WorkerTraceResolver as Ct, MaterializedExecutionIdentity as D, RuntimeRunHandle as Da, RetainedRunHandle as Di, ReconnectRetainedInteractiveRunOptions as Dn, ContinuationAppend as Dr, workerTraceHeaders as Dt, HeldEnvironment as E, RuntimeRunCost as Ea, RetainedRunEventOptions as Ei, readWorkerProgress as En, CheckVerdict as Er, workerTraceEnv as Et, ProviderModelAttemptEvidence as F, AgentBackendInput as Fa, BudgetPool as Fi, HarnessTranscriptCapture as Fn, ContinuationProfile as Fr, OtelAttribute as Ft, RootMaterialization as G, KnowledgeReadinessDecision as Ga, ReservationTicket as Gi, HarnessTranscriptReadLimits as Gn, verdictFromJudgeScore as Gr, createOtelExporter as Gt, ResumedWork as H, AgentTaskSpec as Ha, ReservationRejection as Hi, harnessTranscriptArtifact as Hn, expandQuestions as Hr, buildLoopSpanNodes as Ht, ProviderModelExecutionEvidence as I, AgentExecutionBackend as Ia, BudgetPoolRestore as Ii, HarnessTranscriptEvidence as In, PanelFinding as Ir, OtelExportConfig as It, RootStreamReceipt as J, OpenAIChatToolChoice as Ja, createBudgetPool as Ji, RetainedHarnessTranscriptDescriptor as Jn, BackendTransportError as Jr, padSpanId as Jt, RootProviderModelEvidence as K, OpenAIChatResponseFormat as Ka, ReservationWaitRefused as Ki, HarnessTranscriptReadOptions as Kn, AgentEvalError$1 as Kr, generateSpanId as Kt, RecursiveReservationPolicy as L, AgentKnowledgeProvider as La, BudgetReadout as Li, HarnessTranscriptFile as Ln, VerdictSummary as Lr, OtelExportStats as Lt, NodeSnapshot as M, startRuntimeRun as Ma, RetainedRunTurnInput as Mi, RetainedInteractiveStartMaterial as Mn, ContinuationPanelInput as Mr, readTraceContextFromEnv as Mt, NodeStatus as N, AgentAdapter as Na, StartRetainedRunInEnvironmentOptions as Ni, StartRetainedInteractiveRunOptions as Nn, ContinuationPanelResult as Nr, traceContextToEnv as Nt, MaterializedModelIdentity as O, RuntimeRunOptions as Oa, RetainedRunIntentAdmission as Oi, RecoverRetainedInteractiveRunOptions as On, ContinuationContext as Or, workerTraceSeamKey as Ot, ProfileMaterializationReceipt as P, AgentBackendContext as Pa, StartRetainedRunOptions as Pi, HarnessTranscriptArtifact as Pn, ContinuationPolicy as Pr, LoopSpanNode as Pt, SpawnEvent as Q, RuntimeSession as Qa, Driver as Qi, ProviderNativeCapturePhase as Qn, PlannerError as Qr, RuntimeStreamEventCollector as Qt, ResourceLimit as R, AgentRuntimeEvent as Ra, BudgetReconcileFault as Ri, HarnessTranscriptUnavailable as Rn, admitContinuationPolicy as Rr, OtelExporter as Rt, ExecutorTeardownWarning as S, SelectionReceipt as Sa, RetainedRunCancellation as Si, ScopeProgressInput as Sn, AdmittedFinding as Sr, WorkspaceCheckpointMarker as St, Handle as T, RuntimeRunCompleteInput as Ta, RetainedRunEnvironmentAdmission as Ti, createActivityLog as Tn, CheckUnavailableError as Tr, readWorkerTraceContext as Tt, RetainedExecutionState as U, AgentTaskStatus as Ua, ReservationShortfall as Ui, persistHarnessTranscript as Un, failedItems as Ur, buildRuntimeEventOtelSpans as Ut, ResumedKeyState as V, AgentTaskRunResult as Va, ReservationHolder as Vi, captureHarnessTranscript as Vn, distillFindings as Vr, buildLoopOtelSpans as Vt, RootHandle as W, BackendErrorDetail as Wa, ReservationStage as Wi, HarnessTranscriptMetadata as Wn, passedItems as Wr, createOpenInferenceFileExporter as Wt, Scope as X, RunAgentTaskStreamOptions as Xa, AgentRunSpec as Xi, retainHarnessTranscript as Xn, JudgeError as Xr, toOtelAttributes as Xt, Runtime as Y, RunAgentTaskOptions as Ya, spendFromUsageEvents as Yi, resolveHarnessTranscriptCapture as Yn, ConfigError as Yr, padTraceId as Yt, Settled as Z, RuntimeCanonicalStreamEvent as Za, DefaultVerdict$1 as Zi, ProviderCheckpointCaptureContext as Zn, NotFoundError as Zr, RuntimeEventCollector as Zt, ExecutorMaterialization as _, MountManifestEntry as _a, RetainedInteractiveIntentAdmission as _i, RetainedPendingCause as _n, DriverRetryPolicy as _r, WidenGate as _t, BudgetOverspend as a, LoopIterationStartedPayload as aa, SlotPermit as ai, createRuntimeStreamEventCollector as an, ProviderWorkspaceRetentionPort as ar, SpendGap as at, ExecutorRegistry as b, RunProvenance as ba, RetainedRunAdmissionHook as bi, DEFAULT_STALL_AFTER_MS as bn, upstreamUnavailableSignal as br, WorkerTraceEvidence as bt, EnvironmentTeardownReceipt as c, LoopPlanPayload as ca, NativeContextContinuationExecution as ci, sanitizeRuntimeStreamEvent as cn, DriverAttemptsExhaustedError as cr, SubtreeSummary as ct, ExecutorAccounting as d, LoopStartedPayload as da, ReconnectRetainedRunOptions as di, ToolStepInput as dn, DriverContractState as dr, SupervisorOpts as dt, Iteration as ea, RetainedInteractiveBindingError as ei, RuntimeStreamEventSummary as en, RuntimeStreamEvent as eo, ProviderWorkspaceCaptureProvenance as er, SpawnOpts as et, ExecutorCancellation as f, LoopTeardownFailedPayload as fa, RecoverRetainedRunIntentOptions as fi, TraceSource as fn, DriverFailureClass as fr, TokenUsageProvenance as ft, ExecutorFactory as g, LoopWinner as ga, RetainedInteractiveEnvironmentAdmission as gi, RetainedChildRecovery as gn, DriverRepromptRefusal as gr, UsageEvent as gt, ExecutorExecutionBinding as h, LoopTraceEvent as ha, RetainedInteractiveAdmission as hi, sandboxSessionTraceSource as hn, DriverReentry as hr, UnknownMaterializationReason as ht, Budget as i, LoopIterationEndedPayload as ia, ValidationError as ii, createRuntimeEventCollector as in, ProviderWorkspaceRetentionContext as ir, SpendChannel as it, NodeId as j, RuntimeRunStatus as ja, RetainedRunStartMaterial as ji, RetainedInteractiveRunHandle as jn, ContinuationPanel as jr, mergeTraceEnv as jt, NoWinnerError as k, RuntimeRunPersistenceAdapter as ka, RetainedRunReplayPoint as ki, RetainedInteractiveAdmissionHook as kn, ContinuationEntry as kr, TraceContext as kt, ExecutionBindingReceipt as l, LoopResult as la, NativeContextContinuationHandle as li, SessionMessageLike as ln, DriverBudgetReadout as lr, SupervisedResult as lt, ExecutorContext as m, LoopTraceEmitter as ma, RecoverRetainedRunResult as mi, decodeToolPart as mn, DriverProgressMark as mr, UnconfirmedTeardown as mt, AgentExecutionRef as n, LoopEndedPayload as na, RetainedRunDispatchBindingError as ni, SanitizedKnowledgeReadinessReport as nn, ProviderWorkspaceCaptureResult as nr, SpawnRejection as nt, BudgetViolation as o, LoopLineageOptions as oa, WorkerSlots as oi, sanitizeAgentRuntimeEvent as on, DriverAttemptRecord as or, SteerableRootHandle as ot, ExecutorCancellationRequest as p, LoopTokenUsage as pa, RecoverRetainedRunOptions as pi, createPushTraceSource as pn, DriverLoopRecord as pr, TreeView as pt, RootSignal as q, OpenAIChatTool as qa, ReserveOptions as qi, RetainedHarnessTranscriptCapture as qn, AgentEvalErrorCode as qr, loopEventToOtelSpan as qt, AgentSpec as r, LoopIterationDispatchPayload as ra, RuntimeRunStateError as ri, SanitizedKnowledgeRequirement as rn, ProviderWorkspaceEntryMetadata as rr, Spend as rt, DefaultVerdict as s, LoopPlanDescription as sa, createWorkerSlots as si, sanitizeKnowledgeReadinessReport as sn, DriverAttemptStop as sr, SubtreeResult as st, Agent as t, LoopDecisionPayload as ta, RetainedRunAdmissionError as ti, RuntimeTelemetryOptions as tn, ProviderWorkspaceCaptureReceipt as tr, SpawnPrior as tt, Executor as u, LoopSandboxPlacement as ua, NativeContextContinuationInput as ui, SessionTraceBox as un, DriverContinuationRecord as ur, Supervisor as ut, ExecutorNodeContext as v, MountRecorder as va, RetainedInteractiveStartedAdmission as vi, ActivityLog as vn, classifyDriverFailure as vr, WorkerInteractiveSession as vt, FleetYield as w, Validator as wa, RetainedRunEffect as wi, WorkerProgress as wn, CheckRead as wr, WorkerTraceSeamCarrier as wt, ExecutorResult as x, SandboxClient as xa, RetainedRunCancelOptions as xi, ExecutorProgress as xn, UnavailablePausePolicy as xr, WorkerTraceUnavailableReason as xt, ExecutorProgressEvent as y, OutputAdapter as ya, RetainedRunAdmission as yi, ActivityNote as yn, summarizeDriverAttempts as yr, WorkerInteractiveUnavailableReason as yt, ResourceSpend as z, AgentRuntimeEventSink as za, LeakedReservation as zi, HarnessTranscriptUnavailableReason as zn, admitFinding as zr, OtelSpan as zt };
+//# sourceMappingURL=types-DeuEkBhI.d.ts.map