@tangle-network/agent-runtime 0.263.0 → 0.266.0

package/dist/testing.d.ts

@@ -1,5 +1,5 @@
-import { $a as SuperviseTestOptions, $t as runGraphWithTestBrain, Ao as supervisorAgentWithTestBrain, Tn as driverAgent, Yt as RunGraphTestOptions, to as superviseWithTestBrain, wn as DriverAgentOptions, xo as SupervisorAgentTestDeps } from "./index-DLYBQFyl.js";
-import { On as ToolLoopCallContext, kn as ToolLoopChat } from "./stream-agent-turn-Y5rUc6Q-.js";
+import { $a as SuperviseTestOptions, Ao as supervisorAgentWithTestBrain, Tn as driverAgent, Zt as RunGraphTestOptions, tn as runGraphWithTestBrain, to as superviseWithTestBrain, wn as DriverAgentOptions, xo as SupervisorAgentTestDeps } from "./index-CU2mlMfc.js";
+import { Hn as ToolLoopChat, Vn as ToolLoopCallContext } from "./stream-agent-turn-Gw9hLpBn.js";
 import { AgentImprovementProposal, AgentProfile, AgentProfileImprovementMeasuredComparison, SandboxSizePreset } from "@tangle-network/agent-interface";
 //#region src/testing/index.d.ts
 /** A proposal produced by Runtime's opaque profile-improvement path. */

package/dist/testing.js

@@ -1,14 +1,14 @@
 import { C as canonicalCandidateDigest$1, D as immutableCandidateValue } from "./workspace-archive-C9lgf77y.js";
-import { f as verifyAgentImprovementProposal } from "./improvement-cycle-_IPwoII2.js";
+import { f as verifyAgentImprovementProposal } from "./improvement-cycle-GRPoHLm1.js";
 import { i as applyExactAgentProfileDiff, p as parseExactAgentProfile } from "./profile-D3eXNBQV.js";
