@tangle-network/agent-runtime 0.264.0 → 0.271.0

package/dist/{types-BV14WTyW.d.ts → types-Bo7z5aG5.d.ts}

@@ -1403,6 +1403,30 @@ type BudgetReadout = Readonly<{
   deadlineMs: number;
   reservedTokens: number;
 }>;
+/** The part of each channel a reservation must leave free: a manager's own share of its slice,
+ *  which its children may not reserve. */
+interface ReservationFloor {
+  readonly tokens: number;
+  readonly iterations: number;
+  readonly usd?: number;
+}
+/** 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. */
+  readonly wait?: boolean;
+  /** Leave this much of each channel free after the reservation. */
+  readonly keep?: ReservationFloor;
+}
+/**
+ * A waiting reservation that can never be granted: every open reservation settled and the free
+ * balance still cannot cover it. `shortfalls` are the channels that did not fit at that moment.
+ */
+declare class ReservationWaitRefused extends Error {
+  readonly reason: "budget-exhausted";
+  readonly shortfalls: readonly ReservationShortfall[];
+  constructor(shortfalls: readonly ReservationShortfall[]);
+}
 /** Why a reservation was refused. `budget-exhausted` means the pool ran out of a channel it
  * budgets; `usd-unbudgeted` means the root declared no dollar ceiling, so a dollar request is
  * unsatisfiable at any amount and the fix is to budget the root, not to ask for less. */
@@ -1420,6 +1444,9 @@ 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. */
+  readonly held?: number;
   readonly closedByUnknownSpend?: true;
 }
 /** State recovered from a prior process before new work is admitted. `committed` is measured spend
@@ -1435,10 +1462,17 @@ 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 — the
    * caller inspects `ok` before `ticket`.
+   *
+   * With `wait`, a request the free balance cannot cover now, but could once the open reservations
+   * return, is admitted as a WAITING ticket: `granted` resolves when the pool reserves it, and
+   * rejects with {@link ReservationWaitRefused} once nothing open could return enough. A waiting
+   * ticket reserves nothing; reconciling it withdraws it. While any ticket waits, a new waiting
+   * request queues behind it even when it would fit, so the order of asking is the order of grant.
    */
