@tangle-network/agent-runtime 0.266.0 → 0.273.3

package/dist/{types-CrnwLVYQ.d.ts → types-DMRc3jru.d.ts}

@@ -1998,6 +1998,322 @@ declare class RetainedRunDispatchBindingError extends AgentEvalError {
   });
 }
 //#endregion
+//#region src/runtime/supervise/continuation.d.ts
+/**
+ * One reading of a completion check.
+ *
+ * A check program prints an agent-eval `JudgeScore`; {@link verdictFromJudgeScore} reads it into
+ * this shape. A plain boolean check is a verdict with no items.
+ */
+interface CheckVerdict {
+  /** Whether the check accepts the result. */
+  readonly pass: boolean;
+  /** Every item the check read, by name: 1 when it passes, lower when it does not. The
+   *  `JudgeScore.dimensions` of the check program. */
+  readonly items?: Readonly<Record<string, number>>;
+  /** The check's score. */
+  readonly composite?: number;
+  /** The pass threshold on `composite`, when the check has one. */
+  readonly threshold?: number;
+  /** One `FAIL <item> <where>: <reason>` line per failed item, in the check's order. */
+  readonly failures?: ReadonlyArray<string>;
+  /** The check's prose review of the result, when it writes one. */
+  readonly review?: string;
+}
+/**
+ * The check could not run: its box did not start, its judge's provider refused, its program
+ * crashed. It is not a verdict on the result. Inside a run the loop pauses, as it does for an
+ * unavailable upstream, and the refusal tells the director its result was not judged.
+ */
+declare class CheckUnavailableError extends Error {
+  constructor(message: string, options?: {
+    readonly cause?: unknown;
+  });
+}
+/** Read a check function's return value into a verdict. Anything but `true` or a passing verdict
+ *  is a failure: a check fails closed. */
+declare function checkVerdictOf(outcome: unknown): CheckVerdict;
+/**
+ * Read an agent-eval `JudgeScore` from a check program into a verdict.
+ *
+ * Each dimension is a checked item. `notes` lines that start with `FAIL ` are the failures; the
+ * remaining lines are the check's review. The verdict passes when `composite >= threshold` and the
+ * score is not marked `failed`; a `failed` score means the judge itself did not run, which is
+ * {@link CheckUnavailableError}, not a verdict.
+ */
+declare function verdictFromJudgeScore(score: {
+  readonly dimensions: Readonly<Record<string, number>>;
+  readonly composite: number;
+  readonly notes: string;
+  readonly failed?: true;
+}, threshold: number): CheckVerdict;
+/** Items that fail in `verdict`: every item below 1, or the named items of its FAIL lines. */
+declare function failedItems(verdict: CheckVerdict): ReadonlyArray<string>;
+/** Items that pass in `verdict`. */
+declare function passedItems(verdict: CheckVerdict): ReadonlyArray<string>;
+/** One time the check ran inside the run, whatever started it. */
+interface CheckRead {
+  /** 1-based count of check reads in this manager, the unavailable ones included. */
+  readonly read: number;
+  /** The driver attempt the read belongs to. */
+  readonly attempt: number;
+  /** Epoch ms. */
+  readonly at: number;
+  /** `submit`: a `submit_result` call. `turn-end`: the turn ended with no accepted result. */
+  readonly source: 'submit' | 'turn-end';
+  /** Absent when the check could not run. */
+  readonly verdict?: CheckVerdict;
+  /** Why the check could not run. */
+  readonly unavailable?: string;
+}
+/**
+ * How a manager with a completion check is sent back when its turn ends unmet.
+ *
+ * Required for an external manager with a check: Runtime supplies no default, because a retry
+ * default in source is a research decision the record must make. There is no re-prompt count.
+ * The loop re-enters until the check passes, `report_blocked` ends the run, or a bound ends it:
+ * this deadline, the budget, `maxBarren` turns in a row without progress, or cancellation.
+ * Progress means the check's best composite rose, an accepted result, or a worker that delivered.
+ */
+interface ContinuationPolicy {
+  /** No re-entry starts at or after this instant: epoch ms, or an ISO 8601 time. */
+  readonly deadline: number | string;
+  /** Re-entered turns in a row that may end without progress before the run ends. Minimum 1.
+   *  The evidence for 2: repair loses most of its effect within two or three attempts, and a
+   *  fresh start at the same budget scored higher (Debugging Decay Index). */
+  readonly maxBarren: number;
+  /** Every instruction word of the note. */
+  readonly profile: ContinuationProfile;
+  /** `verbatim` sends the check's FAIL lines, the protected items, and what changed. A check with
+   *  `feedback: 'pass-only'` overrides this to `off`. */
+  readonly failures: 'verbatim' | 'off';
+  /** `on` runs the question panel at each continuation and puts its admitted findings in the note.
+   *  Requires `runPanel`. */
+  readonly panel: 'on' | 'off';
+  /** `on` states the bar: every check item with its state, the best version's verdict and the
+   *  gap, the reference result, and the check's review. */
+  readonly bar: 'on' | 'off';
+  /** The play's registered reference result, for the bar. */
+  readonly reference?: string;
+  /** The best version's verdict on the same check, for the bar. The version loop sets it. */
+  readonly best?: {
+    readonly label: string;
+    readonly verdict: CheckVerdict;
+  };
+  /** The panel's dollar caps. Required with `panel: 'on'`. */
+  readonly panelUsd?: {
+    readonly perContinuation: number;
+    readonly perRun: number;
+  };
+  /** The question panel. Required with `panel: 'on'`. */
+  readonly runPanel?: ContinuationPanel;
+  /** A play's own section, appended after Runtime's sections. It cannot remove or rewrite one. */
+  readonly append?: ContinuationAppend;
+}
+/** Resolve and check a policy before any compute. Returns the deadline in epoch ms. */
+declare function admitContinuationPolicy(policy: ContinuationPolicy, context: string): number;
+/**
+ * Every instruction word of the note. Runtime supplies the facts and their order; this data
+ * supplies the words, so the note can be improved (by a person, reflection, or GEPA) without a code
+ * change. Templates may name the facts in {@link CONTINUATION_FACTS} as `{name}`.
+ */
+interface ContinuationProfile {
+  /** Recorded with every note, so each continuation names the words it carried. */
+  readonly id: string;
+  /** Section 1, the verdict. The first line should state the failure as a fact. */
+  readonly opening: string;
+  /** Section 7: what to do before the next submit. */
+  readonly plan: string;
+  /** Section 8: what the harness enforces, and the honest exit. */
+  readonly rules: string;
+  /** Section headings; an empty heading prints the section without one. */
+  readonly headings: {
+    readonly failures: string;
+    readonly protected: string;
+    readonly changed: string;
+    readonly findings: string;
+    readonly bar: string;
+    readonly plan: string;
+    readonly rules: string;
+  };
+  /** The bar's standing instruction, printed under its heading. */
+  readonly barRule?: string;
+  /** The panel's question templates. `{item}` expands over failed items and `{worker}` over
+   *  settled workers; a template with neither is asked once. */
+  readonly questions?: ReadonlyArray<string>;
+  /** The panel's model, when the profile chooses one. */
+  readonly panelModel?: string;
+  /** What a new version's director reads about the best version's review, for the version
+   *  chain's `'review-of-best'`. It may name `{version}`, `{path}` and `{score}`. */
+  readonly review?: string;
+}
+/** The facts a profile template may name. */
+declare const CONTINUATION_FACTS: readonly ["composite", "threshold", "failed", "total", "reads", "owed", "settled", "delivered", "continuation"];
+/** What the question panel reads for one continuation. */
+interface ContinuationPanelInput {
+  /** 1-based continuation number. */
+  readonly continuation: number;
+  readonly task: unknown;
+  /** The check's verdict this note reports; absent when no result reached the check. */
+  readonly verdict?: CheckVerdict;
+  /** Every check read so far, oldest first. */
+  readonly reads: ReadonlyArray<CheckRead>;
+  /** The expanded questions, one per atomic question. */
+  readonly questions: ReadonlyArray<string>;
+  /** `<runDir>/root-stream.jsonl`, the director's own trace, when the run has a directory. */
+  readonly rootStreamPath?: string;
+  /** Settled workers, with the evidence reference their trace is read from. */
+  readonly workers: ReadonlyArray<{
+    readonly id: string;
+    readonly label: string;
+  }>;
+  readonly bar?: ContinuationPolicy['best'];
+  readonly reference?: string;
+  /** The dollars this panel call may spend. */
+  readonly usdCap: number;
+  readonly signal: AbortSignal;
+}
+/** One answer the panel proposes for the note. */
+interface PanelFinding {
+  readonly question: string;
+  /** The finding, stated as a claim about the run. */
+  readonly claim: string;
+  /** Every `trace://` citation in the answer, and whether the trace store holds it. */
+  readonly citations: ReadonlyArray<{
+    readonly uri: string;
+    readonly resolved: boolean;
+  }>;
+  /** Whether an independent verifier, shown only the cited spans, agreed with the claim. */
+  readonly verified: boolean;
+  /** The failed check items the finding explains, when it names any. */
+  readonly items?: ReadonlyArray<string>;
+}
+interface ContinuationPanelResult {
+  readonly findings: ReadonlyArray<PanelFinding>;
+  /** Dollars spent; `null` when the provider reported no cost. Unknown is never zero. */
+  readonly usd: number | null;
+  /** Provider receipts, recorded verbatim in `panel.jsonl`. */
+  readonly receipts?: unknown;
+}
+/** Ask the panel's questions over the run's own traces. */
+type ContinuationPanel = (input: ContinuationPanelInput) => Promise<ContinuationPanelResult>;
+/** A play's own section for one note. Return `undefined` to add nothing this time. */
+type ContinuationAppend = (context: {
+  readonly continuation: number;
+  readonly verdict?: CheckVerdict;
+  readonly reads: ReadonlyArray<CheckRead>;
+  readonly signal: AbortSignal;
+}) => Promise<{
+  readonly heading: string;
+  readonly text: string;
+} | undefined>;
+/** A finding that reached the note, with the continuation that admitted it. */
+interface AdmittedFinding extends PanelFinding {
+  readonly admittedAt: number;
+  /** Set once every item the finding named passes. */
+  readonly resolvedAt?: number;
+}
+/** Findings reach the note only when every citation resolves, at least two distinct spans are
+ *  cited, and the independent verifier agreed. The best method in Who&When found the failing step
+ *  14.2% of the time, so an unverified finding is noise with a citation. */
+declare function admitFinding(finding: PanelFinding): boolean;
+/**
+ * Rank the admitted findings by how many failed items they explain, drop repeats, and keep them
+ * within the note's cap. Earlier findings stay as they were written (ACE: itemized additions keep
+ * detail that repeated rewrites lose); a finding whose items all pass now is marked resolved.
+ */
+declare function distillFindings(prior: ReadonlyArray<AdmittedFinding>, proposed: ReadonlyArray<PanelFinding>, failing: ReadonlySet<string>, continuation: number): ReadonlyArray<AdmittedFinding>;
+/** Expand the profile's question templates over the failed items and the settled workers. */
+declare function expandQuestions(templates: ReadonlyArray<string>, failing: ReadonlyArray<string>, workers: ReadonlyArray<{
+  readonly id: string;
+  readonly label: string;
+}>): ReadonlyArray<string>;
+/** The facts one note is written from. */
+interface ContinuationNoteInput {
+  readonly profile: ContinuationProfile;
+  /** 1-based. */
+  readonly continuation: number;
+  /** The verdict this turn ended on; absent when no result has reached the check. */
+  readonly verdict?: CheckVerdict;
+  /** The verdict the previous note reported, for what changed. */
+  readonly previous?: CheckVerdict;
+  /** Check reads so far, the unavailable ones included. */
+  readonly reads: number;
+  /** `verbatim` only when the policy and the check both allow the FAIL lines. */
+  readonly failures: 'verbatim' | 'off';
+  readonly findings?: ReadonlyArray<AdmittedFinding>;
+  readonly bar?: {
+    readonly best?: ContinuationPolicy['best'];
+    readonly reference?: string;
+  };
+  readonly appended?: ReadonlyArray<{
+    readonly heading: string;
+    readonly text: string;
+  }>;
+  /** What the run owes, from the check's description. */
+  readonly owed?: string;
+  readonly progress: DriverProgressMark;
+  /** Whether `read_continuation` is served to this manager. */
+  readonly canReadMore: boolean;
+  /** Whether the check's score comes from cases the director cannot see. */
+  readonly sealed?: boolean;
+}
+/**
+ * Write one continuation note, sections 1 to 8 of docs/38. Section 9, the run's state, is
+ * `composeReentryTask`, which wraps this text. Pure: the same input writes the same note.
+ */
+declare function composeContinuationNote(input: ContinuationNoteInput): string;
+/** One continuation as the settle record carries it (`DriverContinuationRecord.continuations`). */
+interface ContinuationEntry {
+  /** 1-based. */
+  readonly continuation: number;
+  /** The driver attempt whose end this note answered. */
+  readonly attempt: number;
+  /** sha256 of the note's text. */
+  readonly noteDigest: string;
+  readonly profile: string;
+  readonly switches: {
+    readonly failures: 'verbatim' | 'off';
+    readonly panel: 'on' | 'off';
+    readonly bar: 'on' | 'off';
+  };
+  /** The verdict the note reported: `null` when no result had reached the check. */
+  readonly before: VerdictSummary | null;
+  /** The verdict at the director's next turn end: `null` when the run ended first. */
+  readonly after: VerdictSummary | null;
+  /** The panel's part: questions asked, findings admitted, dollars (`null` = unknown). */
+  readonly panel?: {
+    readonly asked: number;
+    readonly proposed: number;
+    readonly admitted: number;
+    readonly usd: number | null;
+  };
+  /** Sections a play appended. */
+  readonly appended: number;
+}
+interface VerdictSummary {
+  readonly pass: boolean;
+  readonly composite?: number;
+  readonly failed?: number;
+  readonly total?: number;
+}
+/** A run directory's continuation files: the root's at `<runDir>/continuations/<n>/`, a nested
+ *  manager's at `<runDir>/continuations/managers/<owner>/<n>/`. */
+declare const CONTINUATIONS_DIR = "continuations";
+/** The readout a continuation is composed from. */
+interface ContinuationContext {
+  /** The attempt that just completed, 1-based. */
+  readonly attempt: number;
+  /** Continuations this run has already sent. */
+  readonly continuations: number;
+  /** The mark read after the completed drive. */
+  readonly progress: DriverProgressMark;
+  readonly budget: DriverBudgetReadout;
+  /** Re-entered drives in a row, this one included, that ended without progress. */
+  readonly barrenReentries: number;
+  readonly signal: AbortSignal;
+}
+//#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
@@ -2059,15 +2375,16 @@ interface DriverAttemptRecord {
   readonly unavailableSignal?: string;
   /** 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. */
+  /** True when this COMPLETED attempt's unmet contract sent the loop back with a continuation. */
   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. */
+   *  the manager has no continuation policy, or when the continuation was sent. */
   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'>;
+ *  `continuation.maxBarren` consecutive re-entered drives completed without progress. `closed`
+ *  means the run was already closed: a failed `report_blocked` probe or a progress stop rule. */
+type DriverRepromptRefusal = 'closed' | 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. */
@@ -2088,19 +2405,22 @@ interface DriverProgressMark {
   /** 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;
+  /** The best composite any check read has scored so far. A rise is progress: the director moved
+   *  the outside check even though it has not passed. */
+  readonly composite?: 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. */
+ *  An `unmet-contract` re-entry carries Runtime's continuation note. 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 note 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. */
+  /** The continuation note. Whether it is 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;
+  /** 1-based: which continuation this is. */
+  readonly continuation: number;
 } | {
   readonly reason: 'driver-failure';
   /** The failure that ended the previous drive, as recorded. */
@@ -2108,61 +2428,15 @@ type DriverReentry = {
   /** 1-based: which failure retry this is. */
   readonly retry: number;
 } | {
-  /** The upstream refused the previous drive for capacity, and the loop paused before this
-   *  one. Re-entered like a failure, with the original task and the run's state. */
+  /** The upstream refused the previous drive for capacity, or the check could not run, and the
+   *  loop paused before this one. Re-entered like a failure, with the original task and the
+   *  run's state. */
   readonly reason: 'upstream-unavailable';
   /** The code or status that classified the refusal, such as `provider_quota_exhausted`. */
   readonly signal: string;
   /** 1-based: which pause this is. */
   readonly pause: 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;
 /**
  * How one driver failure is answered.
  *
@@ -2232,11 +2506,15 @@ 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. */
+   *  manager's own `stop` (served only to a manager with no check), 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;
+  /** Every continuation note this manager was sent, with the check's verdict before and after it.
+   *  Empty for a manager with no check. */
+  readonly continuations: ReadonlyArray<ContinuationEntry>;
 }
 /** Count a loop's attempt records into its {@link DriverLoopRecord}. */
 declare function summarizeDriverAttempts(records: ReadonlyArray<DriverAttemptRecord>): DriverLoopRecord;
@@ -2921,18 +3199,45 @@ interface OtelExportConfig {
   batchSize?: number;
   /** Flush interval ms. Default 5000. */
   flushIntervalMs?: number;
+  /**
+   * Most spans held at once, queued plus in flight. Default 2048, the OpenTelemetry batch
+   * processor's own default. A span that arrives when the queue is full is dropped and counted in
+   * {@link OtelExportStats.dropped}, so a stalled collector costs a bounded amount of memory.
+   */
+  maxQueueSize?: number;
+  /** Milliseconds one POST may take before it is abandoned and its spans count as dropped. Default 10000. */
+  timeoutMs?: number;
   /** Resource attributes stamped on every export. */
   resourceAttributes?: Record<string, string | number | boolean>;
   /** Service name. Default 'agent-runtime'. */
   serviceName?: string;
 }
 interface OtelExporter {
-  /** Export a span. */
+  /** Export a span. Never throws: a sink that cannot take the span counts it as dropped. */
   exportSpan(span: OtelSpan): void;
-  /** Force flush pending spans. */
+  /**
+   * Deliver everything queued so far. Rejects when spans were dropped since the previous `flush`,
+   * naming how many and the last error, because a caller that awaits delivery is owed the answer.
+   */
   flush(): Promise<void>;
-  /** Shutdown cleanly. */
+  /** Stop accepting spans and deliver what is queued. Never rejects. */
   shutdown(): Promise<void>;
+  /** What this sink has delivered and lost so far. */
+  stats(): OtelExportStats;
+}
+/**
+ * Delivery accounting for one exporter. `written + dropped + pending` covers every span handed to
+ * `exportSpan`, so a trace that arrives short can be told apart from a run that emitted less.
+ */
+interface OtelExportStats {
+  /** Spans the sink confirmed: a 2xx collector response, or a completed file append. */
+  written: number;
+  /** Spans lost: refused by the collector, failed in transit, over the queue bound, or unwritable. */
+  dropped: number;
+  /** Spans accepted and not yet written or dropped. */
+  pending: number;
+  /** The most recent failure, when there has been one. */
+  lastError?: string;
 }
 interface OtelSpan {
   traceId: string;
@@ -2978,7 +3283,13 @@ interface OtelAttribute {
  */
 declare function createOpenInferenceFileExporter(filePath: string): OtelExporter;
 /**
- * Create an OTEL exporter. Returns undefined when no endpoint is configured.
+ * Create an OTLP/HTTP exporter. Returns undefined when no endpoint is configured.
+ *
+ * One batch is in flight at a time; spans that arrive meanwhile wait in a queue bounded by
+ * `maxQueueSize`. Every span ends in exactly one of `written` or `dropped`: a non-2xx response, a
+ * network error, a timeout, an OTLP `partialSuccess.rejectedSpans` count and a full queue each count
+ * as drops and set `lastError`. Nothing here throws into the caller's run; `flush()` reports the
+ * loss, the same rule {@link createOpenInferenceFileExporter} follows.
  */
 declare function createOtelExporter(config?: OtelExportConfig): OtelExporter | undefined;
 /**
@@ -4029,10 +4340,14 @@ interface SpawnOpts {
    * idempotent per key: once a child spawned under a key settles `done` — in this process or in a
    * journaled prior one — spawning the same key returns that committed result (`prior.state:
    * 'completed'`) instead of paying for the work again. A key whose prior attempt settled `down`
-   * spawns fresh and says so explicitly (`prior.state: 'retried'`). A key whose prior attempt was
-   * journaled as started but never settled is refused (`'in-doubt'`): the remote execution may
-   * still exist and must be recovered before replacement. A key that is currently LIVE is refused
-   * (`'duplicate-key'`). Unkeyed spawns (the default) are position-identified and always run.
+   * spawns fresh and says so explicitly (`prior.state: 'retried'`); a resume DERIVES that same
+   * `down` for an interrupted `inline` attempt, because an in-process execution cannot outlive
+   * its process — so a worker killed mid-flight under a plain in-process executor retries under
+   * its own key instead of wedging. A key whose un-settled prior attempt may still exist
+   * elsewhere (`sandbox`/`cli`/`router` runtimes) is refused (`'in-doubt'`): the remote execution
+   * may still be running and must be recovered before replacement. A key that is currently LIVE
+   * is refused (`'duplicate-key'`). Unkeyed spawns (the default) are position-identified and
+   * always run.
    */
   readonly key?: string;
   /** The settled sibling node this spawn replaces, so a run's record names which worker took over
@@ -4149,8 +4464,9 @@ type Settled<Out> = {
   budgetViolation?: BudgetViolation;
   /** Present only when this child's provider execution was RETAINED (see
    *  `RetainedExecutionState`); absent on an ordinary down. `'pending'` on the settlement the
-   *  driver receives at the reconcile; `'released'` on the replayed settlement of a node the
-   *  release sweep closed. The driver and every replay reader see the fact the journal
+   *  driver receives at the reconcile; `'released'` or `'release-unconfirmed'` on the
+   *  replayed settlement of a node a final settlement closed. The driver and every replay
+   *  reader see the fact the journal
    *  states, so a reader never splits this population on `reason` text — which is identical
    *  on every one of these children. */
   retainedExecution?: RetainedExecutionState;
@@ -4419,8 +4735,12 @@ interface ResumedKeyState<Out = unknown> {
   /** Identity recorded when this key was first admitted. Every reuse must match it exactly. */
   readonly identity?: NodeExecutionIdentity;
   readonly state: 'completed' | 'down' | 'in-doubt';
-  /** The rehydrated settlement; absent exactly when `state` is `'in-doubt'`. */
+  /** The rehydrated settlement; absent when `state` is `'in-doubt'`, and when `'down'` was
+   * *derived* — the resume itself proved the execution dead (an `inline` runtime cannot outlive
+   * its process), so there is no settlement to rehydrate and `reason` says how it died. */
   readonly settled?: Settled<Out>;
+  /** Why a derived `'down'` state exists. Absent on every state backed by a settlement. */
+  readonly reason?: string;
 }
 interface NodeSnapshot {
   readonly id: NodeId;
@@ -4467,10 +4787,10 @@ interface NodeSnapshot {
   readonly trace?: WorkerTraceEvidence;
   /** Present once a settled node's measured spend exceeded its reservation. */
   readonly budgetViolation?: BudgetViolation;
-  /** Present on a retained child: `'pending'` while its cursor slot is open, `'released'` once
-   *  the release sweep closed it. The live view (`makeTreeView`) and the journal view
-   *  (`materializeTreeView`) state the same fact, so a settle record's `tree` answers the
-   *  retained-vs-down question without the observer journal. */
+  /** Present on a retained child: `'pending'` while its cursor slot is open, `'released'` or
+   *  `'release-unconfirmed'` once a final settlement closed it. The live view (`makeTreeView`)
+   *  and the journal view (`materializeTreeView`) state the same fact, so a settle record's
+   *  `tree` answers the retained-vs-down question without the observer journal. */
   readonly retainedExecution?: RetainedExecutionState;
   /** Why a retained child has no accepted result; see `RetainedPendingCause`. */
   readonly retainedPendingCause?: RetainedPendingCause;
@@ -4585,13 +4905,15 @@ type SpawnEvent = {
   harnessTranscript?: HarnessTranscriptEvidence;
   /** Present when the reconciled spend exceeded the reservation, on either status. */
   budgetViolation?: BudgetViolation;
-  /** Written by the release sweep in the settling process, on the same tree, after every
-   *  `environment-teardown` receipt for the node reads `destroyed: true` and the executor's
-   *  own teardown confirmed — or by `healReleasedSlots` on the next resume, when that process
-   *  died between the last `destroyed: true` receipt and this record: the same builder, `seq`
-   *  and `at`, read from the `reconciled` record, so the bytes are identical either way. A
-   *  `destroyed: false` receipt, an empty receipt set, or a `reconciled` record without
-   *  `settledSeq` leaves the slot open.
+  /** `'released'` is written by the release sweep in the settling process, on the same tree,
+   *  after every `environment-teardown` receipt for the node reads `destroyed: true` and the
+   *  executor's own teardown confirmed — or by `healReleasedSlots` on the next resume, when
+   *  that process died between the last `destroyed: true` receipt and this record: the same
+   *  builder, `seq` and `at`, read from the `reconciled` record, so the bytes are identical
+   *  either way. `'release-unconfirmed'` is written by the same builder at the end of a final
+   *  settlement for every retained node the release could not confirm: a `destroyed: false`
+   *  receipt, an empty receipt set, or a refused teardown probe. Only a crash before that point
+   *  or a `reconciled` record without `settledSeq` leaves the slot open.
    *  `spent` is this node's child-work component of the reconcile the pool committed — for
    *  a leaf the streamed floor itself, for a recursive executor its `accounting().reported`
    *  split with the remainder on its `metered` records — never the reservation ceiling.
@@ -4600,7 +4922,7 @@ type SpawnEvent = {
    *  delivery, so replay yields it at the position the driver saw it; `at` is the settlement
    *  instant, and the release instant is on the receipt immediately before it. Typed so a
    *  `'pending'` can never be journaled: the journal states that as `reconciled`. */
-  retainedExecution?: Extract<RetainedExecutionState, 'released'>;
+  retainedExecution?: Exclude<RetainedExecutionState, 'pending'>;
   retainedPendingCause?: RetainedPendingCause;
   /** The bounded account of the team this child led, when it led one. */
   subtree?: SubtreeSummary;
@@ -4622,7 +4944,7 @@ type SpawnEvent = {
   budgetViolation?: BudgetViolation;
   /** As on `settled`: a retained child that was cancelled settles `cancelled`, and the one
    *  builder writes whichever kind the settlement had. */
-  retainedExecution?: Extract<RetainedExecutionState, 'released'>;
+  retainedExecution?: Exclude<RetainedExecutionState, 'pending'>;
   retainedPendingCause?: RetainedPendingCause;
   /** The bounded account of the team this child led, when it led one. */
   subtree?: SubtreeSummary;
@@ -4729,12 +5051,14 @@ type SpawnEvent = {
    *  observed, while its cursor slot stays OPEN so a resume can recover the execution. It stands
    *  in for the `settled` record an open node cannot carry: cost readers and a restored pool
    *  charge this floor for the node instead of its declared ceiling, and a later `settled` or
-   *  `cancelled` record for the same node supersedes it. That record has three writers: a
+   *  `cancelled` record for the same node supersedes it. That record has four writers: a
    *  resumed process's recovered settlement, the release sweep's terminal record marked
-   *  `retainedExecution: 'released'`, or `healReleasedSlots` on the next resume when the
-   *  process died between the last `environment-teardown` receipt and that record. The last
-   *  two write the same bytes, because both read the settlement from THIS record: it is
-   *  literally the settlement it stands in for, minus the cursor position it cannot hold. A
+   *  `retainedExecution: 'released'`, the final settlement's record marked
+   *  `'release-unconfirmed'` for a node whose release it could not confirm, or
+   *  `healReleasedSlots` on the next resume when the process died between the last
+   *  `environment-teardown` receipt and the released record. The last three carry the same
+   *  settlement, because each reads it from THIS record or from the live child it mirrors: it
+   *  is literally the settlement it stands in for, minus the cursor position it cannot hold. A
    *  driver's own inference travels on its `metered` record as on every other path, so
    *  `reconciled + metered` is what the pool committed. Its `seq` lives outside the
    *  cursor-uniqueness namespace; `settledSeq` is the cursor seq. */
@@ -4836,8 +5160,10 @@ type SpawnEvent = {
    *  terminal `settled`/`cancelled` record with `retainedExecution: 'released'` follows on
    *  the same tree and closes the cursor slot; when the settling process dies between this
    *  receipt and that record, `healReleasedSlots` writes the same record on the next resume
-   *  from the `reconciled` record. A `destroyed: false` receipt, an empty receipt set, or an
-   *  unconfirmed teardown leaves the slot open because the environment may still exist.
+   *  from the `reconciled` record. After a `destroyed: false` receipt, an empty receipt set, or
+   *  an unconfirmed teardown, the environment may still exist: the node is journaled as
+   *  `teardown-unconfirmed`, and its slot closes with `retainedExecution:
+   *  'release-unconfirmed'` instead, because the settlement is final either way.
    *  Informational: replay, `materializeTreeView`, and cost readers skip it, and its `seq` is
    *  per node, outside the cursor-uniqueness namespace. */
   kind: 'environment-teardown';
@@ -4928,6 +5254,8 @@ interface SpawnJournal {
   loadTree(root: NodeId): Promise<SpawnEvent[] | undefined>;
   beginTree(root: NodeId, at: string): Promise<void>;
   appendEvent(root: NodeId, ev: SpawnEvent): Promise<void>;
+  /** Publish all events together or none; SQL contexts use this for initialization records. */
+  appendEvents?(root: NodeId, events: ReadonlyArray<SpawnEvent>): Promise<void>;
 }
 /** Content-addressed result blobs (the `outRef` → artifact map) backing the replay
  *  invariant. Split from the journal so the journal stays small (decisions) and the
@@ -5041,10 +5369,16 @@ interface SupervisorOpts {
    *   Sandbox fleet for 19 to 37 hours without it. It then closes each released child's cursor
    *   slot with a terminal record marked `retainedExecution: 'released'`, so `spendGaps` names
    *   it `unreported` (a floor) rather than `never-settled` (a ceiling) and
-   *   `fleetYield.releasedUnrecovered` counts it; a refused release leaves the slot open and
-   *   the node in `teardownUnconfirmed`. A process that dies between the last `destroyed: true`
-   *   receipt and that record leaves the slot open only until the next resume, whose
-   *   `healReleasedSlots` writes the identical record from the `reconciled` record.
+   *   `fleetYield.releasedUnrecovered` counts it. A release that is refused or cannot be
+   *   confirmed names the node in `teardownUnconfirmed` and its `teardown-unconfirmed` record,
+   *   and after the retry window closes its slot with `retainedExecution: 'release-unconfirmed'`,
+   *   counted by `fleetYield.releaseUnconfirmed`: the settlement is final, so the slot closes
+   *   whether or not the environment is confirmed gone. Measured 2026-09-23/24 on the Discovery
+   *   fleet (Runtime 0.249.1 to 0.261.0): 338 of 1,620 agents never settled, and 179 of the
+   *   retained ones had an admission that never named an environment. A process that dies
+   *   between the last `destroyed: true` receipt and the released record leaves the slot open
+   *   only until the next resume, whose `healReleasedSlots` writes the identical record from the
+   *   `reconciled` record.
    * - `'keep'`: a later process may resume this run, so the environments stay for its recovery.
    *
    * Default: `'keep'` when `resume` is true (a durable run a later process may continue), else
@@ -5169,13 +5503,20 @@ interface SpendGap {
  *   `destroyed: true` receipt and the record (same builder, `seq` and `at`, from the
  *   `reconciled` record). The pool's own admission fault, if the reconcile raised one, is not
  *   on this record.
+ * - `'release-unconfirmed'`: root settlement under `retainedAtSettlement: 'release'` ended with
+ *   the execution unrecovered and its environment NOT confirmed destroyed: the provider refused
+ *   the delete, the executor could not confirm it, or the admission never named an environment
+ *   (a create that timed out). The settlement is final, so no process will recover the execution
+ *   and the slot closes anyway, with the same builder, `seq` and `at` as `'released'`. What the
+ *   node may still hold stays named by its `teardown-unconfirmed` record and in
+ *   `teardownUnconfirmed`, for a sweeper.
  *
  * Absent = an ordinary child. The live `Settled` a driver branched on carried `'pending'` where
- * replay yields `'released'` for the same seq, so a resume-aware driver must not branch on the
- * two values. No `'recovered'` value exists yet: a live-adopted recovery settles on the ordinary
- * path and the recorded-result path writes no marker.
+ * replay yields `'released'` or `'release-unconfirmed'` for the same seq, so a resume-aware driver
+ * must not branch on these values. No `'recovered'` value exists yet: a live-adopted recovery
+ * settles on the ordinary path and the recorded-result path writes no marker.
  */
-type RetainedExecutionState = 'pending' | 'released';
+type RetainedExecutionState = 'pending' | 'released' | 'release-unconfirmed';
 /**
  * How this run's spawned CHILDREN ended, counted by node id off the complete journal FOREST at
  * root settlement — after the join barrier and the release sweep, so the terminal records the
@@ -5194,13 +5535,18 @@ interface FleetYield {
   /** `settled` records with `status: 'down'`, released records included. */
   readonly down: number;
   readonly cancelled: number;
-  /** Spawned with no terminal record: a crash-orphaned child, a refused release, or a retained
-   *  executor with nothing to release. Named after `SpendGap`'s `never-settled`. */
+  /** Spawned with no terminal record: a crash-orphaned child, or a retained child of a run that
+   *  keeps its environments for a resume (`retainedAtSettlement: 'keep'`). Named after
+   *  `SpendGap`'s `never-settled`. */
   readonly neverSettled: number;
   /** Terminal records marked `retainedExecution: 'released'` — a subset of `down + cancelled`.
    *  A nested manager whose OWN retained execution was released counts here beside the
    *  grandchildren it released, because its execution was destroyed unrecovered too. */
   readonly releasedUnrecovered: number;
+  /** Terminal records marked `retainedExecution: 'release-unconfirmed'` — a subset of
+   *  `down + cancelled`, disjoint from `releasedUnrecovered`: executions a final settlement left
+   *  unrecovered without confirming their environment destroyed. */
+  readonly releaseUnconfirmed: number;
 }
 /**
  * One channel on which a settled reservation's measured spend exceeded what it reserved.
@@ -5244,6 +5590,10 @@ type SupervisedResult<Out> = {
   readonly rootProviderModel?: RootProviderModelEvidence;
   /** The root manager's retained provider stream, when the run directory holds one. */
   readonly rootStream?: RootStreamReceipt;
+  /** The root manager's native harness session, persisted like a child's receipt. A child's
+   *  receipt rides its settle record and the root has none, so the result carries it. Absent
+   *  for a router-brained root, which runs no driver. */
+  readonly rootHarnessTranscript?: HarnessTranscriptEvidence;
   /** 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. */
@@ -5291,6 +5641,10 @@ type SupervisedResult<Out> = {
   readonly rootProviderModel?: RootProviderModelEvidence;
   /** The root manager's retained provider stream, when the run directory holds one. */
   readonly rootStream?: RootStreamReceipt;
+  /** The root manager's native harness session, persisted like a child's receipt. A child's
+   *  receipt rides its settle record and the root has none, so the result carries it. Absent
+   *  for a router-brained root, which runs no driver. */
+  readonly rootHarnessTranscript?: HarnessTranscriptEvidence;
   /** 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. */
@@ -5361,6 +5715,10 @@ type SupervisedResult<Out> = {
   readonly rootProviderModel?: RootProviderModelEvidence;
   /** The root manager's retained provider stream, when the run directory holds one. */
   readonly rootStream?: RootStreamReceipt;
+  /** The root manager's native harness session, persisted like a child's receipt. A child's
+   *  receipt rides its settle record and the root has none, so the result carries it. Absent
+   *  for a router-brained root, which runs no driver. */
+  readonly rootHarnessTranscript?: HarnessTranscriptEvidence;
   /** 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. */
@@ -5433,5 +5791,5 @@ interface WidenGate<Out> {
   readonly judgeExempt?: boolean;
 }
 //#endregion
-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
+export { SpawnJournal as $, RunAgentTaskOptions as $a, spendFromUsageEvents as $i, HarnessTranscriptCapture as $n, ConfigError as $r, loopEventToOtelSpan as $t, NodeExecutionIdentity as A, RuntimeRunCost as Aa, RetainedRunEventOptions as Ai, TraceSource as An, ContinuationAppend as Ar, createPropagatingTraceEmitter as At, ResultBlobStore as B, AgentExecutionBackend as Ba, BudgetPoolRestore as Bi, ScopeProgressInput as Bn, VerdictSummary as Br, OtelAttribute as Bt, ExecutorToolCall as C, OutputAdapter as Ca, RetainedRunAdmission as Ci, pollFor as Cn, UnavailablePausePolicy as Cr, WorkerTraceResolver as Ct, MaterializedExecutionIdentity as D, ValidationCtx as Da, RetainedRunDispatchedAdmission as Di, SessionMessageLike as Dn, CheckRead as Dr, workerTraceHeaders as Dt, HeldEnvironment as E, SelectionReceipt as Ea, RetainedRunCancellation as Ei, waitUntil as En, CONTINUATION_FACTS as Er, workerTraceEnv as Et, ProviderModelAttemptEvidence as F, RuntimeRunStatus as Fa, RetainedRunStartMaterial as Fi, RetainedPendingCause as Fn, ContinuationPanelInput as Fr, EvalRunGeneration as Ft, RootMaterialization as G, AgentTaskRunResult as Ga, ReservationHolder as Gi, ReconnectRetainedInteractiveRunOptions as Gn, distillFindings as Gr, RuntimeEventOtelOptions as Gt, ResumedWork as H, AgentRuntimeEvent as Ha, BudgetReconcileFault as Hi, WorkerProgress as Hn, admitFinding as Hr, OtelExportStats as Ht, ProviderModelExecutionEvidence as I, startRuntimeRun as Ia, RetainedRunTurnInput as Ii, ActivityLog as In, ContinuationPanelResult as Ir, EvalRunsExportConfig as It, RootStreamReceipt as J, BackendErrorDetail as Ja, ReservationStage as Ji, RetainedInteractiveEnvironmentInput as Jn, passedItems as Jr, buildRuntimeEventOtelSpans as Jt, RootProviderModelEvidence as K, AgentTaskSpec as Ka, ReservationRejection as Ki, RecoverRetainedInteractiveRunOptions as Kn, expandQuestions as Kr, buildLoopOtelSpans as Kt, RecursiveReservationPolicy as L, AgentAdapter as La, StartRetainedRunInEnvironmentOptions as Li, ActivityNote as Ln, ContinuationPolicy as Lr, EvalRunsExportResult as Lt, NodeSnapshot as M, RuntimeRunOptions as Ma, RetainedRunIntentAdmission as Mi, decodeToolPart as Mn, ContinuationEntry as Mr, readTraceContextFromEnv as Mt, NodeStatus as N, RuntimeRunPersistenceAdapter as Na, RetainedRunReplayPoint as Ni, sandboxSessionTraceSource as Nn, ContinuationNoteInput as Nr, traceContextToEnv as Nt, MaterializedModelIdentity as O, Validator as Oa, RetainedRunEffect as Oi, SessionTraceBox as On, CheckUnavailableError as Or, workerTraceSeamKey as Ot, ProfileMaterializationReceipt as P, RuntimeRunRow as Pa, RetainedRunSnapshot as Pi, RetainedChildRecovery as Pn, ContinuationPanel as Pr, EvalRunEvent as Pt, SpawnEvent as Q, OpenAIChatToolChoice as Qa, createBudgetPool as Qi, HarnessTranscriptArtifact as Qn, BackendTransportError as Qr, generateSpanId as Qt, ResourceLimit as R, AgentBackendContext as Ra, StartRetainedRunOptions as Ri, DEFAULT_STALL_AFTER_MS as Rn, ContinuationProfile as Rr, INTELLIGENCE_WIRE_VERSION as Rt, ExecutorTeardownWarning as S, MountRecorder as Sa, RetainedInteractiveStartedAdmission as Si, isWaitOutcome as Sn, upstreamUnavailableSignal as Sr, WorkerTraceUnavailableReason as St, Handle as T, SandboxClient as Ta, RetainedRunCancelOptions as Ti, validateWaitSpec as Tn, CONTINUATIONS_DIR as Tr, readWorkerTraceContext as Tt, RetainedExecutionState as U, AgentRuntimeEventSink as Ua, LeakedReservation as Ui, createActivityLog as Un, checkVerdictOf as Ur, OtelExporter as Ut, ResumedKeyState as V, AgentKnowledgeProvider as Va, BudgetReadout as Vi, TeamProgress as Vn, admitContinuationPolicy as Vr, OtelExportConfig as Vt, RootHandle as W, AgentTaskContext as Wa, ReservationFloor as Wi, readWorkerProgress as Wn, composeContinuationNote as Wr, OtelSpan as Wt, Scope as X, OpenAIChatResponseFormat as Xa, ReservationWaitRefused as Xi, RetainedInteractiveStartMaterial as Xn, AgentEvalError$1 as Xr, createOtelExporter as Xt, Runtime as Y, KnowledgeReadinessDecision as Ya, ReservationTicket as Yi, RetainedInteractiveRunHandle as Yn, verdictFromJudgeScore as Yr, createOpenInferenceFileExporter as Yt, Settled as Z, OpenAIChatTool as Za, ReserveOptions as Zi, StartRetainedInteractiveRunOptions as Zn, AgentEvalErrorCode as Zr, exportEvalRuns as Zt, ExecutorMaterialization as _, LoopTokenUsage as _a, RecoverRetainedRunOptions as _i, WaitProbe as _n, DriverReentry as _r, WaitOpts as _t, BudgetOverspend as a, LoopDecisionPayload as aa, RetainedRunAdmissionError as ai, RuntimeStreamEventSink as an, captureHarnessTranscript as ar, SpendGap as at, ExecutorRegistry as b, LoopWinner as ba, RetainedInteractiveEnvironmentAdmission as bi, WaitSpec as bn, classifyDriverFailure as br, WorkerInteractiveUnavailableReason as bt, EnvironmentTeardownReceipt as c, LoopIterationEndedPayload as ca, ValidationError as ci, SanitizedKnowledgeReadinessReport as cn, DriverAttemptRecord as cr, SubtreeSummary as ct, ExecutorAccounting as d, LoopPlanDescription as da, createWorkerSlots as di, createRuntimeStreamEventCollector as dn, DriverBudgetReadout as dr, SupervisorOpts as dt, AgentRunSpec as ea, JudgeError as ei, padSpanId as en, RunAgentTaskStreamOptions as eo, HarnessTranscriptEvidence as er, SpawnOpts as et, ExecutorCancellation as f, LoopPlanPayload as fa, NativeContextContinuationExecution as fi, sanitizeAgentRuntimeEvent as fn, DriverContinuationRecord as fr, TokenUsageProvenance as ft, ExecutorFactory as g, LoopTeardownFailedPayload as ga, RecoverRetainedRunIntentOptions as gi, WaitOutcome as gn, DriverProgressMark as gr, UsageEvent as gt, ExecutorExecutionBinding as h, LoopStartedPayload as ha, ReconnectRetainedRunOptions as hi, PendingWait as hn, DriverLoopRecord as hr, UnknownMaterializationReason as ht, Budget as i, Iteration as ia, RetainedInteractiveBindingError as ii, RuntimeStreamEventCollector as in, RuntimeStreamEvent as io, ReadableEnvironment as ir, SpendChannel as it, NodeId as j, RuntimeRunHandle as ja, RetainedRunHandle as ji, createPushTraceSource as jn, ContinuationContext as jr, mergeTraceEnv as jt, NoWinnerError as k, RuntimeRunCompleteInput as ka, RetainedRunEnvironmentAdmission as ki, ToolStepInput as kn, CheckVerdict as kr, TraceContext as kt, ExecutionBindingReceipt as l, LoopIterationStartedPayload as la, SlotPermit as li, SanitizedKnowledgeRequirement as ln, DriverAttemptStop as lr, SupervisedResult as lt, ExecutorContext as m, LoopSandboxPlacement as ma, NativeContextContinuationInput as mi, sanitizeRuntimeStreamEvent as mn, DriverFailureClass as mr, UnconfirmedTeardown as mt, AgentExecutionRef as n, Driver as na, PlannerError as ni, toOtelAttributes as nn, RuntimeSession as no, HarnessTranscriptUnavailable as nr, SpawnRejection as nt, BudgetViolation as o, LoopEndedPayload as oa, RetainedRunDispatchBindingError as oi, RuntimeStreamEventSummary as on, harnessTranscriptArtifact as or, SteerableRootHandle as ot, ExecutorCancellationRequest as p, LoopResult as pa, NativeContextContinuationHandle as pi, sanitizeKnowledgeReadinessReport as pn, DriverContractState as pr, TreeView as pt, RootSignal as q, AgentTaskStatus as qa, ReservationShortfall as qi, RetainedInteractiveAdmissionHook as qn, failedItems as qr, buildLoopSpanNodes as qt, AgentSpec as r, ExecCtx as ra, RetainedInteractiveAdmissionError as ri, RuntimeEventCollector as rn, RuntimeSessionStore as ro, HarnessTranscriptUnavailableReason as rr, Spend as rt, DefaultVerdict as s, LoopIterationDispatchPayload as sa, RuntimeRunStateError as si, RuntimeTelemetryOptions as sn, persistHarnessTranscript as sr, SubtreeResult as st, Agent as t, DefaultVerdict$1 as ta, NotFoundError as ti, padTraceId as tn, RuntimeCanonicalStreamEvent as to, HarnessTranscriptFile as tr, SpawnPrior as tt, Executor as u, LoopLineageOptions as ua, WorkerSlots as ui, createRuntimeEventCollector as un, DriverAttemptsExhaustedError as ur, Supervisor as ut, ExecutorNodeContext as v, LoopTraceEmitter as va, RecoverRetainedRunResult as vi, WaitProbeRegistry as vn, DriverRepromptRefusal as vr, WidenGate as vt, FleetYield as w, RunProvenance as wa, RetainedRunAdmissionHook as wi, timerAt as wn, AdmittedFinding as wr, WorkerTraceSeamCarrier as wt, ExecutorResult as x, MountManifestEntry as xa, RetainedInteractiveIntentAdmission as xi, createWaitProbes as xn, summarizeDriverAttempts as xr, WorkerTraceEvidence as xt, ExecutorProgressEvent as y, LoopTraceEvent as ya, RetainedInteractiveAdmission as yi, WaitRejection as yn, DriverRetryPolicy as yr, WorkerInteractiveSession as yt, ResourceSpend as z, AgentBackendInput as za, BudgetPool as zi, ExecutorProgress as zn, PanelFinding as zr, LoopSpanNode as zt };
+//# sourceMappingURL=types-DMRc3jru.d.ts.map