-import { a as superviseWithTestBrain, h as supervisorAgentWithTestBrain } from "./supervise-RF3_8PuR.js";
-import { r as driverAgent } from "./coordination-driver-L9zH0kBx.js";
-import { i as runGraphWithTestBrain } from "./graph-Cusg4eAx.js";
+import { r as driverAgent } from "./coordination-driver-DdZ-nh_4.js";
+import { a as superviseWithTestBrain, h as supervisorAgentWithTestBrain } from "./supervise--njTtSL3.js";
+import { i as runGraphWithTestBrain } from "./graph-CK50N9vG.js";
 import { SANDBOX_SIZE_PRESET_NAMES } from "@tangle-network/agent-interface";
 //#region src/testing/fixtures/agent-improvement-proposal.json
 var agent_improvement_proposal_default = {
 	changedSurfaces: ["prompt"],
-	digest: "sha256:5f4f50e85d413caae43b957dbf580ca7a0cc00cb7279f0dd8cfb6babf743079b",
+	digest: "sha256:b4ce9950c510d96ecccbb6b3134cca32fe0dcf821aef326e0b34010471dc5fc1",
 	evaluation: {
 		"decision": {
 			"contributingChecks": [
@@ -4579,7 +4579,7 @@ var agent_improvement_proposal_default = {
 		],
 		"metadata": {
 			"fixture": "agent-improvement-proposal",
-			"runtimeVersion": "0.263.0"
+			"runtimeVersion": "0.266.0"
 		},
 		"objectives": [
 			{
@@ -4690,8 +4690,8 @@ var agent_improvement_proposal_default = {
 			"baselineContentHash": "sha256:5c21ee53e513fc604cb09754e21c392b24a424da0ef37dbf8f1ee4a8a0b08f09",
 			"candidateContentHash": "sha256:60fcbb1c728194bd51d7d19cb732d1c3f1881dce7e0a6266b41c8b98cfd65693",
 			"kind": "agent-eval-loop",
-			"recordDigest": "sha256:4c02cbe588b9ab34cd220f4331be18660a69416376b878bc88c2b04309aaf3b0",
-			"runId": "agent-runtime-0.263.0-proposal-fixture",
+			"recordDigest": "sha256:38b07934c181f4f92d397194fd50a1ddf303fe599d53feccced96ee75e3f0299",
+			"runId": "agent-runtime-0.266.0-proposal-fixture",
 			"schema": "agent-candidate-experiment"
 		}
 	},
@@ -4714,13 +4714,13 @@ var agent_improvement_proposal_default = {
 	}],
 	kind: "agent-improvement-proposal",
 	proposedAt: "2026-07-10T01:00:00.000Z",
-	runId: "agent-runtime-0.263.0-proposal-fixture"
+	runId: "agent-runtime-0.266.0-proposal-fixture"
 };
 //#endregion
 //#region src/testing/fixtures/agent-profile-improvement-proposal.json
 var agent_profile_improvement_proposal_default = {
 	changedSurfaces: ["prompt", "skills"],
-	digest: "sha256:35bab5a60f089a9a21f66cb3f057c29f407602648d833d1fbfadfdc177e50645",
+	digest: "sha256:6320cd1100f5e0b06dd69176b4aa65ca738ab573b79edef05673db16357a4547",
 	evaluation: {
 		"decision": {
 			"contributingChecks": [
@@ -6354,7 +6354,7 @@ var agent_profile_improvement_proposal_default = {
 		],
 		"metadata": {
 			"fixture": "agent-profile-improvement-proposal",
-			"runtimeVersion": "0.263.0"
+			"runtimeVersion": "0.266.0"
 		},
 		"objectives": [
 			{
@@ -6465,7 +6465,7 @@ var agent_profile_improvement_proposal_default = {
 			"baselineContentHash": "sha256:21c495a37c418c10bde64fbaa188beddeed31f1f051ea60a6a6582a9ee0db704",
 			"candidateContentHash": "sha256:103f77bc8481601eef1ad5fe6ba84a40dffabc3a44f421f8c8559121edab84e9",
 			"kind": "agent-eval-loop",
-			"recordDigest": "sha256:23893fc7f2a2f713647c2b049a34a4bc4de4960616160790014f807b900f61b1",
+			"recordDigest": "sha256:76a0368ba73c6f3e5e4c18daab0019ef6b95e634fcffc4601d2436c4c8471db6",
 			"runId": "profile-improvement-1",
 			"schema": "agent-profile-improvement-experiment"
 		}

package/dist/tui/index.d.ts

@@ -1,4 +1,4 @@
-import { Ct as ProvisionedSupervisor, St as ProvisionSupervisorRequest, Tt as provisionSupervisor, wt as SupervisorCleanupReceipt, xt as ProvisionSupervisorConnection } from "../index-DLYBQFyl.js";
+import { Ct as ProvisionSupervisorConnection, Dt as provisionSupervisor, Et as SupervisorCleanupReceipt, Tt as ProvisionedSupervisor, wt as ProvisionSupervisorRequest } from "../index-CU2mlMfc.js";
 //#region src/tui/top-app.d.ts
 /**
  * The interactive side of the supervisor-run TUI: a keypress/mouse loop over the frames

package/dist/tui/index.js

@@ -1,3 +1,3 @@
-import { t as provisionSupervisor } from "../provision-supervisor-CIKvsWDa.js";
+import { t as provisionSupervisor } from "../provision-supervisor-Bf_bPaCv.js";
 import { a as renderTopFrameWithLayout, i as renderTopFrame, n as runTopApp, r as loadTopSnapshot, t as renderTopOnce } from "../top-app-VAOrBskv.js";
 export { loadTopSnapshot, provisionSupervisor, renderTopFrame, renderTopFrameWithLayout, renderTopOnce, runTopApp };

package/dist/{types-C-nszovv.d.ts → types-CrnwLVYQ.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';
@@ -2080,8 +2168,9 @@ declare const DEFAULT_MAX_BARREN_REPROMPTS = 2;
  *
  *  - `terminal`: Runtime's own refusal, or a request that fails identically forever. The run ends.
  *  - `transient`: a foreign accident. It is retried under `maxAttempts` and the barren streak.
- *  - `unavailable`: the upstream refused for capacity (quota, rate limit, overload). The driver
- *    pauses and re-enters, and only the deadline, the budget, and cancellation bound the pauses.
+ *  - `unavailable`: the upstream cannot serve now (quota, rate limit, overload, or the router's
+ *    own provider credential refused). The driver pauses and re-enters, and only the deadline, the
+ *    budget, and cancellation bound the pauses.
  */
 type DriverFailureClass = 'transient' | 'terminal' | 'unavailable';
 /**
@@ -2125,8 +2214,10 @@ interface DriverLoopRecord {
   readonly failureRetries: number;
   /** Re-entries after the upstream refused a drive for capacity. Each is a pause, not a failure. */
   readonly unavailablePauses: number;
-  /** Infrastructure time the unavailable upstream cost this loop: every refused drive's duration
-   *  plus the pause after it. */
+  /** Infrastructure time the unavailable upstream cost this loop: every pause, plus every refused
+   *  drive that made no progress. A refused drive that made progress was mostly work, so only its
+   *  pause counts. Measured 2026-09-24 on a real run: a first drive worked 8 minutes before its
+   *  refusal, and counting its whole duration doubled a 10-minute outage to 16 minutes. */
   readonly unavailableMs: number;
   /** Re-entered drives, in a row at the end, that completed without a delivery. */
   readonly barrenReentries: number;
@@ -2352,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;
@@ -2362,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). */
@@ -2390,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 {
@@ -2417,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. */
@@ -2468,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
@@ -3137,6 +3263,12 @@ interface Agent<Task, Out> {
   traceSource?(): TraceSource | undefined;
   /** Optional live execution progress exposed by executors that can observe it. */
   progress?(): ExecutorProgress | undefined;
+  /**
+   * Optional capture of this agent's own harness session, for an agent that runs a harness as a
+   * manager. A driver child forwards it to its executor, so the manager settles with the same
+   * receipt a leaf gets instead of `executor-exposes-no-transcript`.
+   */
+  harnessTranscript?(): HarnessTranscriptCapture | undefined;
 }
 /**
  * The leaf runtime — ONE open interface, not a closed union. `execute` returns a
@@ -3874,12 +4006,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 {
@@ -3919,7 +4053,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
@@ -3984,6 +4118,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;
@@ -4024,10 +4160,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.
@@ -4172,12 +4345,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>;
   }>;
@@ -4304,7 +4479,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
@@ -4327,12 +4502,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,
@@ -4429,6 +4602,8 @@ type SpawnEvent = {
    *  `'pending'` can never be journaled: the journal states that as `reconciled`. */
   retainedExecution?: Extract<RetainedExecutionState, 'released'>;
   retainedPendingCause?: RetainedPendingCause;
+  /** The bounded account of the team this child led, when it led one. */
+  subtree?: SubtreeSummary;
   seq: number;
   at: string;
 } | {
@@ -4449,6 +4624,8 @@ type SpawnEvent = {
    *  builder writes whichever kind the settlement had. */
   retainedExecution?: Extract<RetainedExecutionState, 'released'>;
   retainedPendingCause?: RetainedPendingCause;
+  /** The bounded account of the team this child led, when it led one. */
+  subtree?: SubtreeSummary;
   seq: number;
   at: string;
 } | {
@@ -4771,8 +4948,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;
 }
@@ -4798,13 +4974,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`
@@ -5254,5 +5433,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-C-nszovv.d.ts.map
+export { SpawnJournal as $, LoopWinner as $i, HarnessTranscriptEvidence as $n, RetainedInteractiveEnvironmentAdmission as $r, padSpanId as $t, NodeExecutionIdentity as A, OpenAIChatTool as Aa, ReserveOptions as Ai, createPushTraceSource as An, AgentEvalErrorCode as Ar, createPropagatingTraceEmitter as At, ResultBlobStore as B, LoopIterationDispatchPayload as Bi, TeamProgress as Bn, RuntimeRunStateError as Br, OtelAttribute as Bt, ExecutorToolCall as C, AgentTaskContext as Ca, ReservationFloor as Ci, timerAt as Cn, OnUnmetContract as Cr, WorkerTraceResolver as Ct, MaterializedExecutionIdentity as D, BackendErrorDetail as Da, ReservationStage as Di, SessionTraceBox as Dn, upstreamUnavailableSignal as Dr, workerTraceHeaders as Dt, HeldEnvironment as E, AgentTaskStatus as Ea, ReservationShortfall as Ei, SessionMessageLike as En, summarizeDriverAttempts as Er, workerTraceEnv as Et, ProviderModelAttemptEvidence as F, RuntimeSession as Fa, Driver as Fi, ActivityLog as Fn, PlannerError as Fr, EvalRunGeneration as Ft, RootMaterialization as G, LoopPlanPayload as Gi, RecoverRetainedInteractiveRunOptions as Gn, NativeContextContinuationExecution as Gr, buildLoopOtelSpans as Gt, ResumedWork as H, LoopIterationStartedPayload as Hi, createActivityLog as Hn, SlotPermit as Hr, OtelExporter as Ht, ProviderModelExecutionEvidence as I, RuntimeSessionStore as Ia, ExecCtx as Ii, ActivityNote as In, RetainedInteractiveAdmissionError as Ir, EvalRunsExportConfig as It, RootStreamReceipt as J, LoopStartedPayload as Ji, RetainedInteractiveRunHandle as Jn, ReconnectRetainedRunOptions as Jr, createOpenInferenceFileExporter as Jt, RootProviderModelEvidence as K, LoopResult as Ki, RetainedInteractiveAdmissionHook as Kn, NativeContextContinuationHandle as Kr, buildLoopSpanNodes as Kt, RecursiveReservationPolicy as L, RuntimeStreamEvent as La, Iteration as Li, DEFAULT_STALL_AFTER_MS as Ln, RetainedInteractiveBindingError as Lr, EvalRunsExportResult as Lt, NodeSnapshot as M, RunAgentTaskOptions as Ma, spendFromUsageEvents as Mi, sandboxSessionTraceSource as Mn, ConfigError as Mr, readTraceContextFromEnv as Mt, NodeStatus as N, RunAgentTaskStreamOptions as Na, AgentRunSpec as Ni, RetainedChildRecovery as Nn, JudgeError as Nr, traceContextToEnv as Nt, MaterializedModelIdentity as O, KnowledgeReadinessDecision as Oa, ReservationTicket as Oi, ToolStepInput as On, UnavailablePausePolicy as Or, workerTraceSeamKey as Ot, ProfileMaterializationReceipt as P, RuntimeCanonicalStreamEvent as Pa, DefaultVerdict$1 as Pi, RetainedPendingCause as Pn, NotFoundError as Pr, EvalRunEvent as Pt, SpawnEvent as Q, LoopTraceEvent as Qi, HarnessTranscriptCapture as Qn, RetainedInteractiveAdmission as Qr, loopEventToOtelSpan as Qt, ResourceLimit as R, LoopDecisionPayload as Ri, ExecutorProgress as Rn, RetainedRunAdmissionError as Rr, INTELLIGENCE_WIRE_VERSION as Rt, ExecutorTeardownWarning as S, AgentRuntimeEventSink as Sa, LeakedReservation as Si, pollFor as Sn, DriverUnmetContractDecision as Sr, WorkerTraceUnavailableReason as St, Handle as T, AgentTaskSpec as Ta, ReservationRejection as Ti, waitUntil as Tn, defaultUnmetContractSteer as Tr, readWorkerTraceContext as Tt, RetainedExecutionState as U, LoopLineageOptions as Ui, readWorkerProgress as Un, WorkerSlots as Ur, OtelSpan as Ut, ResumedKeyState as V, LoopIterationEndedPayload as Vi, WorkerProgress as Vn, ValidationError as Vr, OtelExportConfig as Vt, RootHandle as W, LoopPlanDescription as Wi, ReconnectRetainedInteractiveRunOptions as Wn, createWorkerSlots as Wr, RuntimeEventOtelOptions as Wt, Scope as X, LoopTokenUsage as Xi, StartRetainedInteractiveRunOptions as Xn, RecoverRetainedRunOptions as Xr, exportEvalRuns as Xt, Runtime as Y, LoopTeardownFailedPayload as Yi, RetainedInteractiveStartMaterial as Yn, RecoverRetainedRunIntentOptions as Yr, createOtelExporter as Yt, Settled as Z, LoopTraceEmitter as Zi, HarnessTranscriptArtifact as Zn, RecoverRetainedRunResult as Zr, generateSpanId as Zt, ExecutorMaterialization as _, AgentBackendContext as _a, StartRetainedRunOptions as _i, WaitProbeRegistry as _n, DriverReentry as _r, WaitOpts as _t, BudgetOverspend as a, SelectionReceipt as aa, RetainedRunCancellation as ai, RuntimeStreamEventSummary as an, harnessTranscriptArtifact as ar, SpendGap as at, ExecutorRegistry as b, AgentKnowledgeProvider as ba, BudgetReadout as bi, createWaitProbes as bn, DriverRetryPolicy as br, WorkerInteractiveUnavailableReason as bt, EnvironmentTeardownReceipt as c, RuntimeRunCompleteInput as ca, RetainedRunEnvironmentAdmission as ci, SanitizedKnowledgeRequirement as cn, DriverAttemptRecord as cr, SubtreeSummary as ct, ExecutorAccounting as d, RuntimeRunOptions as da, RetainedRunIntentAdmission as di, sanitizeAgentRuntimeEvent as dn, DriverBudgetReadout as dr, SupervisorOpts as dt, MountManifestEntry as ea, RetainedInteractiveIntentAdmission as ei, padTraceId as en, HarnessTranscriptFile as er, SpawnOpts as et, ExecutorCancellation as f, RuntimeRunPersistenceAdapter as fa, RetainedRunReplayPoint as fi, sanitizeKnowledgeReadinessReport as fn, DriverContinuationRecord as fr, TokenUsageProvenance as ft, ExecutorFactory as g, AgentAdapter as ga, StartRetainedRunInEnvironmentOptions as gi, WaitProbe as gn, DriverProgressMark as gr, UsageEvent as gt, ExecutorExecutionBinding as h, startRuntimeRun as ha, RetainedRunTurnInput as hi, WaitOutcome as hn, DriverLoopRecord as hr, UnknownMaterializationReason as ht, Budget as i, SandboxClient as ia, RetainedRunCancelOptions as ii, RuntimeStreamEventSink as in, captureHarnessTranscript as ir, SpendChannel as it, NodeId as j, OpenAIChatToolChoice as ja, createBudgetPool as ji, decodeToolPart as jn, BackendTransportError as jr, mergeTraceEnv as jt, NoWinnerError as k, OpenAIChatResponseFormat as ka, ReservationWaitRefused as ki, TraceSource as kn, AgentEvalError$1 as kr, TraceContext as kt, ExecutionBindingReceipt as l, RuntimeRunCost as la, RetainedRunEventOptions as li, createRuntimeEventCollector as ln, DriverAttemptStop as lr, SupervisedResult as lt, ExecutorContext as m, RuntimeRunStatus as ma, RetainedRunStartMaterial as mi, PendingWait as mn, DriverFailureClass as mr, UnconfirmedTeardown as mt, AgentExecutionRef as n, OutputAdapter as na, RetainedRunAdmission as ni, RuntimeEventCollector as nn, HarnessTranscriptUnavailableReason as nr, SpawnRejection as nt, BudgetViolation as o, ValidationCtx as oa, RetainedRunDispatchedAdmission as oi, RuntimeTelemetryOptions as on, persistHarnessTranscript as or, SteerableRootHandle as ot, ExecutorCancellationRequest as p, RuntimeRunRow as pa, RetainedRunSnapshot as pi, sanitizeRuntimeStreamEvent as pn, DriverContractState as pr, TreeView as pt, RootSignal as q, LoopSandboxPlacement as qi, RetainedInteractiveEnvironmentInput as qn, NativeContextContinuationInput as qr, buildRuntimeEventOtelSpans as qt, AgentSpec as r, RunProvenance as ra, RetainedRunAdmissionHook as ri, RuntimeStreamEventCollector as rn, ReadableEnvironment as rr, Spend as rt, DefaultVerdict as s, Validator as sa, RetainedRunEffect as si, SanitizedKnowledgeReadinessReport as sn, DEFAULT_MAX_BARREN_REPROMPTS as sr, SubtreeResult as st, Agent as t, MountRecorder as ta, RetainedInteractiveStartedAdmission as ti, toOtelAttributes as tn, HarnessTranscriptUnavailable as tr, SpawnPrior as tt, Executor as u, RuntimeRunHandle as ua, RetainedRunHandle as ui, createRuntimeStreamEventCollector as un, DriverAttemptsExhaustedError as ur, Supervisor as ut, ExecutorNodeContext as v, AgentBackendInput as va, BudgetPool as vi, WaitRejection as vn, DriverRepromptPolicy as vr, WidenGate as vt, FleetYield as w, AgentTaskRunResult as wa, ReservationHolder as wi, validateWaitSpec as wn, classifyDriverFailure as wr, WorkerTraceSeamCarrier as wt, ExecutorResult as x, AgentRuntimeEvent as xa, BudgetReconcileFault as xi, isWaitOutcome as xn, DriverUnmetContractContext as xr, WorkerTraceEvidence as xt, ExecutorProgressEvent as y, AgentExecutionBackend as ya, BudgetPoolRestore as yi, WaitSpec as yn, DriverRepromptRefusal as yr, WorkerInteractiveSession as yt, ResourceSpend as z, LoopEndedPayload as zi, ScopeProgressInput as zn, RetainedRunDispatchBindingError as zr, LoopSpanNode as zt };
+//# sourceMappingURL=types-CrnwLVYQ.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-runtime",
-  "version": "0.263.0",
+  "version": "0.266.0",
   "description": "Shared task-lifecycle skeleton for agents: a recursive loop kernel for chat turns, one-shot tasks, and multi-attempt loops, with trace capture and eval-gated self-improvement. Domain behavior lives in adapters; scoring and ship-gates in @tangle-network/agent-eval.",
   "homepage": "https://github.com/tangle-network/agent-runtime#readme",
   "repository": {
@@ -123,7 +123,7 @@
   "peerDependencies": {
     "@tangle-network/agent-eval": ">=0.185.0 <0.188.0",
     "@tangle-network/agent-interface": "^2.11.0",
-    "@tangle-network/sandbox": ">=0.36.4 <0.48.0 || ^0.49.0-0 || ^0.50.0"
+    "@tangle-network/sandbox": ">=0.36.4 <0.48.0 || ^0.49.0-0 || ^0.50.0 || ^0.51.0 || ^0.52.0"
   },
   "dependencies": {
     "@tangle-network/agent-core": ">=0.9.6 <0.10.0",