-  reserve(b: Budget, holder?: ReservationHolder): {
+  reserve(b: Budget, holder?: ReservationHolder, options?: ReserveOptions): {
     ok: true;
     ticket: ReservationTicket;
+    granted?: Promise<void>;
   } | {
     ok: false;
     reason: ReservationRejection;
@@ -1770,6 +1804,55 @@ type RecoverRetainedRunResult = {
   readonly environment: AgentEnvironment;
 };
 //#endregion
+//#region src/runtime/supervise/worker-slots.d.ts
+/**
+ * Worker slots: the one bound on how many spawned agents work at the same time.
+ *
+ * Every scope of a supervised tree draws from one allocator. A host that runs several trees in one
+ * process can pass the same allocator to each of them, and the bound then holds across all of them.
+ *
+ * A spawn past the bound is never refused. It keeps its reserved budget slice and waits in a queue,
+ * and it starts when a slot frees. The queue releases the deepest spawn first and then the oldest,
+ * so a subtree that is already paid for finishes before the tree grows wider.
+ *
+ * A slot counts a working agent: a spawned agent that runs with no running child of its own. A
+ * manager whose children are all running is waiting on them, so its first running child takes over
+ * the manager's slot and the manager takes it back when its last running child ends. This makes
+ * nested waits deadlock-free: a manager can always run one child on its own slot, so a queued subtree
+ * always keeps a path to completion, whatever the bound and however deep the tree.
+ *
+ * The bound therefore limits working agents, not environments. The environments alive at one time
+ * can exceed it by the number of managers that have a running child. The conserved budget pool and
+ * the deadline bound the total work; this allocator only bounds how much of it runs at once.
+ *
+ * @experimental
+ */
+/** A fleet-wide bound on concurrently working agents, with a queue for the spawns past it. */
+interface WorkerSlots {
+  /** The bound on working agents, or `undefined` when only the budget bounds concurrency. */
+  readonly max: number | undefined;
+  /** Working agents that hold a slot now. */
+  readonly working: number;
+  /** Spawns that hold a budget slice and wait for a slot. */
+  readonly queued: number;
+}
+/**
+ * One held or awaited slot. `ready` resolves when the slot is granted; `granted` reads whether it
+ * has been. `release` returns the slot, or withdraws a request that is still queued, and is
+ * idempotent.
+ */
+interface SlotPermit {
+  readonly ready: Promise<void>;
+  readonly granted: boolean;
+  release(): void;
+}
+/**
+ * Create a worker-slot allocator. `max` omitted, `0`, or negative leaves concurrency bounded by the
+ * budget alone, and every spawn starts at once. Pass the returned allocator as `workerSlots` to each
+ * run that should share one bound.
+ */
+declare function createWorkerSlots(max?: number): WorkerSlots;
+//#endregion
 //#region src/errors.d.ts
 /**
  *
@@ -1915,6 +1998,18 @@ declare class RetainedRunDispatchBindingError extends AgentEvalError {
   });
 }
 //#endregion
+//#region src/runtime/supervise/upstream-unavailable.d.ts
+/** How long an agent waits after its upstream refused a turn for capacity: the codes and
+ *  statuses `upstreamUnavailableSignal` reads. A pause is not a failure: a driver spends neither
+ *  `maxAttempts` nor `maxConsecutiveFailures` on it. */
+interface UnavailablePausePolicy {
+  /** The first pause, doubling per consecutive refusal. Default 15000ms. */
+  readonly unavailablePauseMs?: number;
+  /** Ceiling on the doubling. Default 300000ms, so a long outage costs at most twelve turns an
+   *  hour. */
+  readonly maxUnavailablePauseMs?: number;
+}
+//#endregion
 //#region src/runtime/supervise/driver-retry.d.ts
 /** The scope's live conserved-pool readout — the retry's real bound. Indexed off `Scope` so this
  *  module tracks the pool's shape rather than restating it. */
@@ -1924,7 +2019,7 @@ type DriverBudgetReadout = Scope<unknown>['budget'];
 type DriverContractState = 'met' | 'unmet' | 'none';
 /** How hard the root driver is retried after a transient failure. The defaults retry; a caller
  *  that wants the pre-#741 behavior sets `enabled: false` and owns the consequence. */
-interface DriverRetryPolicy {
+interface DriverRetryPolicy extends UnavailablePausePolicy {
   /** `false` restores the historical behavior: the first driver failure ends the run. */
   readonly enabled?: boolean;
   /** Consecutive failures that changed NOTHING (no metered spend, no settlement, no submission)
@@ -1938,13 +2033,6 @@ interface DriverRetryPolicy {
   readonly initialBackoffMs?: number;
   /** Ceiling on the doubling. Default 30000ms. */
   readonly maxBackoffMs?: number;
-  /** Pause before re-entering after the upstream was unavailable (see
-   *  {@link upstreamUnavailableSignal}), doubling per consecutive pause. Default 15000ms. A pause
-   *  is not a failure: it consumes neither `maxAttempts` nor `maxConsecutiveFailures`. */
-  readonly unavailablePauseMs?: number;
-  /** Ceiling on the pause doubling. Default 300000ms, so a long outage costs at most twelve
-   *  re-entries an hour. */
-  readonly maxUnavailablePauseMs?: number;
 }
 /** Why the retry loop stopped. `completed` is the only non-failure. */
 type DriverAttemptStop = 'completed' | 'terminal-error' | 'retry-disabled' | 'aborted' | 'budget-exhausted' | 'deadline' | 'no-progress' | 'max-attempts';
@@ -2355,6 +2443,23 @@ interface ExecutorProgress {
   /** A one-line human-readable state ("turn 3, running tests"). */
   readonly note?: string;
 }
+/** The team a worker leads, as its own lead observes it mid-flight: every agent below the worker,
+ *  at every depth. A lead reads this instead of the team's raw outputs, so the read stays bounded
+ *  however large the team grows. */
+interface TeamProgress {
+  /** Agents spawned below the worker, at every depth. */
+  readonly agents: number;
+  /** Levels below the worker: `1` when it leads only workers that lead no one. */
+  readonly depth: number;
+  /** Agents below it that hold a worker slot and are running. */
+  readonly working: number;
+  /** Agents below it waiting for a worker slot. */
+  readonly queued: number;
+  /** Agents below it that settled done. */
+  readonly done: number;
+  /** Agents below it that settled down or were cancelled. */
+  readonly down: number;
+}
 /** The full live view of one worker, as `observe_agent` returns it mid-flight. */
 interface WorkerProgress {
   readonly id: string;
@@ -2365,9 +2470,11 @@ interface WorkerProgress {
    *  can actually reach it. False means a steer would be recorded and dropped. */
   readonly steerable: boolean;
   readonly startedAt: number;
-  /** Epoch ms of the last metered usage event or executor-reported activity. */
+  /** Epoch ms of the last metered usage event or executor-reported activity. For a worker that
+   *  leads a team, the newest activity anywhere in that team counts, its own turns included. */
   readonly lastActivityAt: number;
   readonly idleMs: number;
+  /** Live, not waiting for a worker slot, and idle past `stallAfterMs`. */
   readonly stalled: boolean;
   readonly stallAfterMs: number;
   /** Metered iterations so far (the executor's own count when it reports one). */
@@ -2393,6 +2500,8 @@ interface WorkerProgress {
    *  Unlike `recentActivity` this is never evicted, so it still answers on a failed run. */
   readonly derived?: ReadonlyArray<string>;
   readonly note?: string;
+  /** The team this worker leads; absent while it leads no one. */
+  readonly team?: TeamProgress;
 }
 /** A bounded newest-last ring of `ActivityNote`s an executor keeps to answer `progress()`. */
 interface ActivityLog {
@@ -2420,6 +2529,8 @@ interface ScopeProgressInput {
   readonly usd: number;
   readonly usdKnown?: boolean;
   readonly resources?: Spend['resources'];
+  /** The team the worker leads, when it leads one. */
+  readonly team?: TeamProgress;
 }
 /** Fold the scope-derived facts and the executor's optional enrichment into one read. Pure: the
  *  caller supplies `now`, so a test can observe a stall without waiting for one. */
@@ -2471,10 +2582,22 @@ interface RetainedChildRecovery {
     kind: 'spawned';
   }>;
   readonly spec: AgentSpec;
+  /** The node's original task, which its admitted identity digests. */
   readonly task: unknown;
+  /** The admissions of the invocation being recovered. */
   readonly admissions: readonly RetainedRunAdmission[];
   readonly factory: ExecutorFactory<unknown>;
   readonly priorMaterialization?: ProfileMaterializationReceipt;
+  /** The invocation being recovered, when it is a leaf's continuation rather than its first. */
+  readonly continuation?: RetainedLeafContinuation;
+}
+/** @internal A leaf's later invocation: its own task, input and execution identity, and the
+ *  environment admission of the invocation it continues. */
+interface RetainedLeafContinuation {
+  readonly task: unknown;
+  readonly inputSeq: number;
+  readonly executionId: string;
+  readonly priorSession: RetainedRunEnvironmentAdmission;
 }
 //#endregion
 //#region src/runtime/supervise/trace-source.d.ts
@@ -2798,18 +2921,45 @@ interface OtelExportConfig {
   batchSize?: number;
   /** Flush interval ms. Default 5000. */
   flushIntervalMs?: number;
+  /**
+   * Most spans held at once, queued plus in flight. Default 2048, the OpenTelemetry batch
+   * processor's own default. A span that arrives when the queue is full is dropped and counted in
+   * {@link OtelExportStats.dropped}, so a stalled collector costs a bounded amount of memory.
+   */
+  maxQueueSize?: number;
+  /** Milliseconds one POST may take before it is abandoned and its spans count as dropped. Default 10000. */
+  timeoutMs?: number;
   /** Resource attributes stamped on every export. */
   resourceAttributes?: Record<string, string | number | boolean>;
   /** Service name. Default 'agent-runtime'. */
   serviceName?: string;
 }
 interface OtelExporter {
-  /** Export a span. */
+  /** Export a span. Never throws: a sink that cannot take the span counts it as dropped. */
   exportSpan(span: OtelSpan): void;
-  /** Force flush pending spans. */
+  /**
+   * Deliver everything queued so far. Rejects when spans were dropped since the previous `flush`,
+   * naming how many and the last error, because a caller that awaits delivery is owed the answer.
+   */
   flush(): Promise<void>;
-  /** Shutdown cleanly. */
+  /** Stop accepting spans and deliver what is queued. Never rejects. */
   shutdown(): Promise<void>;
+  /** What this sink has delivered and lost so far. */
+  stats(): OtelExportStats;
+}
+/**
+ * Delivery accounting for one exporter. `written + dropped + pending` covers every span handed to
+ * `exportSpan`, so a trace that arrives short can be told apart from a run that emitted less.
+ */
+interface OtelExportStats {
+  /** Spans the sink confirmed: a 2xx collector response, or a completed file append. */
+  written: number;
+  /** Spans lost: refused by the collector, failed in transit, over the queue bound, or unwritable. */
+  dropped: number;
+  /** Spans accepted and not yet written or dropped. */
+  pending: number;
+  /** The most recent failure, when there has been one. */
+  lastError?: string;
 }
 interface OtelSpan {
   traceId: string;
@@ -2855,7 +3005,13 @@ interface OtelAttribute {
  */
 declare function createOpenInferenceFileExporter(filePath: string): OtelExporter;
 /**
- * Create an OTEL exporter. Returns undefined when no endpoint is configured.
+ * Create an OTLP/HTTP exporter. Returns undefined when no endpoint is configured.
+ *
+ * One batch is in flight at a time; spans that arrive meanwhile wait in a queue bounded by
+ * `maxQueueSize`. Every span ends in exactly one of `written` or `dropped`: a non-2xx response, a
+ * network error, a timeout, an OTLP `partialSuccess.rejectedSpans` count and a full queue each count
+ * as drops and set `lastError`. Nothing here throws into the caller's run; `flush()` reports the
+ * loss, the same rule {@link createOpenInferenceFileExporter} follows.
  */
 declare function createOtelExporter(config?: OtelExportConfig): OtelExporter | undefined;
 /**
@@ -3883,12 +4039,14 @@ interface Spend {
    */
   tokensProvenance?: TokenUsageProvenance;
 }
-/** `'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.
+/** `'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' | 'acquiring' | 'running' | 'waiting' | 'done' | 'failed' | 'cancelled';
+type NodeStatus = 'pending' | 'queued' | 'acquiring' | 'running' | 'waiting' | 'done' | 'failed' | 'cancelled';
 /** Deterministic node id — `${parent}:s${seq}` from the cursor order, never wall-clock. */
 type NodeId = string;
 interface SpawnOpts {
@@ -3904,10 +4062,14 @@ interface SpawnOpts {
    * idempotent per key: once a child spawned under a key settles `done` — in this process or in a
    * journaled prior one — spawning the same key returns that committed result (`prior.state:
    * 'completed'`) instead of paying for the work again. A key whose prior attempt settled `down`
-   * spawns fresh and says so explicitly (`prior.state: 'retried'`). A key whose prior attempt was
-   * journaled as started but never settled is refused (`'in-doubt'`): the remote execution may
-   * still exist and must be recovered before replacement. A key that is currently LIVE is refused
-   * (`'duplicate-key'`). Unkeyed spawns (the default) are position-identified and always run.
+   * spawns fresh and says so explicitly (`prior.state: 'retried'`); a resume DERIVES that same
+   * `down` for an interrupted `inline` attempt, because an in-process execution cannot outlive
+   * its process — so a worker killed mid-flight under a plain in-process executor retries under
+   * its own key instead of wedging. A key whose un-settled prior attempt may still exist
+   * elsewhere (`sandbox`/`cli`/`router` runtimes) is refused (`'in-doubt'`): the remote execution
+   * may still be running and must be recovered before replacement. A key that is currently LIVE
+   * is refused (`'duplicate-key'`). Unkeyed spawns (the default) are position-identified and
+   * always run.
    */
   readonly key?: string;
   /** The settled sibling node this spawn replaces, so a run's record names which worker took over
@@ -3928,7 +4090,7 @@ interface SpawnOpts {
  * run, its driver simply finished. A caller that outlived the request it was serving (a background
  * tool invocation still holding the driver's verbs) gets a refusal it can record, instead of a
  * child nobody joins. */
-type SpawnRejection = 'budget-exhausted' | 'usd-unbudgeted' | 'depth-exceeded' | 'duplicate-key' | 'in-doubt' | 'invalid-identity' | 'key-conflict' | 'max-live-workers' | 'scope-aborted' | 'scope-settled';
+type SpawnRejection = 'budget-exhausted' | 'usd-unbudgeted' | 'depth-exceeded' | 'duplicate-key' | 'in-doubt' | 'invalid-identity' | 'key-conflict' | 'scope-aborted' | 'scope-settled';
 /**
  * What a KEYED spawn resolved to when the key had a prior attempt. Absent on a fresh key (and on
  * every unkeyed spawn). `'completed'` is the exactly-once path: NOTHING was spawned — the handle
@@ -3993,6 +4155,8 @@ type Settled<Out> = {
   harnessTranscript?: HarnessTranscriptEvidence;
   /** Present when the measured spend exceeded this child's reservation. */
   budgetViolation?: BudgetViolation;
+  /** Present when this child led workers of its own: a bounded account of its team. */
+  subtree?: SubtreeSummary;
   /** Epoch ms parsed from the durable settlement record when available. */
   settledAt?: number;
   seq: number;
@@ -4022,8 +4186,9 @@ type Settled<Out> = {
   budgetViolation?: BudgetViolation;
   /** Present only when this child's provider execution was RETAINED (see
    *  `RetainedExecutionState`); absent on an ordinary down. `'pending'` on the settlement the
-   *  driver receives at the reconcile; `'released'` on the replayed settlement of a node the
-   *  release sweep closed. The driver and every replay reader see the fact the journal
+   *  driver receives at the reconcile; `'released'` or `'release-unconfirmed'` on the
+   *  replayed settlement of a node a final settlement closed. The driver and every replay
+   *  reader see the fact the journal
    *  states, so a reader never splits this population on `reason` text — which is identical
    *  on every one of these children. */
   retainedExecution?: RetainedExecutionState;
@@ -4033,10 +4198,47 @@ type Settled<Out> = {
    *  `retainedExecution` is; the `reason` text names the same thing, but a reader must never
    *  have to parse it (#1204). */
   retainedPendingCause?: RetainedPendingCause;
+  /** Present when this child led workers of its own: a bounded account of its team. */
+  subtree?: SubtreeSummary;
   /** Epoch ms parsed from the durable settlement/cancellation record when available. */
   settledAt?: number;
   seq: number;
 };
+/**
+ * A bounded account of the team a manager led, carried up on its settlement.
+ *
+ * A lead reads its children's summaries instead of every descendant's output: the counts cover
+ * the whole subtree, and `results` lists only the manager's own direct children, best first.
+ * Every listed result stays addressable by its content address (`outRef`), so the lead can read
+ * any one of them in full. The summary is bounded at every level, so a tree of hundreds of agents
+ * reaches its root as a handful of summaries.
+ */
+interface SubtreeSummary {
+  /** Spawned agents below this node, at every depth. */
+  readonly agents: number;
+  /** Levels below this node: `1` when it led only workers that led no one. */
+  readonly depth: number;
+  /** Agents below this node that settled done. */
+  readonly done: number;
+  /** Agents below this node that settled down or were cancelled. */
+  readonly down: number;
+  /** This node's own direct children, done before down and then by score, at most
+   *  `SUBTREE_RESULT_LIMIT` of them. */
+  readonly results: ReadonlyArray<SubtreeResult>;
+  /** Direct children not listed in `results`. */
+  readonly omitted: number;
+}
+/** One direct child of a manager, as its lead sees it in a {@link SubtreeSummary}. */
+interface SubtreeResult {
+  readonly id: NodeId;
+  readonly label: string;
+  readonly status: 'done' | 'down';
+  /** Content address of the child's retained output, when it produced one. */
+  readonly outRef?: string;
+  readonly score?: number;
+  /** Agents in this child's own subtree, itself excluded. */
+  readonly agents: number;
+}
 /**
  * The budget-conserving reactive scope an `Agent.act` runs inside. `spawn` reserves
  * budget atomically from the shared pool and fails closed when the pool cannot cover it.
@@ -4181,12 +4383,14 @@ interface Scope<Out> {
   readonly view: TreeView;
   /** Conserved-pool readouts (post-reservation). */
   readonly budget: BudgetReadout;
-  /** One tree-wide view of simultaneous spawned work. Every nested scope reads the same counter;
-   *  the root agent itself is not a spawned worker. `freeSlots` is `null` when no limit is set.
-   *  `unconfirmed` NAMES the settled children whose executor teardown was never acknowledged —
-   *  the nodes still holding a capacity slot. Empty on every healthy run. */
+  /** The worker-slot allocator as this scope sees it. Every scope of a tree, and every tree that
+   *  shares the allocator, reads the same counts; the root agent itself holds no slot. `working`
+   *  counts agents that hold a slot, `queued` counts admitted spawns that wait for one, and
+   *  `freeSlots` is `null` when no bound is set. `unconfirmed` NAMES this scope's settled children
+   *  whose executor teardown was never acknowledged. Empty on every healthy run. */
   readonly workerCapacity: Readonly<{
-    live: number;
+    working: number;
+    queued: number;
     freeSlots: number | null;
     unconfirmed: ReadonlyArray<UnconfirmedTeardown>;
   }>;
@@ -4253,8 +4457,12 @@ interface ResumedKeyState<Out = unknown> {
   /** Identity recorded when this key was first admitted. Every reuse must match it exactly. */
   readonly identity?: NodeExecutionIdentity;
   readonly state: 'completed' | 'down' | 'in-doubt';
-  /** The rehydrated settlement; absent exactly when `state` is `'in-doubt'`. */
+  /** The rehydrated settlement; absent when `state` is `'in-doubt'`, and when `'down'` was
+   * *derived* — the resume itself proved the execution dead (an `inline` runtime cannot outlive
+   * its process), so there is no settlement to rehydrate and `reason` says how it died. */
   readonly settled?: Settled<Out>;
+  /** Why a derived `'down'` state exists. Absent on every state backed by a settlement. */
+  readonly reason?: string;
 }
 interface NodeSnapshot {
   readonly id: NodeId;
@@ -4301,10 +4509,10 @@ interface NodeSnapshot {
   readonly trace?: WorkerTraceEvidence;
   /** Present once a settled node's measured spend exceeded its reservation. */
   readonly budgetViolation?: BudgetViolation;
-  /** Present on a retained child: `'pending'` while its cursor slot is open, `'released'` once
-   *  the release sweep closed it. The live view (`makeTreeView`) and the journal view
-   *  (`materializeTreeView`) state the same fact, so a settle record's `tree` answers the
-   *  retained-vs-down question without the observer journal. */
+  /** Present on a retained child: `'pending'` while its cursor slot is open, `'released'` or
+   *  `'release-unconfirmed'` once a final settlement closed it. The live view (`makeTreeView`)
+   *  and the journal view (`materializeTreeView`) state the same fact, so a settle record's
+   *  `tree` answers the retained-vs-down question without the observer journal. */
   readonly retainedExecution?: RetainedExecutionState;
   /** Why a retained child has no accepted result; see `RetainedPendingCause`. */
   readonly retainedPendingCause?: RetainedPendingCause;
@@ -4313,7 +4521,7 @@ interface NodeSnapshot {
 interface TreeView {
   readonly root: NodeId;
   readonly nodes: ReadonlyArray<NodeSnapshot>;
-  /** Count of nodes in `running` or `acquiring` — the "what's in flow?" answer. */
+  /** 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
@@ -4336,12 +4544,10 @@ type SpawnEvent = {
   successorOf?: NodeId;
   budget: Budget;
   runtime: Runtime;
-  /** Root-only opt-in admission contract. A resumed run must use the same policy and fleet
-   * limits; absent on historical and default-off records. */
+  /** Root-only opt-in owner-share contract. A resumed run must use the same policy; absent on
+   * records that set none. */
   recursiveAdmission?: {
     policy: RecursiveReservationPolicy;
-    maxDepth: number;
-    maxLiveWorkers: number;
   };
   /** Exact nested journal tree this node owns. Runtime writes this only after privately
    * attesting the executor as a recursive scope owner. Its absence means no tree is followed,
@@ -4421,13 +4627,15 @@ type SpawnEvent = {
   harnessTranscript?: HarnessTranscriptEvidence;
   /** Present when the reconciled spend exceeded the reservation, on either status. */
   budgetViolation?: BudgetViolation;
-  /** Written by the release sweep in the settling process, on the same tree, after every
-   *  `environment-teardown` receipt for the node reads `destroyed: true` and the executor's
-   *  own teardown confirmed — or by `healReleasedSlots` on the next resume, when that process
-   *  died between the last `destroyed: true` receipt and this record: the same builder, `seq`
-   *  and `at`, read from the `reconciled` record, so the bytes are identical either way. A
-   *  `destroyed: false` receipt, an empty receipt set, or a `reconciled` record without
-   *  `settledSeq` leaves the slot open.
+  /** `'released'` is written by the release sweep in the settling process, on the same tree,
+   *  after every `environment-teardown` receipt for the node reads `destroyed: true` and the
+   *  executor's own teardown confirmed — or by `healReleasedSlots` on the next resume, when
+   *  that process died between the last `destroyed: true` receipt and this record: the same
+   *  builder, `seq` and `at`, read from the `reconciled` record, so the bytes are identical
+   *  either way. `'release-unconfirmed'` is written by the same builder at the end of a final
+   *  settlement for every retained node the release could not confirm: a `destroyed: false`
+   *  receipt, an empty receipt set, or a refused teardown probe. Only a crash before that point
+   *  or a `reconciled` record without `settledSeq` leaves the slot open.
    *  `spent` is this node's child-work component of the reconcile the pool committed — for
    *  a leaf the streamed floor itself, for a recursive executor its `accounting().reported`
    *  split with the remainder on its `metered` records — never the reservation ceiling.
@@ -4436,8 +4644,10 @@ type SpawnEvent = {
    *  delivery, so replay yields it at the position the driver saw it; `at` is the settlement
    *  instant, and the release instant is on the receipt immediately before it. Typed so a
    *  `'pending'` can never be journaled: the journal states that as `reconciled`. */
-  retainedExecution?: Extract<RetainedExecutionState, 'released'>;
+  retainedExecution?: Exclude<RetainedExecutionState, 'pending'>;
   retainedPendingCause?: RetainedPendingCause;
+  /** The bounded account of the team this child led, when it led one. */
+  subtree?: SubtreeSummary;
   seq: number;
   at: string;
 } | {
@@ -4456,8 +4666,10 @@ type SpawnEvent = {
   budgetViolation?: BudgetViolation;
   /** As on `settled`: a retained child that was cancelled settles `cancelled`, and the one
    *  builder writes whichever kind the settlement had. */
-  retainedExecution?: Extract<RetainedExecutionState, 'released'>;
+  retainedExecution?: Exclude<RetainedExecutionState, 'pending'>;
   retainedPendingCause?: RetainedPendingCause;
+  /** The bounded account of the team this child led, when it led one. */
+  subtree?: SubtreeSummary;
   seq: number;
   at: string;
 } | {
@@ -4561,12 +4773,14 @@ type SpawnEvent = {
    *  observed, while its cursor slot stays OPEN so a resume can recover the execution. It stands
    *  in for the `settled` record an open node cannot carry: cost readers and a restored pool
    *  charge this floor for the node instead of its declared ceiling, and a later `settled` or
-   *  `cancelled` record for the same node supersedes it. That record has three writers: a
+   *  `cancelled` record for the same node supersedes it. That record has four writers: a
    *  resumed process's recovered settlement, the release sweep's terminal record marked
-   *  `retainedExecution: 'released'`, or `healReleasedSlots` on the next resume when the
-   *  process died between the last `environment-teardown` receipt and that record. The last
-   *  two write the same bytes, because both read the settlement from THIS record: it is
-   *  literally the settlement it stands in for, minus the cursor position it cannot hold. A
+   *  `retainedExecution: 'released'`, the final settlement's record marked
+   *  `'release-unconfirmed'` for a node whose release it could not confirm, or
+   *  `healReleasedSlots` on the next resume when the process died between the last
+   *  `environment-teardown` receipt and the released record. The last three carry the same
+   *  settlement, because each reads it from THIS record or from the live child it mirrors: it
+   *  is literally the settlement it stands in for, minus the cursor position it cannot hold. A
    *  driver's own inference travels on its `metered` record as on every other path, so
    *  `reconciled + metered` is what the pool committed. Its `seq` lives outside the
    *  cursor-uniqueness namespace; `settledSeq` is the cursor seq. */
@@ -4668,8 +4882,10 @@ type SpawnEvent = {
    *  terminal `settled`/`cancelled` record with `retainedExecution: 'released'` follows on
    *  the same tree and closes the cursor slot; when the settling process dies between this
    *  receipt and that record, `healReleasedSlots` writes the same record on the next resume
-   *  from the `reconciled` record. A `destroyed: false` receipt, an empty receipt set, or an
-   *  unconfirmed teardown leaves the slot open because the environment may still exist.
+   *  from the `reconciled` record. After a `destroyed: false` receipt, an empty receipt set, or
+   *  an unconfirmed teardown, the environment may still exist: the node is journaled as
+   *  `teardown-unconfirmed`, and its slot closes with `retainedExecution:
+   *  'release-unconfirmed'` instead, because the settlement is final either way.
    *  Informational: replay, `materializeTreeView`, and cost readers skip it, and its `seq` is
    *  per node, outside the cursor-uniqueness namespace. */
   kind: 'environment-teardown';
@@ -4780,8 +4996,7 @@ interface Supervisor<Task, Out> {
   attach(h: RootHandle<Out>): void;
 }
 /** Optional recursive admission policy. `ownerShare` is the fraction of every manager's budget
- * kept free for its own inference while children hold their full declared ceilings. The same
- * policy reserves one live worker slot per remaining depth, up to `maxDepth`. */
+ * kept free for its own inference while children hold their declared slices. */
 interface RecursiveReservationPolicy {
   readonly ownerShare: number;
 }
@@ -4807,13 +5022,16 @@ interface SupervisorOpts {
    *  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;
-  /** Runtime recursion-depth ceiling (paired with the conserved pool per R3). */
+  /** Recursion ceiling (root = 0). The conserved pool bounds depth; this only stops a runaway
+   *  recursion. Omit = `DEFAULT_MAX_DEPTH` (16). */
   readonly maxDepth?: number;
-  /** Hard tree-wide cap on simultaneously executing spawned workers. The root is excluded; every
-   *  nested driver and leaf shares this one allocation. Omit/`<= 0` leaves worker count uncapped. */
-  readonly maxLiveWorkers?: number;
-  /** Opt in to reserving each manager's inference share and enough tree-wide worker slots for a
-   * descendant path to `maxDepth`. Omit to retain full-ceiling admission behavior. */
+  /** The bound on concurrently working agents across the whole tree, as a number or as an
+   *  allocator from `createWorkerSlots` that several runs share. A spawn past it waits in a queue
+   *  instead of being refused. The root holds no slot. Omit/`<= 0` bounds concurrency by the budget
+   *  alone. */
+  readonly workerSlots?: number | WorkerSlots;
+  /** Opt in to keeping each manager's inference share free of its children's slices. A resumed
+   *  run must use the same policy. */
   readonly reservationPolicy?: RecursiveReservationPolicy;
   /**
    * OTP intensity breaker: more than `maxRestarts` child restarts within `withinMs`
@@ -4871,10 +5089,16 @@ interface SupervisorOpts {
    *   Sandbox fleet for 19 to 37 hours without it. It then closes each released child's cursor
    *   slot with a terminal record marked `retainedExecution: 'released'`, so `spendGaps` names
    *   it `unreported` (a floor) rather than `never-settled` (a ceiling) and
-   *   `fleetYield.releasedUnrecovered` counts it; a refused release leaves the slot open and
-   *   the node in `teardownUnconfirmed`. A process that dies between the last `destroyed: true`
-   *   receipt and that record leaves the slot open only until the next resume, whose
-   *   `healReleasedSlots` writes the identical record from the `reconciled` record.
+   *   `fleetYield.releasedUnrecovered` counts it. A release that is refused or cannot be
+   *   confirmed names the node in `teardownUnconfirmed` and its `teardown-unconfirmed` record,
+   *   and after the retry window closes its slot with `retainedExecution: 'release-unconfirmed'`,
+   *   counted by `fleetYield.releaseUnconfirmed`: the settlement is final, so the slot closes
+   *   whether or not the environment is confirmed gone. Measured 2026-09-23/24 on the Discovery
+   *   fleet (Runtime 0.249.1 to 0.261.0): 338 of 1,620 agents never settled, and 179 of the
+   *   retained ones had an admission that never named an environment. A process that dies
+   *   between the last `destroyed: true` receipt and the released record leaves the slot open
+   *   only until the next resume, whose `healReleasedSlots` writes the identical record from the
+   *   `reconciled` record.
    * - `'keep'`: a later process may resume this run, so the environments stay for its recovery.
    *
    * Default: `'keep'` when `resume` is true (a durable run a later process may continue), else
@@ -4999,13 +5223,20 @@ interface SpendGap {
  *   `destroyed: true` receipt and the record (same builder, `seq` and `at`, from the
  *   `reconciled` record). The pool's own admission fault, if the reconcile raised one, is not
  *   on this record.
+ * - `'release-unconfirmed'`: root settlement under `retainedAtSettlement: 'release'` ended with
+ *   the execution unrecovered and its environment NOT confirmed destroyed: the provider refused
+ *   the delete, the executor could not confirm it, or the admission never named an environment
+ *   (a create that timed out). The settlement is final, so no process will recover the execution
+ *   and the slot closes anyway, with the same builder, `seq` and `at` as `'released'`. What the
+ *   node may still hold stays named by its `teardown-unconfirmed` record and in
+ *   `teardownUnconfirmed`, for a sweeper.
  *
  * Absent = an ordinary child. The live `Settled` a driver branched on carried `'pending'` where
- * replay yields `'released'` for the same seq, so a resume-aware driver must not branch on the
- * two values. No `'recovered'` value exists yet: a live-adopted recovery settles on the ordinary
- * path and the recorded-result path writes no marker.
+ * replay yields `'released'` or `'release-unconfirmed'` for the same seq, so a resume-aware driver
+ * must not branch on these values. No `'recovered'` value exists yet: a live-adopted recovery
+ * settles on the ordinary path and the recorded-result path writes no marker.
  */
-type RetainedExecutionState = 'pending' | 'released';
+type RetainedExecutionState = 'pending' | 'released' | 'release-unconfirmed';
 /**
  * How this run's spawned CHILDREN ended, counted by node id off the complete journal FOREST at
  * root settlement — after the join barrier and the release sweep, so the terminal records the
@@ -5024,13 +5255,18 @@ interface FleetYield {
   /** `settled` records with `status: 'down'`, released records included. */
   readonly down: number;
   readonly cancelled: number;
-  /** Spawned with no terminal record: a crash-orphaned child, a refused release, or a retained
-   *  executor with nothing to release. Named after `SpendGap`'s `never-settled`. */
+  /** Spawned with no terminal record: a crash-orphaned child, or a retained child of a run that
+   *  keeps its environments for a resume (`retainedAtSettlement: 'keep'`). Named after
+   *  `SpendGap`'s `never-settled`. */
   readonly neverSettled: number;
   /** Terminal records marked `retainedExecution: 'released'` — a subset of `down + cancelled`.
    *  A nested manager whose OWN retained execution was released counts here beside the
    *  grandchildren it released, because its execution was destroyed unrecovered too. */
   readonly releasedUnrecovered: number;
+  /** Terminal records marked `retainedExecution: 'release-unconfirmed'` — a subset of
+   *  `down + cancelled`, disjoint from `releasedUnrecovered`: executions a final settlement left
+   *  unrecovered without confirming their environment destroyed. */
+  readonly releaseUnconfirmed: number;
 }
 /**
  * One channel on which a settled reservation's measured spend exceeded what it reserved.
@@ -5263,5 +5499,5 @@ interface WidenGate<Out> {
   readonly judgeExempt?: boolean;
 }
 //#endregion
-export { SpawnJournal as $, RuntimeRunCost as $i, HarnessTranscriptUnavailableReason as $n, RetainedRunDispatchedAdmission as $r, toOtelAttributes as $t, NodeExecutionIdentity as A, LoopIterationDispatchPayload as Ai, sandboxSessionTraceSource as An, NotFoundError as Ar, readTraceContextFromEnv as At, ResultBlobStore as B, LoopTokenUsage as Bi, readWorkerProgress as Bn, NativeContextContinuationInput as Br, OtelExporter as Bt, ExecutorToolCall as C, RunAgentTaskStreamOptions as Ca, AgentRunSpec as Ci, waitUntil as Cn, summarizeDriverAttempts as Cr, readWorkerTraceContext as Ct, MaterializedExecutionIdentity as D, RuntimeStreamEvent as Da, Iteration as Di, TraceSource as Dn, BackendTransportError as Dr, TraceContext as Dt, HeldEnvironment as E, RuntimeSessionStore as Ea, ExecCtx as Ei, ToolStepInput as En, AgentEvalErrorCode as Er, workerTraceSeamKey as Et, ProviderModelAttemptEvidence as F, LoopPlanPayload as Fi, DEFAULT_STALL_AFTER_MS as Fn, RetainedRunDispatchBindingError as Fr, EvalRunsExportResult as Ft, RootMaterialization as G, MountRecorder as Gi, RetainedInteractiveRunHandle as Gn, RetainedInteractiveAdmission as Gr, buildRuntimeEventOtelSpans as Gt, ResumedWork as H, LoopTraceEvent as Hi, RecoverRetainedInteractiveRunOptions as Hn, RecoverRetainedRunIntentOptions as Hr, RuntimeEventOtelOptions as Ht, ProviderModelExecutionEvidence as I, LoopResult as Ii, ExecutorProgress as In, RuntimeRunStateError as Ir, INTELLIGENCE_WIRE_VERSION as It, RootStreamReceipt as J, SandboxClient as Ji, HarnessTranscriptArtifact as Jn, RetainedInteractiveStartedAdmission as Jr, exportEvalRuns as Jt, RootProviderModelEvidence as K, OutputAdapter as Ki, RetainedInteractiveStartMaterial as Kn, RetainedInteractiveEnvironmentAdmission as Kr, createOpenInferenceFileExporter as Kt, RecursiveReservationPolicy as L, LoopSandboxPlacement as Li, ScopeProgressInput as Ln, ValidationError as Lr, LoopSpanNode as Lt, NodeSnapshot as M, LoopIterationStartedPayload as Mi, RetainedPendingCause as Mn, RetainedInteractiveAdmissionError as Mr, EvalRunEvent as Mt, NodeStatus as N, LoopLineageOptions as Ni, ActivityLog as Nn, RetainedInteractiveBindingError as Nr, EvalRunGeneration as Nt, MaterializedModelIdentity as O, LoopDecisionPayload as Oi, createPushTraceSource as On, ConfigError as Or, createPropagatingTraceEmitter as Ot, ProfileMaterializationReceipt as P, LoopPlanDescription as Pi, ActivityNote as Pn, RetainedRunAdmissionError as Pr, EvalRunsExportConfig as Pt, SpawnEvent as Q, RuntimeRunCompleteInput as Qi, HarnessTranscriptUnavailable as Qn, RetainedRunCancellation as Qr, padTraceId as Qt, ResourceLimit as R, LoopStartedPayload as Ri, WorkerProgress as Rn, NativeContextContinuationExecution as Rr, OtelAttribute as Rt, ExecutorTeardownWarning as S, RunAgentTaskOptions as Sa, spendFromUsageEvents as Si, validateWaitSpec as Sn, defaultUnmetContractSteer as Sr, WorkerTraceSeamCarrier as St, Handle as T, RuntimeSession as Ta, Driver as Ti, SessionTraceBox as Tn, AgentEvalError$1 as Tr, workerTraceHeaders as Tt, RetainedExecutionState as U, LoopWinner as Ui, RetainedInteractiveAdmissionHook as Un, RecoverRetainedRunOptions as Ur, buildLoopOtelSpans as Ut, ResumedKeyState as V, LoopTraceEmitter as Vi, ReconnectRetainedInteractiveRunOptions as Vn, ReconnectRetainedRunOptions as Vr, OtelSpan as Vt, RootHandle as W, MountManifestEntry as Wi, RetainedInteractiveEnvironmentInput as Wn, RecoverRetainedRunResult as Wr, buildLoopSpanNodes as Wt, Scope as X, ValidationCtx as Xi, HarnessTranscriptEvidence as Xn, RetainedRunAdmissionHook as Xr, loopEventToOtelSpan as Xt, Runtime as Y, SelectionReceipt as Yi, HarnessTranscriptCapture as Yn, RetainedRunAdmission as Yr, generateSpanId as Yt, Settled as Z, Validator as Zi, HarnessTranscriptFile as Zn, RetainedRunCancelOptions as Zr, padSpanId as Zt, ExecutorMaterialization as _, BackendErrorDetail as _a, ReservationRejection as _i, WaitSpec as _n, DriverRetryPolicy as _r, WorkerInteractiveSession as _t, BudgetOverspend as a, startRuntimeRun as aa, RetainedRunReplayPoint as ai, SanitizedKnowledgeReadinessReport as an, DriverAttemptRecord as ar, SpendGap as at, ExecutorRegistry as b, OpenAIChatTool as ba, ReservationTicket as bi, pollFor as bn, OnUnmetContract as br, WorkerTraceUnavailableReason as bt, EnvironmentTeardownReceipt as c, AgentBackendInput as ca, RetainedRunTurnInput as ci, createRuntimeStreamEventCollector as cn, DriverBudgetReadout as cr, Supervisor as ct, ExecutorAccounting as d, AgentRuntimeEvent as da, BudgetPool as di, sanitizeRuntimeStreamEvent as dn, DriverFailureClass as dr, TreeView as dt, RuntimeRunHandle as ea, RetainedRunEffect as ei, RuntimeEventCollector as en, ReadableEnvironment as er, SpawnOpts as et, ExecutorCancellation as f, AgentRuntimeEventSink as fa, BudgetPoolRestore as fi, PendingWait as fn, DriverLoopRecord as fr, UnconfirmedTeardown as ft, ExecutorFactory as g, AgentTaskStatus as ga, ReservationHolder as gi, WaitRejection as gn, DriverRepromptRefusal as gr, WidenGate as gt, ExecutorExecutionBinding as h, AgentTaskSpec as ha, LeakedReservation as hi, WaitProbeRegistry as hn, DriverRepromptPolicy as hr, WaitOpts as ht, Budget as i, RuntimeRunStatus as ia, RetainedRunIntentAdmission as ii, RuntimeTelemetryOptions as in, DEFAULT_MAX_BARREN_REPROMPTS as ir, SpendChannel as it, NodeId as j, LoopIterationEndedPayload as ji, RetainedChildRecovery as jn, PlannerError as jr, traceContextToEnv as jt, NoWinnerError as k, LoopEndedPayload as ki, decodeToolPart as kn, JudgeError as kr, mergeTraceEnv as kt, ExecutionBindingReceipt as l, AgentExecutionBackend as la, StartRetainedRunInEnvironmentOptions as li, sanitizeAgentRuntimeEvent as ln, DriverContinuationRecord as lr, SupervisorOpts as lt, ExecutorContext as m, AgentTaskRunResult as ma, BudgetReconcileFault as mi, WaitProbe as mn, DriverReentry as mr, UsageEvent as mt, AgentExecutionRef as n, RuntimeRunPersistenceAdapter as na, RetainedRunEventOptions as ni, RuntimeStreamEventSink as nn, harnessTranscriptArtifact as nr, SpawnRejection as nt, BudgetViolation as o, AgentAdapter as oa, RetainedRunSnapshot as oi, SanitizedKnowledgeRequirement as on, DriverAttemptStop as or, SteerableRootHandle as ot, ExecutorCancellationRequest as p, AgentTaskContext as pa, BudgetReadout as pi, WaitOutcome as pn, DriverProgressMark as pr, UnknownMaterializationReason as pt, RootSignal as q, RunProvenance as qi, StartRetainedInteractiveRunOptions as qn, RetainedInteractiveIntentAdmission as qr, createOtelExporter as qt, AgentSpec as r, RuntimeRunRow as ra, RetainedRunHandle as ri, RuntimeStreamEventSummary as rn, persistHarnessTranscript as rr, Spend as rt, DefaultVerdict as s, AgentBackendContext as sa, RetainedRunStartMaterial as si, createRuntimeEventCollector as sn, DriverAttemptsExhaustedError as sr, SupervisedResult as st, Agent as t, RuntimeRunOptions as ta, RetainedRunEnvironmentAdmission as ti, RuntimeStreamEventCollector as tn, captureHarnessTranscript as tr, SpawnPrior as tt, Executor as u, AgentKnowledgeProvider as ua, StartRetainedRunOptions as ui, sanitizeKnowledgeReadinessReport as un, DriverContractState as ur, TokenUsageProvenance as ut, ExecutorNodeContext as v, KnowledgeReadinessDecision as va, ReservationShortfall as vi, createWaitProbes as vn, DriverUnmetContractContext as vr, WorkerInteractiveUnavailableReason as vt, FleetYield as w, RuntimeCanonicalStreamEvent as wa, DefaultVerdict$1 as wi, SessionMessageLike as wn, upstreamUnavailableSignal as wr, workerTraceEnv as wt, ExecutorResult as x, OpenAIChatToolChoice as xa, createBudgetPool as xi, timerAt as xn, classifyDriverFailure as xr, WorkerTraceResolver as xt, ExecutorProgressEvent as y, OpenAIChatResponseFormat as ya, ReservationStage as yi, isWaitOutcome as yn, DriverUnmetContractDecision as yr, WorkerTraceEvidence as yt, ResourceSpend as z, LoopTeardownFailedPayload as zi, createActivityLog as zn, NativeContextContinuationHandle as zr, OtelExportConfig as zt };
-//# sourceMappingURL=types-BV14WTyW.d.ts.map
+export { SpawnJournal as $, LoopTraceEvent as $i, HarnessTranscriptCapture as $n, RetainedInteractiveAdmission as $r, loopEventToOtelSpan as $t, NodeExecutionIdentity as A, OpenAIChatResponseFormat as Aa, ReservationWaitRefused as Ai, TraceSource as An, AgentEvalError$1 as Ar, createPropagatingTraceEmitter as At, ResultBlobStore as B, LoopEndedPayload as Bi, ScopeProgressInput as Bn, RetainedRunDispatchBindingError as Br, OtelAttribute as Bt, ExecutorToolCall as C, AgentRuntimeEventSink as Ca, LeakedReservation as Ci, pollFor as Cn, DriverUnmetContractDecision as Cr, WorkerTraceResolver as Ct, MaterializedExecutionIdentity as D, AgentTaskStatus as Da, ReservationShortfall as Di, SessionMessageLike as Dn, summarizeDriverAttempts as Dr, workerTraceHeaders as Dt, HeldEnvironment as E, AgentTaskSpec as Ea, ReservationRejection as Ei, waitUntil as En, defaultUnmetContractSteer as Er, workerTraceEnv as Et, ProviderModelAttemptEvidence as F, RuntimeCanonicalStreamEvent as Fa, DefaultVerdict$1 as Fi, RetainedPendingCause as Fn, NotFoundError as Fr, EvalRunGeneration as Ft, RootMaterialization as G, LoopPlanDescription as Gi, ReconnectRetainedInteractiveRunOptions as Gn, createWorkerSlots as Gr, RuntimeEventOtelOptions as Gt, ResumedWork as H, LoopIterationEndedPayload as Hi, WorkerProgress as Hn, ValidationError as Hr, OtelExportStats as Ht, ProviderModelExecutionEvidence as I, RuntimeSession as Ia, Driver as Ii, ActivityLog as In, PlannerError as Ir, EvalRunsExportConfig as It, RootStreamReceipt as J, LoopSandboxPlacement as Ji, RetainedInteractiveEnvironmentInput as Jn, NativeContextContinuationInput as Jr, buildRuntimeEventOtelSpans as Jt, RootProviderModelEvidence as K, LoopPlanPayload as Ki, RecoverRetainedInteractiveRunOptions as Kn, NativeContextContinuationExecution as Kr, buildLoopOtelSpans as Kt, RecursiveReservationPolicy as L, RuntimeSessionStore as La, ExecCtx as Li, ActivityNote as Ln, RetainedInteractiveAdmissionError as Lr, EvalRunsExportResult as Lt, NodeSnapshot as M, OpenAIChatToolChoice as Ma, createBudgetPool as Mi, decodeToolPart as Mn, BackendTransportError as Mr, readTraceContextFromEnv as Mt, NodeStatus as N, RunAgentTaskOptions as Na, spendFromUsageEvents as Ni, sandboxSessionTraceSource as Nn, ConfigError as Nr, traceContextToEnv as Nt, MaterializedModelIdentity as O, BackendErrorDetail as Oa, ReservationStage as Oi, SessionTraceBox as On, upstreamUnavailableSignal as Or, workerTraceSeamKey as Ot, ProfileMaterializationReceipt as P, RunAgentTaskStreamOptions as Pa, AgentRunSpec as Pi, RetainedChildRecovery as Pn, JudgeError as Pr, EvalRunEvent as Pt, SpawnEvent as Q, LoopTraceEmitter as Qi, HarnessTranscriptArtifact as Qn, RecoverRetainedRunResult as Qr, generateSpanId as Qt, ResourceLimit as R, RuntimeStreamEvent as Ra, Iteration as Ri, DEFAULT_STALL_AFTER_MS as Rn, RetainedInteractiveBindingError as Rr, INTELLIGENCE_WIRE_VERSION as Rt, ExecutorTeardownWarning as S, AgentRuntimeEvent as Sa, BudgetReconcileFault as Si, isWaitOutcome as Sn, DriverUnmetContractContext as Sr, WorkerTraceUnavailableReason as St, Handle as T, AgentTaskRunResult as Ta, ReservationHolder as Ti, validateWaitSpec as Tn, classifyDriverFailure as Tr, readWorkerTraceContext as Tt, RetainedExecutionState as U, LoopIterationStartedPayload as Ui, createActivityLog as Un, SlotPermit as Ur, OtelExporter as Ut, ResumedKeyState as V, LoopIterationDispatchPayload as Vi, TeamProgress as Vn, RuntimeRunStateError as Vr, OtelExportConfig as Vt, RootHandle as W, LoopLineageOptions as Wi, readWorkerProgress as Wn, WorkerSlots as Wr, OtelSpan as Wt, Scope as X, LoopTeardownFailedPayload as Xi, RetainedInteractiveStartMaterial as Xn, RecoverRetainedRunIntentOptions as Xr, createOtelExporter as Xt, Runtime as Y, LoopStartedPayload as Yi, RetainedInteractiveRunHandle as Yn, ReconnectRetainedRunOptions as Yr, createOpenInferenceFileExporter as Yt, Settled as Z, LoopTokenUsage as Zi, StartRetainedInteractiveRunOptions as Zn, RecoverRetainedRunOptions as Zr, exportEvalRuns as Zt, ExecutorMaterialization as _, AgentAdapter as _a, StartRetainedRunInEnvironmentOptions as _i, WaitProbe as _n, DriverProgressMark as _r, WaitOpts as _t, BudgetOverspend as a, SandboxClient as aa, RetainedRunCancelOptions as ai, RuntimeStreamEventSink as an, captureHarnessTranscript as ar, SpendGap as at, ExecutorRegistry as b, AgentExecutionBackend as ba, BudgetPoolRestore as bi, WaitSpec as bn, DriverRepromptRefusal as br, WorkerInteractiveUnavailableReason as bt, EnvironmentTeardownReceipt as c, Validator as ca, RetainedRunEffect as ci, SanitizedKnowledgeReadinessReport as cn, DEFAULT_MAX_BARREN_REPROMPTS as cr, SubtreeSummary as ct, ExecutorAccounting as d, RuntimeRunHandle as da, RetainedRunHandle as di, createRuntimeStreamEventCollector as dn, DriverAttemptsExhaustedError as dr, SupervisorOpts as dt, LoopWinner as ea, RetainedInteractiveEnvironmentAdmission as ei, padSpanId as en, HarnessTranscriptEvidence as er, SpawnOpts as et, ExecutorCancellation as f, RuntimeRunOptions as fa, RetainedRunIntentAdmission as fi, sanitizeAgentRuntimeEvent as fn, DriverBudgetReadout as fr, TokenUsageProvenance as ft, ExecutorFactory as g, startRuntimeRun as ga, RetainedRunTurnInput as gi, WaitOutcome as gn, DriverLoopRecord as gr, UsageEvent as gt, ExecutorExecutionBinding as h, RuntimeRunStatus as ha, RetainedRunStartMaterial as hi, PendingWait as hn, DriverFailureClass as hr, UnknownMaterializationReason as ht, Budget as i, RunProvenance as ia, RetainedRunAdmissionHook as ii, RuntimeStreamEventCollector as in, ReadableEnvironment as ir, SpendChannel as it, NodeId as j, OpenAIChatTool as ja, ReserveOptions as ji, createPushTraceSource as jn, AgentEvalErrorCode as jr, mergeTraceEnv as jt, NoWinnerError as k, KnowledgeReadinessDecision as ka, ReservationTicket as ki, ToolStepInput as kn, UnavailablePausePolicy as kr, TraceContext as kt, ExecutionBindingReceipt as l, RuntimeRunCompleteInput as la, RetainedRunEnvironmentAdmission as li, SanitizedKnowledgeRequirement as ln, DriverAttemptRecord as lr, SupervisedResult as lt, ExecutorContext as m, RuntimeRunRow as ma, RetainedRunSnapshot as mi, sanitizeRuntimeStreamEvent as mn, DriverContractState as mr, UnconfirmedTeardown as mt, AgentExecutionRef as n, MountRecorder as na, RetainedInteractiveStartedAdmission as ni, toOtelAttributes as nn, HarnessTranscriptUnavailable as nr, SpawnRejection as nt, BudgetViolation as o, SelectionReceipt as oa, RetainedRunCancellation as oi, RuntimeStreamEventSummary as on, harnessTranscriptArtifact as or, SteerableRootHandle as ot, ExecutorCancellationRequest as p, RuntimeRunPersistenceAdapter as pa, RetainedRunReplayPoint as pi, sanitizeKnowledgeReadinessReport as pn, DriverContinuationRecord as pr, TreeView as pt, RootSignal as q, LoopResult as qi, RetainedInteractiveAdmissionHook as qn, NativeContextContinuationHandle as qr, buildLoopSpanNodes as qt, AgentSpec as r, OutputAdapter as ra, RetainedRunAdmission as ri, RuntimeEventCollector as rn, HarnessTranscriptUnavailableReason as rr, Spend as rt, DefaultVerdict as s, ValidationCtx as sa, RetainedRunDispatchedAdmission as si, RuntimeTelemetryOptions as sn, persistHarnessTranscript as sr, SubtreeResult as st, Agent as t, MountManifestEntry as ta, RetainedInteractiveIntentAdmission as ti, padTraceId as tn, HarnessTranscriptFile as tr, SpawnPrior as tt, Executor as u, RuntimeRunCost as ua, RetainedRunEventOptions as ui, createRuntimeEventCollector as un, DriverAttemptStop as ur, Supervisor as ut, ExecutorNodeContext as v, AgentBackendContext as va, StartRetainedRunOptions as vi, WaitProbeRegistry as vn, DriverReentry as vr, WidenGate as vt, FleetYield as w, AgentTaskContext as wa, ReservationFloor as wi, timerAt as wn, OnUnmetContract as wr, WorkerTraceSeamCarrier as wt, ExecutorResult as x, AgentKnowledgeProvider as xa, BudgetReadout as xi, createWaitProbes as xn, DriverRetryPolicy as xr, WorkerTraceEvidence as xt, ExecutorProgressEvent as y, AgentBackendInput as ya, BudgetPool as yi, WaitRejection as yn, DriverRepromptPolicy as yr, WorkerInteractiveSession as yt, ResourceSpend as z, LoopDecisionPayload as zi, ExecutorProgress as zn, RetainedRunAdmissionError as zr, LoopSpanNode as zt };
+//# sourceMappingURL=types-Bo7z5aG5.d.ts.map