@tangle-network/agent-runtime 0.259.1 → 0.262.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-sGOO254Q.js";
-import { On as ToolLoopCallContext, kn as ToolLoopChat } from "./stream-agent-turn-DRTFLphI.js";
+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-B8tXCisZ.js";
+import { On as ToolLoopCallContext, kn as ToolLoopChat } from "./stream-agent-turn-u28hoxuR.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 { E as immutableCandidateValue, S as canonicalCandidateDigest$1 } from "./workspace-archive-DQGFwvM6.js";
-import { f as verifyAgentImprovementProposal } from "./improvement-cycle-D0Os0Hg_.js";
-import { C as applyExactAgentProfileDiff, j as parseExactAgentProfile } from "./prepare-RuaAclli.js";
-import { i as superviseWithTestBrain, m as supervisorAgentWithTestBrain } from "./supervise-DsQjhLN-.js";
-import { r as driverAgent } from "./coordination-driver-BmtrkNPu.js";
-import { i as runGraphWithTestBrain } from "./graph-BKRvWzHx.js";
+import { C as canonicalCandidateDigest$1, D as immutableCandidateValue } from "./workspace-archive-C9lgf77y.js";
+import { f as verifyAgentImprovementProposal } from "./improvement-cycle-DirqO-fX.js";
+import { i as applyExactAgentProfileDiff, p as parseExactAgentProfile } from "./profile-D3eXNBQV.js";
+import { a as superviseWithTestBrain, h as supervisorAgentWithTestBrain } from "./supervise-BeAI8-On.js";
+import { r as driverAgent } from "./coordination-driver-COGC8FK2.js";
+import { i as runGraphWithTestBrain } from "./graph-DgODOGWN.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:19457805693ea7ddd45aa6c1e3a9ae0bb360827141cf6d991b1f82d185496389",
+	digest: "sha256:e1d74ab82b724262b4e7bc20293545067a835552bbbd63dd5bf7273b91029883",
 	evaluation: {
 		"decision": {
 			"contributingChecks": [
@@ -4579,7 +4579,7 @@ var agent_improvement_proposal_default = {
 		],
 		"metadata": {
 			"fixture": "agent-improvement-proposal",
-			"runtimeVersion": "0.259.1"
+			"runtimeVersion": "0.262.0"
 		},
 		"objectives": [
 			{
@@ -4690,8 +4690,8 @@ var agent_improvement_proposal_default = {
 			"baselineContentHash": "sha256:5c21ee53e513fc604cb09754e21c392b24a424da0ef37dbf8f1ee4a8a0b08f09",
 			"candidateContentHash": "sha256:60fcbb1c728194bd51d7d19cb732d1c3f1881dce7e0a6266b41c8b98cfd65693",
 			"kind": "agent-eval-loop",
-			"recordDigest": "sha256:4505cf8191efaec81ddaf725576407f06dfee1ed2f87888853e0696ed37eff7a",
-			"runId": "agent-runtime-0.259.1-proposal-fixture",
+			"recordDigest": "sha256:1b01b8fbb4ae05234153c592b541ca0ab769de016b88b74e6f0036ab3dadd2a5",
+			"runId": "agent-runtime-0.262.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.259.1-proposal-fixture"
+	runId: "agent-runtime-0.262.0-proposal-fixture"
 };
 //#endregion
 //#region src/testing/fixtures/agent-profile-improvement-proposal.json
 var agent_profile_improvement_proposal_default = {
 	changedSurfaces: ["prompt", "skills"],
-	digest: "sha256:3ed48a3ac943729eb507b7d105bbf7b5c898a30da911761347a00f30e194cb74",
+	digest: "sha256:5a3be63c1592806ae888e56078f3544a079b0179e9d90c1a207b1f699aeed2c0",
 	evaluation: {
 		"decision": {
 			"contributingChecks": [
@@ -6354,7 +6354,7 @@ var agent_profile_improvement_proposal_default = {
 		],
 		"metadata": {
 			"fixture": "agent-profile-improvement-proposal",
-			"runtimeVersion": "0.259.1"
+			"runtimeVersion": "0.262.0"
 		},
 		"objectives": [
 			{
@@ -6465,7 +6465,7 @@ var agent_profile_improvement_proposal_default = {
 			"baselineContentHash": "sha256:21c495a37c418c10bde64fbaa188beddeed31f1f051ea60a6a6582a9ee0db704",
 			"candidateContentHash": "sha256:103f77bc8481601eef1ad5fe6ba84a40dffabc3a44f421f8c8559121edab84e9",
 			"kind": "agent-eval-loop",
-			"recordDigest": "sha256:7f24dbb41ae9f4a3ca2c8998a7a0f7f3fcab2295f06436d36b986225b2ac70cf",
+			"recordDigest": "sha256:3bbd4a17775981fdcd3ca6eb47d2d926a9c4ab9d743ce95f4dd049cf91eb12ca",
 			"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-sGOO254Q.js";
+import { Ct as ProvisionedSupervisor, St as ProvisionSupervisorRequest, Tt as provisionSupervisor, wt as SupervisorCleanupReceipt, xt as ProvisionSupervisorConnection } from "../index-B8tXCisZ.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-B9tf4soF.js";
+import { t as provisionSupervisor } from "../provision-supervisor-9FMwo-Es.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-ChewVlpE.d.ts → types-CP3iQ8Ji.d.ts}

@@ -1,6 +1,6 @@
 import { l as RuntimeHooks } from "./runtime-hooks-Bj6wJHlH.js";
-import { AgentExactRunControlRef, AgentInteractiveSession, AgentInteractiveSessionPromptAcknowledgement, AgentInteractiveSessionPromptCommand, AgentInteractiveSessionRef, AgentInteractiveSessionStart, AgentNativeContextContinuationOptions, AgentNativeContextContinuationResult, AgentProfile, AgentSessionStatus, AgentTurnResult, ChildTaskEvent, ContextTransferRequest, HarnessType, InputPart, InteractionAcknowledgement, InteractionRequest, InteractionResponseCommand, NativeContextBoundaryProof, NativeContextContinuationRequest, NativeContextContinuationTurn, RequestedInteractions, RuntimeEventEnvelope, Sha256Digest, StreamEvent } from "@tangle-network/agent-interface";
-import { ControlBudget, ControlDecision, ControlEvalResult, ControlRunResult, ControlStep, DataAcquisitionPlan, DefaultVerdict, DefaultVerdict as DefaultVerdict$1, KnowledgeReadinessReport, KnowledgeRequirement, RunRecord, ToolSpan, TraceStore, UserQuestion } from "@tangle-network/agent-eval";
+import { AgentExactRunControlRef, AgentInteractiveSession, AgentInteractiveSessionPromptAcknowledgement, AgentInteractiveSessionPromptCommand, AgentInteractiveSessionRef, AgentInteractiveSessionStart, AgentInteractiveSessionStatus, AgentNativeContextContinuationOptions, AgentNativeContextContinuationResult, AgentProfile, AgentSessionStatus, AgentTurnResult, ChildTaskEvent, ContextTransferRequest, HarnessType, InputPart, InteractionAcknowledgement, InteractionRequest, InteractionResponseCommand, NativeContextBoundaryProof, NativeContextContinuationRequest, NativeContextContinuationTurn, RequestedInteractions, RuntimeEventEnvelope, Sha256Digest, StreamEvent } from "@tangle-network/agent-interface";
+import { AgentEvalError, AgentEvalError as AgentEvalError$1, AgentEvalErrorCode, ConfigError, ControlBudget, ControlDecision, ControlEvalResult, ControlRunResult, ControlStep, DataAcquisitionPlan, DefaultVerdict, DefaultVerdict as DefaultVerdict$1, JudgeError, KnowledgeReadinessReport, KnowledgeRequirement, NotFoundError, RunRecord, ToolSpan, TraceStore, UserQuestion, ValidationError } from "@tangle-network/agent-eval";
 import { AgentRunOutcome } from "@tangle-network/sandbox/runtime";
 import { BackendType, CreateRequestOptions, CreateSandboxOptions, PromptOptions, SandboxEvent, SandboxInstance } from "@tangle-network/sandbox";
 import { AgentEnvironment, AgentEnvironmentCapabilities, AgentEnvironmentProvider, AgentTurnInput, AgentTurnResult as AgentTurnResult$1, CreateAgentEnvironmentInput } from "@tangle-network/agent-interface/environment-provider";
@@ -1770,6 +1770,344 @@ type RecoverRetainedRunResult = {
   readonly environment: AgentEnvironment;
 };
 //#endregion
+//#region src/errors.d.ts
+/**
+ *
+ * A backend transport call (HTTP, gRPC, sidecar IPC) failed with a non-success
+ * status. Distinct from `JudgeError` (which is structural / unrecoverable)
+ * because backend failures are sometimes retryable and consumers may want to
+ * branch on the upstream status code.
+ *
+ * @stable
+ */
+declare class BackendTransportError extends AgentEvalError {
+  readonly backend: string;
+  readonly status?: number;
+  /**
+   * Router-owned proof that a rejected request never reached a provider.
+   *
+   * This is intentionally one-sided. An absent value, or any value this
+   * package does not understand, remains unknown to Runtime.
+   */
+  readonly providerDispatch?: 'not_started';
+  /**
+   * The upstream's own error class when it names one (the bridge's `parse_error`,
+   * `not_configured`, a provider's `invalid_request_error`). A class the upstream never
+   * retries is a decision about the request, so a retry policy may read it where no
+   * status arrived.
+   */
+  readonly upstreamCode?: string;
+  /**
+   * Truncated upstream response body (≤2 KiB) when available. Diagnostic
+   * only — surfaces in `backend_error.error.body` and `final.error.body`
+   * so operators can see "free_tier_limit", "invalid_api_key", etc. without
+   * cracking the log line open.
+   */
+  readonly body?: string;
+  constructor(backend: string, message: string, options?: {
+    cause?: unknown;
+    status?: number;
+    upstreamCode?: string;
+    body?: string;
+    providerDispatch?: 'not_started';
+  });
+}
+/**
+ *
+ * A runtime-run lifecycle method was called in an order the state machine does
+ * not allow: `persist()` before `complete()`, `complete()` twice, etc.
+ *
+ * @stable
+ */
+declare class RuntimeRunStateError extends AgentEvalError {
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+}
+/**
+ *
+ * The dynamic-loop planner returned an unusable topology move — the LLM emitted
+ * no parseable envelope, an unknown `kind`, or a structurally-invalid move
+ * (e.g. a fanout with zero tasks). This is a structural failure of the
+ * agent-authored topology, not a config mistake: the planner ran but its output
+ * cannot drive the kernel. Carries `validation` so cross-package handlers can
+ * pattern-match without importing the runtime. Fail loud — never substitute a
+ * default move, or the loop silently runs a topology nobody chose.
+ *
+ * @stable
+ */
+declare class PlannerError extends AgentEvalError {
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+}
+/**
+ *
+ * The caller's `onAdmission` durability hook rejected, so a retained run's
+ * admission record is not durable. For a pre-create intent, no provider work
+ * has started. For a later record, provider state may already be live and the
+ * environment remains available for recovery. Carries `capture_integrity`
+ * because the required recovery record was not written.
+ *
+ * @stable
+ */
+declare abstract class RetainedAdmissionError<TAdmission extends RetainedRunAdmission | RetainedInteractiveAdmission> extends AgentEvalError {
+  readonly phase: TAdmission['phase'];
+  /** The exact record the hook failed to persist, for direct recovery. */
+  readonly admission: TAdmission;
+  constructor(admission: TAdmission, options?: {
+    cause?: unknown;
+  });
+}
+/** The caller could not persist one detached-run recovery record. @stable */
+declare class RetainedRunAdmissionError extends RetainedAdmissionError<RetainedRunAdmission> {}
+/** The caller could not persist one exact interactive-process recovery record. @stable */
+declare class RetainedInteractiveAdmissionError extends RetainedAdmissionError<RetainedInteractiveAdmission> {}
+/**
+ * A provider returned a valid interactive reference that does not bind to the
+ * exact start request, or returned data that could not be parsed as one.
+ *
+ * The requested start and any valid provider reference are detached snapshots.
+ * Malformed provider data is never copied into the error, so the error remains
+ * safe to persist while the environment remains available for orphan cleanup.
+ *
+ * @stable
+ */
+declare class RetainedInteractiveBindingError extends AgentEvalError {
+  /** The exact native-process start request sent to the provider. */
+  readonly requested: AgentInteractiveSessionStart;
+  /** The valid provider data, when the provider returned a parseable value. */
+  readonly returned: {
+    readonly ref?: AgentInteractiveSessionRef;
+    readonly status?: AgentInteractiveSessionStatus;
+  };
+  constructor(requested: AgentInteractiveSessionStart, returned: RetainedInteractiveBindingError['returned'], options?: {
+    cause?: unknown;
+  });
+}
+/**
+ *
+ * A retained dispatch answered with coordinates that do not bind to the
+ * identity the runtime requested, or failed exact verification. The
+ * environment-phase admission is already durable at this point, so its
+ * coordinates plus the provider reference carried here are the manual
+ * recovery path. The environment is intentionally kept. Carries
+ * `backend_integrity` because the provider violated its dispatch contract.
+ *
+ * @stable
+ */
+declare class RetainedRunDispatchBindingError extends AgentEvalError {
+  /** The coordinates the runtime sent with the dispatch. */
+  readonly requested: {
+    readonly provider: string;
+    readonly environmentId: string;
+    readonly sessionId: string;
+    readonly executionId: string;
+  };
+  /** The loose reference the provider actually returned, for triage. */
+  readonly returned: {
+    readonly id?: string;
+    readonly provider?: string;
+    readonly controlRef?: unknown;
+  };
+  constructor(requested: RetainedRunDispatchBindingError['requested'], returned: RetainedRunDispatchBindingError['returned'], options?: {
+    cause?: unknown;
+  });
+}
+//#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. */
+type DriverBudgetReadout = Scope<unknown>['budget'];
+/** Whether the run's declared completion check has passed. `'none'` means the caller declared no
+ *  check at all — the retry then reads spend and settlements exactly as it always has. */
+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 {
+  /** `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)
+   *  before the run gives up. Default 3. A failure that made progress resets the count. */
+  readonly maxConsecutiveFailures?: number;
+  /** Ceiling on failed invocations across this driver run, regardless of progress. Default 8,
+   *  minimum 1. Successful continuations do not consume this allowance or reset it.
+   *  This bounds repeated crashes that each make enough progress to reset the barren streak. */
+  readonly maxAttempts?: number;
+  /** Backoff before the first retry, doubling per consecutive failure. Default 2000ms. */
+  readonly initialBackoffMs?: number;
+  /** Ceiling on the doubling. Default 30000ms. */
+  readonly maxBackoffMs?: 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';
+/** One attempt's record — the legible failure the issue's third ask names. Emitted per attempt so
+ *  an operator sees `driver failed after N attempts` instead of one opaque `pi exit unknown`. */
+interface DriverAttemptRecord {
+  /** 1-based. */
+  readonly attempt: number;
+  readonly durationMs: number;
+  /** Absent when the attempt completed. */
+  readonly error?: string;
+  readonly classification?: 'transient' | 'terminal';
+  /** Did anything change since the previous attempt (spend, settlement, submission)? */
+  readonly madeProgress: boolean;
+  /** Set when this attempt ended the loop. */
+  readonly stop?: DriverAttemptStop;
+  /** Set when another attempt follows. */
+  readonly retryInMs?: number;
+  /** How this attempt was entered. Absent on the first attempt. */
+  readonly reentry?: DriverReentry['reason'];
+  /** The completion check's verdict after this attempt. Absent when the caller declares none. */
+  readonly contract?: DriverContractState;
+  /** True when this COMPLETED attempt's unmet contract sent the loop back into the live session. */
+  readonly reprompted?: boolean;
+  /** Why an unmet contract did NOT re-enter the session. Absent when the contract was met, when
+   *  the caller configured no re-prompt, or when the re-prompt was issued. */
+  readonly repromptRefusedBy?: DriverRepromptRefusal;
+}
+/** Why a completed drive with an unmet contract was not re-entered. `no-progress` means
+ *  `reprompt.maxBarren` consecutive re-entered drives completed without a delivery. */
+type DriverRepromptRefusal = 'reprompts-exhausted' | 'caller-stop' | Extract<DriverAttemptStop, 'aborted' | 'budget-exhausted' | 'deadline' | 'max-attempts' | 'no-progress'>;
+/** The comparable mark used to decide whether an attempt moved the run TOWARD ITS DELIVERABLE.
+ *  While a declared check is unmet, spend and settlements are not progress on their own; see this
+ *  file's header for the measurement that made that the rule. */
+interface DriverProgressMark {
+  /** Monotone total of POOL spend since the first reading, in tokens — the driver's own metered
+   *  turns AND any child settlement, because the conserved pool is shared. Deliberately not
+   *  driver-only: a child that settled during the attempt is progress by any reading, and the
+   *  coarser signal can only bias toward rescuing a run, never toward abandoning one. */
+  readonly poolTokensSpent: number;
+  /** Monotone count of settled children. */
+  readonly settledCount: number;
+  /** Whether an accepted deliverable exists — a submission that PASSED the completion check. */
+  readonly submitted: boolean;
+  /** The completion check's verdict right now. Omit (or `'none'`) when the caller declares no
+   *  check: the retry then reads spend and settlements exactly as it did before this field
+   *  existed, so a caller with no contract is unaffected. */
+  readonly contract?: DriverContractState;
+  /** Monotone count of settled children that PASSED the completion check. A child that ran and
+   *  settled without delivering does not count here, which is the whole point. */
+  readonly deliveredCount?: number;
+}
+/** Why the loop is entering the driver again. Absent on the first attempt only.
+ *
+ *  An `unmet-contract` re-entry carries the unmet items. A `driver-failure` re-entry carries no
+ *  instruction of its own: the drive that failed may never have read the last one, so the caller
+ *  re-enters with the ORIGINAL task and the run's state, never with the unmet-items text alone. */
+type DriverReentry = {
+  readonly reason: 'unmet-contract';
+  /** The unmet items. Whether they are the whole turn depends on where the drive runs: only a
+   *  backend that proves the same harness session may be re-entered with this text alone. */
+  readonly steer: string;
+  /** 1-based: which re-prompt this is. */
+  readonly reprompt: number;
+} | {
+  readonly reason: 'driver-failure';
+  /** The failure that ended the previous drive, as recorded. */
+  readonly failure: string;
+  /** 1-based: which failure retry this is. */
+  readonly retry: number;
+};
+/** What the caller sees when a drive returns with its completion check unmet. */
+interface DriverUnmetContractContext {
+  /** The attempt that just completed, 1-based. */
+  readonly attempt: number;
+  /** How many re-prompts this run has already issued. */
+  readonly reprompts: number;
+  readonly maxReprompts: DriverRepromptPolicy['maxReprompts'];
+  /** The mark read AFTER the completed drive. */
+  readonly progress: DriverProgressMark;
+  readonly budget: DriverBudgetReadout;
+  /** What the run was supposed to produce, from the caller's completion check. */
+  readonly describe?: string;
+  /** Consecutive re-entered drives, this one included, that completed without a delivery. */
+  readonly barrenReentries: number;
+}
+/** The caller's answer: re-enter the session with `steer`, or end the run here. */
+type DriverUnmetContractDecision = {
+  readonly steer: string;
+} | 'stop';
+/** Compose the re-entry instruction for a completed drive that delivered nothing, or refuse. */
+type OnUnmetContract = (context: DriverUnmetContractContext) => DriverUnmetContractDecision | Promise<DriverUnmetContractDecision>;
+/** How a completed-but-undelivered drive is re-entered. Absent = the historical behavior, where
+ *  such a drive ends the run and only the completion gate's label records what happened. */
+interface DriverRepromptPolicy {
+  /** How many times one run may re-enter its driver with the unmet items. `0` = never.
+   *  `'until-complete'` removes the count cap and requires a finite positive scope deadline.
+   *  Budget, cancellation, explicit stop, the barren bound, and failure retry limits still apply. */
+  readonly maxReprompts: number | 'until-complete';
+  /** Consecutive re-entered drives that may complete without a delivery before re-prompting stops
+   *  (`repromptRefusedBy: 'no-progress'`). Default {@link DEFAULT_MAX_BARREN_REPROMPTS}; minimum 1.
+   *  A delivery — an accepted submission, a child that passed its check, the contract turning
+   *  met — resets the count. */
+  readonly maxBarren?: number;
+  /** Compose the instruction, or return `'stop'`. Omit = {@link defaultUnmetContractSteer}. */
+  readonly onUnmetContract?: OnUnmetContract;
+  /** What the run owes, surfaced in the default instruction. */
+  readonly describe?: string;
+}
+/**
+ * The instruction a completed-but-undelivered drive is re-entered with when the caller supplies no
+ * `onUnmetContract`. It states the verdict, names what is owed, reports the ledger, and gives the
+ * three steps — the same shape `depthStrategy` re-prompts a resumed session with, said in the
+ * driver's own terms.
+ */
+declare function defaultUnmetContractSteer(context: DriverUnmetContractContext): string;
+/** Two re-prompted drives in a row that deliver nothing end the re-prompts. */
+declare const DEFAULT_MAX_BARREN_REPROMPTS = 2;
+/**
+ * Classify one driver failure. Runtime's own typed refusals are decisions and stay terminal;
+ * anything foreign is an accident and is retryable. A `BackendTransportError` is split by status
+ * because the taxonomy already promises consumers may branch on it: a 5xx/429/408 is the upstream
+ * having a bad moment, while a 401/404/422 is a request that will fail identically forever. The
+ * bridge's own never-retry classes are terminal whether or not a status rides with them.
+ */
+declare function classifyDriverFailure(error: unknown, signal?: AbortSignal): 'transient' | 'terminal';
+/** The error a give-up throws: the original cause, re-described with the attempt history so
+ *  `driver-failed` carries a diagnosable message instead of one backend's last words. */
+declare class DriverAttemptsExhaustedError extends RuntimeRunStateError {
+  readonly attempts: readonly DriverAttemptRecord[];
+  readonly stop: DriverAttemptStop;
+  constructor(cause: unknown, attempts: readonly DriverAttemptRecord[], stop: DriverAttemptStop);
+}
+/**
+ * What one driver loop did, counted from its attempt records: the numbers a run's settle record
+ * carries so a reader can tell genuine continuations from failure retries without the journal.
+ *
+ * Measured motive: the most genuine continuations in any recorded lab run was 11
+ * (evidence-compiler-j, which won), while the two larger counts, 32 and 12, were re-entries after
+ * failed turns. One `attempts` number hid which was which.
+ */
+interface DriverLoopRecord {
+  /** Driver invocations started. */
+  readonly attempts: number;
+  /** Genuine continuations: completed drives with the contract unmet that were re-entered. */
+  readonly reprompts: number;
+  /** Re-entries after a failed drive. */
+  readonly failureRetries: number;
+  /** Re-entered drives, in a row at the end, that completed without a delivery. */
+  readonly barrenReentries: number;
+  /** Why the loop ended: its last record's stop, or `unrecorded` when it ended without one (an
+   *  admission refusal before the first attempt, or a throw from outside the loop). */
+  readonly ended: DriverAttemptStop | 'unrecorded';
+  /** Why a completed-but-unmet drive was not re-entered, when that ended the loop. */
+  readonly repromptRefusedBy?: DriverRepromptRefusal;
+}
+/** A manager's driver loop as its run's settle record carries it (`SupervisedResult.continuation`). */
+interface DriverContinuationRecord extends DriverLoopRecord {
+  /** Re-entries that ran in a new environment because the provider no longer held the old one. */
+  readonly environmentReplacements: number;
+  /** How the run was closed, when something closed it: an accepted `submit_result`, the
+   *  manager's own `stop`, a `report_blocked` whose probe failed, or the caller's progress
+   *  `stopRule`. Absent when the loop ended on a bound or a failure. */
+  readonly closedBy?: 'result-accepted' | 'stop' | 'blocked' | 'stop-rule';
+  /** The reason the manager gave, or the failed probe, verbatim. */
+  readonly stopReason?: string;
+}
+/** Count a loop's attempt records into its {@link DriverLoopRecord}. */
+declare function summarizeDriverAttempts(records: ReadonlyArray<DriverAttemptRecord>): DriverLoopRecord;
+//#endregion
 //#region src/runtime/harness-transcript.d.ts
 declare const HARNESS_TRANSCRIPT_SCHEMA_VERSION: 1;
 interface HarnessTranscriptFile {
@@ -3521,6 +3859,10 @@ interface SpawnOpts {
    * (`'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
+   *  whose work. The caller asserts the relation; the coordination `spawn_worker` tool admits only
+   *  a settled worker of the same manager. Journaled on `spawned` and on the `agent.spawn` hook. */
+  readonly successorOf?: NodeId;
 }
 /** Fail-closed spawn rejections: an exhausted pool, a dollar request against a root that budgets
  *  no dollars, an exceeded recursion ceiling, a full tree-wide worker allocation, a `key` that is
@@ -3939,8 +4281,17 @@ type SpawnEvent = {
   key?: string;
   /** Manager-scoped assignment identity used to join unkeyed and keyed work alike. */
   assignmentId?: string;
+  /** The settled sibling node this spawn replaces (`SpawnOpts.successorOf`). */
+  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. */
+  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,
    * including records written before this field existed and caller leaves named `driver`. */
@@ -4357,6 +4708,12 @@ interface Supervisor<Task, Out> {
   run(root: Agent<Task, Out>, task: Task, opts: SupervisorOpts): Promise<SupervisedResult<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`. */
+interface RecursiveReservationPolicy {
+  readonly ownerShare: number;
+}
 interface SupervisorOpts {
   /** The root conserved-pool ceiling (tokens + usd + iterations + deadline). */
   readonly budget: Budget;
@@ -4384,6 +4741,9 @@ interface SupervisorOpts {
   /** 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. */
+  readonly reservationPolicy?: RecursiveReservationPolicy;
   /**
    * OTP intensity breaker: more than `maxRestarts` child restarts within `withinMs`
    * trips the supervisor to `no-winner` rather than restarting forever.
@@ -4643,6 +5003,10 @@ type SupervisedResult<Out> = {
   readonly rootProviderModel?: RootProviderModelEvidence;
   /** The root manager's retained provider stream, when the run directory holds one. */
   readonly rootStream?: RootStreamReceipt;
+  /** What the root's external driver loop did: genuine continuations, failure retries,
+   *  environment replacements, why the loop ended, and how the root closed the run. Absent for
+   *  a router-brained root, which runs no driver loop. */
+  readonly continuation?: DriverContinuationRecord;
   /** Runtime-owned provider evidence reduced across the complete journal forest. */
   readonly providerModel?: ProviderModelExecutionEvidence;
   /** Settled children whose teardown stayed unconfirmed after the settlement retry window
@@ -4686,6 +5050,10 @@ type SupervisedResult<Out> = {
   readonly rootProviderModel?: RootProviderModelEvidence;
   /** The root manager's retained provider stream, when the run directory holds one. */
   readonly rootStream?: RootStreamReceipt;
+  /** What the root's external driver loop did: genuine continuations, failure retries,
+   *  environment replacements, why the loop ended, and how the root closed the run. Absent for
+   *  a router-brained root, which runs no driver loop. */
+  readonly continuation?: DriverContinuationRecord;
   /** Runtime-owned provider evidence reduced across the complete journal forest. */
   readonly providerModel?: ProviderModelExecutionEvidence;
   /** Settled children whose teardown stayed unconfirmed after the settlement retry window
@@ -4752,6 +5120,10 @@ type SupervisedResult<Out> = {
   readonly rootProviderModel?: RootProviderModelEvidence;
   /** The root manager's retained provider stream, when the run directory holds one. */
   readonly rootStream?: RootStreamReceipt;
+  /** What the root's external driver loop did: genuine continuations, failure retries,
+   *  environment replacements, why the loop ended, and how the root closed the run. Absent for
+   *  a router-brained root, which runs no driver loop. */
+  readonly continuation?: DriverContinuationRecord;
   /** Runtime-owned provider evidence reduced across the complete journal forest. */
   readonly providerModel?: ProviderModelExecutionEvidence;
   /** Settled children whose teardown stayed unconfirmed after the settlement retry window
@@ -4820,5 +5192,5 @@ interface WidenGate<Out> {
   readonly judgeExempt?: boolean;
 }
 //#endregion
-export { SpawnOpts as $, ReadableEnvironment as $n, LoopPlanDescription as $r, RuntimeEventCollector as $t, NodeExecutionIdentity as A, AgentRuntimeEvent as Ai, RetainedChildRecovery as An, BudgetPool as Ar, traceContextToEnv as At, ResumedKeyState as B, OpenAIChatToolChoice as Bi, ReconnectRetainedInteractiveRunOptions as Bn, createBudgetPool as Br, OtelSpan as Bt, ExecutorToolCall as C, RuntimeRunStatus as Ci, SessionMessageLike as Cn, RetainedRunIntentAdmission as Cr, workerTraceEnv as Ct, MaterializedExecutionIdentity as D, AgentBackendInput as Di, createPushTraceSource as Dn, RetainedRunTurnInput as Dr, createPropagatingTraceEmitter as Dt, HeldEnvironment as E, AgentBackendContext as Ei, TraceSource as En, RetainedRunStartMaterial as Er, TraceContext as Et, ProviderModelAttemptEvidence as F, AgentTaskStatus as Fi, ExecutorProgress as Fn, ReservationHolder as Fr, INTELLIGENCE_WIRE_VERSION as Ft, RootProviderModelEvidence as G, RuntimeSessionStore as Gi, RetainedInteractiveStartMaterial as Gn, ExecCtx as Gr, createOpenInferenceFileExporter as Gt, RetainedExecutionState as H, RunAgentTaskStreamOptions as Hi, RetainedInteractiveAdmissionHook as Hn, AgentRunSpec as Hr, buildLoopOtelSpans as Ht, ProviderModelExecutionEvidence as I, BackendErrorDetail as Ii, ScopeProgressInput as In, ReservationRejection as Ir, LoopSpanNode as It, Runtime as J, HarnessTranscriptCapture as Jn, LoopEndedPayload as Jr, generateSpanId as Jt, RootSignal as K, RuntimeStreamEvent as Ki, StartRetainedInteractiveRunOptions as Kn, Iteration as Kr, createOtelExporter as Kt, ResourceLimit as L, KnowledgeReadinessDecision as Li, WorkerProgress as Ln, ReservationShortfall as Lr, OtelAttribute as Lt, NodeSnapshot as M, AgentTaskContext as Mi, ActivityLog as Mn, BudgetReadout as Mr, EvalRunGeneration as Mt, NodeStatus as N, AgentTaskRunResult as Ni, ActivityNote as Nn, BudgetReconcileFault as Nr, EvalRunsExportConfig as Nt, MaterializedModelIdentity as O, AgentExecutionBackend as Oi, decodeToolPart as On, StartRetainedRunInEnvironmentOptions as Or, mergeTraceEnv as Ot, ProfileMaterializationReceipt as P, AgentTaskSpec as Pi, DEFAULT_STALL_AFTER_MS as Pn, LeakedReservation as Pr, EvalRunsExportResult as Pt, SpawnJournal as Q, HarnessTranscriptUnavailableReason as Qn, LoopLineageOptions as Qr, toOtelAttributes as Qt, ResourceSpend as R, OpenAIChatResponseFormat as Ri, createActivityLog as Rn, ReservationStage as Rr, OtelExportConfig as Rt, ExecutorTeardownWarning as S, RuntimeRunRow as Si, waitUntil as Sn, RetainedRunHandle as Sr, readWorkerTraceContext as St, Handle as T, AgentAdapter as Ti, ToolStepInput as Tn, RetainedRunSnapshot as Tr, workerTraceSeamKey as Tt, RootHandle as U, RuntimeCanonicalStreamEvent as Ui, RetainedInteractiveEnvironmentInput as Un, DefaultVerdict$1 as Ur, buildLoopSpanNodes as Ut, ResumedWork as V, RunAgentTaskOptions as Vi, RecoverRetainedInteractiveRunOptions as Vn, spendFromUsageEvents as Vr, RuntimeEventOtelOptions as Vt, RootMaterialization as W, RuntimeSession as Wi, RetainedInteractiveRunHandle as Wn, Driver as Wr, buildRuntimeEventOtelSpans as Wt, Settled as X, HarnessTranscriptFile as Xn, LoopIterationEndedPayload as Xr, padSpanId as Xt, Scope as Y, HarnessTranscriptEvidence as Yn, LoopIterationDispatchPayload as Yr, loopEventToOtelSpan as Yt, SpawnEvent as Z, HarnessTranscriptUnavailable as Zn, LoopIterationStartedPayload as Zr, padTraceId as Zt, ExecutorMaterialization as _, RuntimeRunCompleteInput as _i, createWaitProbes as _n, RetainedRunCancellation as _r, WorkerInteractiveUnavailableReason as _t, BudgetOverspend as a, LoopTokenUsage as ai, SanitizedKnowledgeRequirement as an, NativeContextContinuationInput as ar, SteerableRootHandle as at, ExecutorRegistry as b, RuntimeRunOptions as bi, timerAt as bn, RetainedRunEnvironmentAdmission as br, WorkerTraceResolver as bt, EnvironmentTeardownReceipt as c, LoopWinner as ci, sanitizeAgentRuntimeEvent as cn, RecoverRetainedRunOptions as cr, SupervisorOpts as ct, ExecutorAccounting as d, OutputAdapter as di, PendingWait as dn, RetainedInteractiveEnvironmentAdmission as dr, UnconfirmedTeardown as dt, LoopPlanPayload as ei, RuntimeStreamEventCollector as en, captureHarnessTranscript as er, SpawnPrior as et, ExecutorCancellation as f, RunProvenance as fi, WaitOutcome as fn, RetainedInteractiveIntentAdmission as fr, UnknownMaterializationReason as ft, ExecutorFactory as g, Validator as gi, WaitSpec as gn, RetainedRunCancelOptions as gr, WorkerInteractiveSession as gt, ExecutorExecutionBinding as h, ValidationCtx as hi, WaitRejection as hn, RetainedRunAdmissionHook as hr, WidenGate as ht, Budget as i, LoopTeardownFailedPayload as ii, SanitizedKnowledgeReadinessReport as in, NativeContextContinuationHandle as ir, SpendGap as it, NodeId as j, AgentRuntimeEventSink as ji, RetainedPendingCause as jn, BudgetPoolRestore as jr, EvalRunEvent as jt, NoWinnerError as k, AgentKnowledgeProvider as ki, sandboxSessionTraceSource as kn, StartRetainedRunOptions as kr, readTraceContextFromEnv as kt, ExecutionBindingReceipt as l, MountManifestEntry as li, sanitizeKnowledgeReadinessReport as ln, RecoverRetainedRunResult as lr, TokenUsageProvenance as lt, ExecutorContext as m, SelectionReceipt as mi, WaitProbeRegistry as mn, RetainedRunAdmission as mr, WaitOpts as mt, AgentExecutionRef as n, LoopSandboxPlacement as ni, RuntimeStreamEventSummary as nn, persistHarnessTranscript as nr, Spend as nt, BudgetViolation as o, LoopTraceEmitter as oi, createRuntimeEventCollector as on, ReconnectRetainedRunOptions as or, SupervisedResult as ot, ExecutorCancellationRequest as p, SandboxClient as pi, WaitProbe as pn, RetainedInteractiveStartedAdmission as pr, UsageEvent as pt, RootStreamReceipt as q, HarnessTranscriptArtifact as qn, LoopDecisionPayload as qr, exportEvalRuns as qt, AgentSpec as r, LoopStartedPayload as ri, RuntimeTelemetryOptions as rn, NativeContextContinuationExecution as rr, SpendChannel as rt, DefaultVerdict as s, LoopTraceEvent as si, createRuntimeStreamEventCollector as sn, RecoverRetainedRunIntentOptions as sr, Supervisor as st, Agent as t, LoopResult as ti, RuntimeStreamEventSink as tn, harnessTranscriptArtifact as tr, SpawnRejection as tt, Executor as u, MountRecorder as ui, sanitizeRuntimeStreamEvent as un, RetainedInteractiveAdmission as ur, TreeView as ut, ExecutorNodeContext as v, RuntimeRunCost as vi, isWaitOutcome as vn, RetainedRunDispatchedAdmission as vr, WorkerTraceEvidence as vt, FleetYield as w, startRuntimeRun as wi, SessionTraceBox as wn, RetainedRunReplayPoint as wr, workerTraceHeaders as wt, ExecutorResult as x, RuntimeRunPersistenceAdapter as xi, validateWaitSpec as xn, RetainedRunEventOptions as xr, WorkerTraceSeamCarrier as xt, ExecutorProgressEvent as y, RuntimeRunHandle as yi, pollFor as yn, RetainedRunEffect as yr, WorkerTraceUnavailableReason as yt, ResultBlobStore as z, OpenAIChatTool as zi, readWorkerProgress as zn, ReservationTicket as zr, OtelExporter as zt };
-//# sourceMappingURL=types-ChewVlpE.d.ts.map
+export { SpawnJournal as $, RuntimeRunOptions as $i, HarnessTranscriptUnavailableReason as $n, RetainedRunEnvironmentAdmission as $r, toOtelAttributes as $t, NodeExecutionIdentity as A, LoopIterationStartedPayload as Ai, sandboxSessionTraceSource as An, RetainedInteractiveAdmissionError as Ar, readTraceContextFromEnv as At, ResultBlobStore as B, LoopTraceEvent as Bi, readWorkerProgress as Bn, RecoverRetainedRunIntentOptions as Br, OtelExporter as Bt, ExecutorToolCall as C, RuntimeSession as Ca, Driver as Ci, waitUntil as Cn, AgentEvalError$1 as Cr, readWorkerTraceContext as Ct, MaterializedExecutionIdentity as D, LoopEndedPayload as Di, TraceSource as Dn, JudgeError as Dr, TraceContext as Dt, HeldEnvironment as E, LoopDecisionPayload as Ei, ToolStepInput as En, ConfigError as Er, workerTraceSeamKey as Et, ProviderModelAttemptEvidence as F, LoopSandboxPlacement as Fi, DEFAULT_STALL_AFTER_MS as Fn, ValidationError as Fr, EvalRunsExportResult as Ft, RootMaterialization as G, RunProvenance as Gi, RetainedInteractiveRunHandle as Gn, RetainedInteractiveIntentAdmission as Gr, buildRuntimeEventOtelSpans as Gt, ResumedWork as H, MountManifestEntry as Hi, RecoverRetainedInteractiveRunOptions as Hn, RecoverRetainedRunResult as Hr, RuntimeEventOtelOptions as Ht, ProviderModelExecutionEvidence as I, LoopStartedPayload as Ii, ExecutorProgress as In, NativeContextContinuationExecution as Ir, INTELLIGENCE_WIRE_VERSION as It, RootStreamReceipt as J, ValidationCtx as Ji, HarnessTranscriptArtifact as Jn, RetainedRunAdmissionHook as Jr, exportEvalRuns as Jt, RootProviderModelEvidence as K, SandboxClient as Ki, RetainedInteractiveStartMaterial as Kn, RetainedInteractiveStartedAdmission as Kr, createOpenInferenceFileExporter as Kt, RecursiveReservationPolicy as L, LoopTeardownFailedPayload as Li, ScopeProgressInput as Ln, NativeContextContinuationHandle as Lr, LoopSpanNode as Lt, NodeSnapshot as M, LoopPlanDescription as Mi, RetainedPendingCause as Mn, RetainedRunAdmissionError as Mr, EvalRunEvent as Mt, NodeStatus as N, LoopPlanPayload as Ni, ActivityLog as Nn, RetainedRunDispatchBindingError as Nr, EvalRunGeneration as Nt, MaterializedModelIdentity as O, LoopIterationDispatchPayload as Oi, createPushTraceSource as On, NotFoundError as Or, createPropagatingTraceEmitter as Ot, ProfileMaterializationReceipt as P, LoopResult as Pi, ActivityNote as Pn, RuntimeRunStateError as Pr, EvalRunsExportConfig as Pt, SpawnEvent as Q, RuntimeRunHandle as Qi, HarnessTranscriptUnavailable as Qn, RetainedRunEffect as Qr, padTraceId as Qt, ResourceLimit as R, LoopTokenUsage as Ri, WorkerProgress as Rn, NativeContextContinuationInput as Rr, OtelAttribute as Rt, ExecutorTeardownWarning as S, RuntimeCanonicalStreamEvent as Sa, DefaultVerdict$1 as Si, validateWaitSpec as Sn, summarizeDriverAttempts as Sr, WorkerTraceSeamCarrier as St, Handle as T, RuntimeStreamEvent as Ta, Iteration as Ti, SessionTraceBox as Tn, BackendTransportError as Tr, workerTraceHeaders as Tt, RetainedExecutionState as U, MountRecorder as Ui, RetainedInteractiveAdmissionHook as Un, RetainedInteractiveAdmission as Ur, buildLoopOtelSpans as Ut, ResumedKeyState as V, LoopWinner as Vi, ReconnectRetainedInteractiveRunOptions as Vn, RecoverRetainedRunOptions as Vr, OtelSpan as Vt, RootHandle as W, OutputAdapter as Wi, RetainedInteractiveEnvironmentInput as Wn, RetainedInteractiveEnvironmentAdmission as Wr, buildLoopSpanNodes as Wt, Scope as X, RuntimeRunCompleteInput as Xi, HarnessTranscriptEvidence as Xn, RetainedRunCancellation as Xr, loopEventToOtelSpan as Xt, Runtime as Y, Validator as Yi, HarnessTranscriptCapture as Yn, RetainedRunCancelOptions as Yr, generateSpanId as Yt, Settled as Z, RuntimeRunCost as Zi, HarnessTranscriptFile as Zn, RetainedRunDispatchedAdmission as Zr, padSpanId as Zt, ExecutorMaterialization as _, OpenAIChatResponseFormat as _a, ReservationStage as _i, WaitSpec as _n, DriverUnmetContractContext as _r, WorkerInteractiveSession as _t, BudgetOverspend as a, AgentBackendContext as aa, RetainedRunStartMaterial as ai, SanitizedKnowledgeReadinessReport as an, DriverAttemptRecord as ar, SpendGap as at, ExecutorRegistry as b, RunAgentTaskOptions as ba, spendFromUsageEvents as bi, pollFor as bn, classifyDriverFailure as br, WorkerTraceUnavailableReason as bt, EnvironmentTeardownReceipt as c, AgentKnowledgeProvider as ca, StartRetainedRunOptions as ci, createRuntimeStreamEventCollector as cn, DriverBudgetReadout as cr, Supervisor as ct, ExecutorAccounting as d, AgentTaskContext as da, BudgetReadout as di, sanitizeRuntimeStreamEvent as dn, DriverLoopRecord as dr, TreeView as dt, RuntimeRunPersistenceAdapter as ea, RetainedRunEventOptions as ei, RuntimeEventCollector as en, ReadableEnvironment as er, SpawnOpts as et, ExecutorCancellation as f, AgentTaskRunResult as fa, BudgetReconcileFault as fi, PendingWait as fn, DriverProgressMark as fr, UnconfirmedTeardown as ft, ExecutorFactory as g, KnowledgeReadinessDecision as ga, ReservationShortfall as gi, WaitRejection as gn, DriverRetryPolicy as gr, WidenGate as gt, ExecutorExecutionBinding as h, BackendErrorDetail as ha, ReservationRejection as hi, WaitProbeRegistry as hn, DriverRepromptRefusal as hr, WaitOpts as ht, Budget as i, AgentAdapter as ia, RetainedRunSnapshot as ii, RuntimeTelemetryOptions as in, DEFAULT_MAX_BARREN_REPROMPTS as ir, SpendChannel as it, NodeId as j, LoopLineageOptions as ji, RetainedChildRecovery as jn, RetainedInteractiveBindingError as jr, traceContextToEnv as jt, NoWinnerError as k, LoopIterationEndedPayload as ki, decodeToolPart as kn, PlannerError as kr, mergeTraceEnv as kt, ExecutionBindingReceipt as l, AgentRuntimeEvent as la, BudgetPool as li, sanitizeAgentRuntimeEvent as ln, DriverContinuationRecord as lr, SupervisorOpts as lt, ExecutorContext as m, AgentTaskStatus as ma, ReservationHolder as mi, WaitProbe as mn, DriverRepromptPolicy as mr, UsageEvent as mt, AgentExecutionRef as n, RuntimeRunStatus as na, RetainedRunIntentAdmission as ni, RuntimeStreamEventSink as nn, harnessTranscriptArtifact as nr, SpawnRejection as nt, BudgetViolation as o, AgentBackendInput as oa, RetainedRunTurnInput as oi, SanitizedKnowledgeRequirement as on, DriverAttemptStop as or, SteerableRootHandle as ot, ExecutorCancellationRequest as p, AgentTaskSpec as pa, LeakedReservation as pi, WaitOutcome as pn, DriverReentry as pr, UnknownMaterializationReason as pt, RootSignal as q, SelectionReceipt as qi, StartRetainedInteractiveRunOptions as qn, RetainedRunAdmission as qr, createOtelExporter as qt, AgentSpec as r, startRuntimeRun as ra, RetainedRunReplayPoint as ri, RuntimeStreamEventSummary as rn, persistHarnessTranscript as rr, Spend as rt, DefaultVerdict as s, AgentExecutionBackend as sa, StartRetainedRunInEnvironmentOptions as si, createRuntimeEventCollector as sn, DriverAttemptsExhaustedError as sr, SupervisedResult as st, Agent as t, RuntimeRunRow as ta, RetainedRunHandle as ti, RuntimeStreamEventCollector as tn, captureHarnessTranscript as tr, SpawnPrior as tt, Executor as u, AgentRuntimeEventSink as ua, BudgetPoolRestore as ui, sanitizeKnowledgeReadinessReport as un, DriverContractState as ur, TokenUsageProvenance as ut, ExecutorNodeContext as v, OpenAIChatTool as va, ReservationTicket as vi, createWaitProbes as vn, DriverUnmetContractDecision as vr, WorkerInteractiveUnavailableReason as vt, FleetYield as w, RuntimeSessionStore as wa, ExecCtx as wi, SessionMessageLike as wn, AgentEvalErrorCode as wr, workerTraceEnv as wt, ExecutorResult as x, RunAgentTaskStreamOptions as xa, AgentRunSpec as xi, timerAt as xn, defaultUnmetContractSteer as xr, WorkerTraceResolver as xt, ExecutorProgressEvent as y, OpenAIChatToolChoice as ya, createBudgetPool as yi, isWaitOutcome as yn, OnUnmetContract as yr, WorkerTraceEvidence as yt, ResourceSpend as z, LoopTraceEmitter as zi, createActivityLog as zn, ReconnectRetainedRunOptions as zr, OtelExportConfig as zt };
+//# sourceMappingURL=types-CP3iQ8Ji.d.ts.map