@tangle-network/agent-runtime 0.231.1 → 0.233.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-BW6lJXnH.js";
-import { Dn as ToolLoopChat, En as ToolLoopCallContext } from "./stream-agent-turn-hiU4vgGX.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-BwWBXoyq.js";
+import { Dn as ToolLoopChat, En as ToolLoopCallContext } from "./stream-agent-turn-aXpd9b_N.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 { f as verifyAgentImprovementProposal } from "./improvement-cycle-CjIeWuyB.js";
+import { f as verifyAgentImprovementProposal } from "./improvement-cycle-WJJALdil.js";
 import { o as canonicalCandidateDigest$1, u as immutableCandidateValue } from "./protected-redaction-wGo44k2K.js";
 import { M as parseExactAgentProfile, w as applyExactAgentProfileDiff } from "./prepare-Dc30WRB0.js";
-import { p as supervisorAgentWithTestBrain, r as superviseWithTestBrain } from "./supervise-Cl_-IsVc.js";
-import { r as driverAgent } from "./coordination-driver-CUdEC2Qh.js";
-import { i as runGraphWithTestBrain } from "./graph-D4wgK3ns.js";
+import { p as supervisorAgentWithTestBrain, r as superviseWithTestBrain } from "./supervise-CAJWyXQ-.js";
+import { r as driverAgent } from "./coordination-driver-BR52Rt39.js";
+import { i as runGraphWithTestBrain } from "./graph-BtMQMQin.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:6e82ad15ab3d4ce4f73913de01f1e13ebc68bb4b4d9120b43382f01954dd956e",
+	digest: "sha256:c955600d688a194cfb429c3c6165a5b8f16ca1634597cab757af0b05cd3290e3",
 	evaluation: {
 		"decision": {
 			"contributingChecks": [
@@ -4579,7 +4579,7 @@ var agent_improvement_proposal_default = {
 		],
 		"metadata": {
 			"fixture": "agent-improvement-proposal",
-			"runtimeVersion": "0.231.1"
+			"runtimeVersion": "0.233.0"
 		},
 		"objectives": [
 			{
@@ -4690,8 +4690,8 @@ var agent_improvement_proposal_default = {
 			"baselineContentHash": "sha256:5c21ee53e513fc604cb09754e21c392b24a424da0ef37dbf8f1ee4a8a0b08f09",
 			"candidateContentHash": "sha256:60fcbb1c728194bd51d7d19cb732d1c3f1881dce7e0a6266b41c8b98cfd65693",
 			"kind": "agent-eval-loop",
-			"recordDigest": "sha256:e26e7e4ff57e2509e042c553c638f579680f438553fbede8b8d51c35b2c6be68",
-			"runId": "agent-runtime-0.231.1-proposal-fixture",
+			"recordDigest": "sha256:cbf8298e0f8dd8a60ef8fe8ce3cc4b5c214e35a3c40c05c167e22a4848c43a90",
+			"runId": "agent-runtime-0.233.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.231.1-proposal-fixture"
+	runId: "agent-runtime-0.233.0-proposal-fixture"
 };
 //#endregion
 //#region src/testing/fixtures/agent-profile-improvement-proposal.json
 var agent_profile_improvement_proposal_default = {
 	changedSurfaces: ["prompt", "skills"],
-	digest: "sha256:d02c9c48865e63a968095846d85416c925186c770caca400680b2448988414f8",
+	digest: "sha256:a28e23a8892b3d8ba6c66c374750e321b06bc036fad7aa76984e617cdc378ff3",
 	evaluation: {
 		"decision": {
 			"contributingChecks": [
@@ -6354,7 +6354,7 @@ var agent_profile_improvement_proposal_default = {
 		],
 		"metadata": {
 			"fixture": "agent-profile-improvement-proposal",
-			"runtimeVersion": "0.231.1"
+			"runtimeVersion": "0.233.0"
 		},
 		"objectives": [
 			{
@@ -6465,7 +6465,7 @@ var agent_profile_improvement_proposal_default = {
 			"baselineContentHash": "sha256:21c495a37c418c10bde64fbaa188beddeed31f1f051ea60a6a6582a9ee0db704",
 			"candidateContentHash": "sha256:103f77bc8481601eef1ad5fe6ba84a40dffabc3a44f421f8c8559121edab84e9",
 			"kind": "agent-eval-loop",
-			"recordDigest": "sha256:5cad90b609c3f39e1fe23ea5a140b10fb58221ee0b7aabf12b62a8e5c0e3b58c",
+			"recordDigest": "sha256:1bcc70b1e1bb5a020da56e97fcc4a2d89824ecf8ca59b2e0232b868333daa4c4",
 			"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-BW6lJXnH.js";
+import { Ct as ProvisionedSupervisor, St as ProvisionSupervisorRequest, Tt as provisionSupervisor, wt as SupervisorCleanupReceipt, xt as ProvisionSupervisorConnection } from "../index-BwWBXoyq.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-DyNDlA2I.js";
+import { t as provisionSupervisor } from "../provision-supervisor-BME3OgTk.js";
 import { a as renderTopFrameWithLayout, i as renderTopFrame, n as runTopApp, r as loadTopSnapshot, t as renderTopOnce } from "../top-app-CMMd8DgR.js";
 export { loadTopSnapshot, provisionSupervisor, renderTopFrame, renderTopFrameWithLayout, renderTopOnce, runTopApp };

package/dist/{types-DBovefLD.d.ts → types-F5MG_7Qq.d.ts}

@@ -1743,34 +1743,121 @@ type RecoverRetainedRunResult = {
   readonly environment: AgentEnvironment;
 };
 //#endregion
-//#region src/runtime/native-session-evidence.d.ts
-declare const NATIVE_SESSION_SCHEMA_VERSION: 1;
-interface NativeSessionFile {
+//#region src/runtime/harness-transcript.d.ts
+declare const HARNESS_TRANSCRIPT_SCHEMA_VERSION: 1;
+interface HarnessTranscriptFile {
   readonly path: string;
   readonly bytes: number;
   readonly content: string;
 }
-interface NativeSessionArtifact {
-  readonly schemaVersion: typeof NATIVE_SESSION_SCHEMA_VERSION;
+interface HarnessTranscriptArtifact {
+  readonly schemaVersion: typeof HARNESS_TRANSCRIPT_SCHEMA_VERSION;
   readonly harness: string;
-  readonly files: readonly NativeSessionFile[];
+  readonly files: readonly HarnessTranscriptFile[];
   /** Paths found but not read, with why — a gap named is a gap an operator can act on. */
   readonly skipped: readonly {
     readonly path: string;
     readonly reason: string;
   }[];
 }
-type NativeSessionEvidence = {
+/** Why no transcript reached a record, from either the capture or the settle path. */
+type HarnessTranscriptUnavailableReason = 'unsupported-environment' | 'unknown-harness' | 'no-transcript' | 'enumeration-failed' |
+/** No environment was ever created for this child, so there is no transcript and never
+ *  was one. The admission refusal of #1240 is the measured case: a budget pool that
+ *  refuses an unknown dollar cost kills the child before it runs. Distinct from
+ *  `unsupported-environment`, which means a box existed and could not be read. */
+'execution-never-started' |
+/** An environment WAS created and the child ran, but the capture never executed — the
+ *  deadline/abort path closes the stream with `iterator.return()`, which runs the
+ *  generator's `finally` and skips its `catch`. Says only what is known: this child had a
+ *  transcript and nobody read it. Never collapse it into `execution-never-started`; that
+ *  would report a child that reasoned for twenty seconds as one that never ran. */
+'capture-did-not-run' |
+/** This executor implements no transcript port at all: a CLI, in-process, bridge, or
+ *  sandbox-session executor that has no capture yet. An absence by construction, never a
+ *  failure — and never a claim that the harness wrote nothing. */
+'executor-exposes-no-transcript' |
+/** Session files were found and none was carried: every path was refused, over budget,
+ *  unreadable, or skipped by an abort. The `skipped` list beside this reason names each one,
+ *  so "there was a transcript and it was not kept" never reads as "no transcript". */
+'nothing-carried' |
+/** The capture succeeded and the blob write did not. The transcript existed in memory and
+ *  never reached disk; mirrors `trace-persistence-failed` on the tool-span receipt. */
+'transcript-persistence-failed';
+interface HarnessTranscriptUnavailable {
+  readonly status: 'unavailable';
+  readonly reason: HarnessTranscriptUnavailableReason;
+  /** Present with `nothing-carried`: the paths that existed and why each was not read. */
+  readonly skipped?: readonly {
+    readonly path: string;
+    readonly reason: string;
+  }[];
+}
+/**
+ * What the executor holds in memory between the read and the settle: the files, inline.
+ *
+ * Never journaled and never inside a result blob. The scope persists it under its own content
+ * ref and records the {@link HarnessTranscriptEvidence} receipt instead, so the settlement stays
+ * small and a replay pays nothing for a transcript nobody opens.
+ */
+type HarnessTranscriptCapture = {
+  readonly status: 'captured';
+  readonly artifact: HarnessTranscriptArtifact;
+  readonly fileCount: number;
+  readonly totalBytes: number;
+  /** Non-zero when some transcript was found but deliberately not carried. */
+  readonly skippedCount: number;
+} | HarnessTranscriptUnavailable;
+/**
+ * The durable receipt on a settlement: a content-addressed pointer to a persisted
+ * {@link HarnessTranscriptArtifact}, or the exact reason there is none. A SIBLING of the tool-span
+ * `trace` receipt, never nested inside it — a dropped child has zero tool spans and an
+ * unavailable trace, and it is precisely the child whose transcript this exists to keep.
+ */
+type HarnessTranscriptEvidence = {
   readonly status: 'available';
-  readonly artifact: NativeSessionArtifact;
+  /** Content-addressed pointer to a persisted `HarnessTranscriptArtifact` in the run's blobs. */
+  readonly transcriptRef: string;
+  readonly harness: string;
   readonly fileCount: number;
   readonly totalBytes: number;
   /** Non-zero when some transcript was found but deliberately not carried. */
   readonly skippedCount: number;
-} | {
-  readonly status: 'unavailable';
-  readonly reason: 'unsupported-environment' | 'unknown-harness' | 'no-transcript' | 'enumeration-failed';
-};
+} | HarnessTranscriptUnavailable;
+/** The two optional environment reads the capture needs. Public because `captureHarnessTranscript`
+ *  is, so a BYO executor can satisfy it with any box that offers a bounded `read` and an `exec`. */
+interface ReadableEnvironment {
+  readonly read?: (path: string, options?: {
+    readonly signal?: AbortSignal;
+  }) => Promise<string>;
+  readonly exec?: (command: string, options?: Record<string, unknown>) => Promise<{
+    readonly stdout?: string;
+    readonly exitCode?: number;
+  }>;
+}
+/**
+ * Read the harness transcript out of one LIVE environment.
+ *
+ * Call this before the environment is destroyed — on the settled path that means before the
+ * result is built, since the `finally` that destroys runs after. It never throws: a teardown
+ * must not fail because evidence could not be collected, and every failure mode is a named
+ * `reason` the settled receipt carries instead of an empty artifact that reads as coverage.
+ */
+declare function captureHarnessTranscript(environment: ReadableEnvironment | undefined, harness: string | undefined, signal?: AbortSignal): Promise<HarnessTranscriptCapture>;
+/**
+ * Persist a capture under its own content ref and return the receipt a settlement carries.
+ *
+ * The scope calls this, not the executor: storage stays out of every provider and destroy site,
+ * exactly as the tool-span trace is persisted by `captureWorkerTraceEvidence` and not by the
+ * source that collected it. A capture that is already unavailable passes through untouched.
+ */
+declare function persistHarnessTranscript(capture: HarnessTranscriptCapture, blobs: Pick<ResultBlobStore, 'put'>): Promise<HarnessTranscriptEvidence>;
+/**
+ * Rehydrate the exact persisted transcript a receipt points at, or `undefined` when the receipt
+ * says there is none. Throws only when the receipt claims a blob the store does not hold — that
+ * is corruption, not absence, and must not read as "no transcript".
+ */
+declare function harnessTranscriptArtifact(evidence: HarnessTranscriptEvidence, blobs: Pick<ResultBlobStore, 'get'>): Promise<HarnessTranscriptArtifact | undefined>;
 //#endregion
 //#region src/runtime/retained-interactive-types.d.ts
 /** Environment and exact AgentProfile used to start one native coding-agent process. @stable */
@@ -2729,6 +2816,18 @@ interface Executor<Out> {
    * executors omit it (returns `undefined`).
    */
   metered?(): Spend | undefined;
+  /**
+   * The child's OWN harness transcript, read out of its environment while that environment was
+   * still live. Read on settle, valid after `execute` resolves OR throws — the throw half is the
+   * point: a child that drops produces no result artifact, so before this the only carrier was
+   * the settled result and a dropped child's reasoning died with its box (#1244).
+   *
+   * An executor with no transcript to offer omits the method entirely; the settle path then
+   * records `executor-exposes-no-transcript` rather than an empty artifact that reads as
+   * coverage. Never throws. Returns the in-memory capture; the SCOPE persists it under its own
+   * content ref and settles the receipt, so no executor ever learns about storage.
+   */
+  harnessTranscript?(): HarnessTranscriptCapture | undefined;
 }
 /** Why Runtime cannot provide structured tool-call evidence for one settled execution. */
 type WorkerTraceUnavailableReason = 'execution-did-not-start' | 'executor-did-not-expose-trace-source' | 'trace-source-unavailable' | 'no-tool-spans-captured' | 'invalid-tool-spans' | 'trace-collection-failed' | 'trace-persistence-failed' | 'legacy-settlement-without-trace-evidence' | 'not-an-executor';
@@ -2738,16 +2837,6 @@ type WorkerTraceEvidence = {
   /** Content-addressed pointer to a persisted `WorkerToolTraceArtifact`. */
   readonly traceRef: string;
   readonly spanCount: number;
-  /**
-   * The child's OWN harness transcript, read out of its environment before destroy.
-   *
-   * `traceRef` above points at the supervisor's tool spans: toolName, args, status,
-   * callId, with startedAt === endedAt. It carries no assistant text, no reasoning and
-   * no tool results, so `status: 'available'` on this object never meant the child's
-   * session survived — it was destroyed with the environment. This says whether it did.
-   * Absent on a settlement recorded before the capture existed.
-   */
-  readonly nativeSession?: NativeSessionEvidence;
 } | {
   readonly status: 'unavailable';
   readonly reason: WorkerTraceUnavailableReason;
@@ -3390,6 +3479,12 @@ type Settled<Out> = {
   providerModel?: ProviderModelExecutionEvidence;
   /** Structured tool evidence captured before this settlement was journaled. */
   trace: WorkerTraceEvidence;
+  /** Whether the child's OWN harness transcript survived its environment, or why it did not.
+   *  A SIBLING of `trace`, not a field inside it: `trace` carries the supervisor's tool spans
+   *  (toolName, args, status, callId, startedAt === endedAt) and nothing the child said, and a
+   *  child with zero tool spans has an UNAVAILABLE trace — so a receipt nested inside the
+   *  available arm could never describe exactly the children that need it most (#1244). */
+  harnessTranscript?: HarnessTranscriptEvidence;
   /** Present when the measured spend exceeded this child's reservation. */
   budgetViolation?: BudgetViolation;
   /** Epoch ms parsed from the durable settlement record when available. */
@@ -3406,10 +3501,22 @@ type Settled<Out> = {
   infra: boolean;
   /** Partial structured tool evidence captured before this failure was journaled. */
   trace: WorkerTraceEvidence;
+  /** The child's own harness transcript, read out of its environment at the last moment it
+   *  was live, or the named reason it could not be. This is the path the capture existed
+   *  for and never covered: a dropped child produces no result artifact, so before #1244
+   *  its reasoning was destroyed with its box. */
+  harnessTranscript?: HarnessTranscriptEvidence;
   /** Partial provider model evidence survives an aborted or failed execution. */
   providerModel?: ProviderModelExecutionEvidence;
   /** Present when the spend reconciled for this child exceeded its reservation. */
   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
+   *  states, so a reader never splits this population on `reason` text — which is identical
+   *  on every one of these children. */
+  retainedExecution?: RetainedExecutionState;
   /** Epoch ms parsed from the durable settlement/cancellation record when available. */
   settledAt?: number;
   seq: number;
@@ -3650,6 +3757,11 @@ 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. */
+  readonly retainedExecution?: RetainedExecutionState;
 }
 /** The live tree — what `scope.view` / `RootHandle.view()` materialize for a viewer. */
 interface TreeView {
@@ -3744,8 +3856,23 @@ type SpawnEvent = {
   reason?: string;
   /** Structured tool evidence. Optional only for journals written before trace capture. */
   trace?: WorkerTraceEvidence;
+  /** Whether this child's harness transcript survived, or the named reason it did not.
+   *  Absent on journals written before the capture existed — which is not the same fact as
+   *  a recorded `unavailable`, and is why this stays optional rather than defaulting. */
+  harnessTranscript?: HarnessTranscriptEvidence;
   /** Present when the reconciled spend exceeded the reservation, on either status. */
   budgetViolation?: BudgetViolation;
+  /** Written only by the release sweep, on the same tree, after every `environment-teardown`
+   *  receipt for the node reads `destroyed: true` and the executor's own teardown confirmed.
+   *  `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.
+   *  `reason`/`infra`/`trace`/`harnessTranscript`/`outRef`/`providerModel` are the
+   *  settlement the driver received, verbatim; `seq` is the cursor seq stamped on that
+   *  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'>;
   seq: number;
   at: string;
 } | {
@@ -3757,8 +3884,14 @@ type SpawnEvent = {
   spent?: Spend;
   providerModel?: ProviderModelExecutionEvidence;
   trace?: WorkerTraceEvidence;
+  /** The child's harness transcript receipt, when the executor could still be read at the
+   *  cancel. The settle path writes it on this record exactly as on `settled`. */
+  harnessTranscript?: HarnessTranscriptEvidence;
   outRef?: string;
   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'>;
   seq: number;
   at: string;
 } | {
@@ -3862,12 +3995,19 @@ 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. A driver's own inference travels on its
+   *  `cancelled` record for the same node supersedes it. That record has two writers: a
+   *  resumed process's recovered settlement, or the release sweep's terminal record marked
+   *  `retainedExecution: 'released'`. 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. */
   kind: 'reconciled';
   id: NodeId;
   spent: Spend;
+  /** The transcript receipt of a retained-pending child. This record is the ONLY durable home
+   *  it has: the node writes no `settled` record while its slot stays open, and these are the
+   *  #1244 children exactly — dropped mid-run with a live box the capture read. A later
+   *  terminal record for the node carries the same receipt forward. */
+  harnessTranscript?: HarnessTranscriptEvidence;
   seq: number;
   at: string;
 } | {
@@ -3890,7 +4030,11 @@ type SpawnEvent = {
    *  the environment its executor kept for recovery could never be recovered; this is the
    *  receipt of the supervisor's release, one per environment, naming the provider's own id
    *  so a fleet listing can be reconciled against it. A `destroyed: false` receipt carries why
-   *  in `detail`, and the node is then also journaled as `teardown-unconfirmed`.
+   *  in `detail`, and the node is then also journaled as `teardown-unconfirmed`. When every
+   *  receipt for a node is `destroyed: true` and the executor confirms teardown, the node's
+   *  terminal `settled`/`cancelled` record with `retainedExecution: 'released'` follows on
+   *  the same tree and closes the cursor slot; a `destroyed: false` receipt or an unconfirmed
+   *  teardown leaves the slot open because the environment may still exist.
    *  Informational: replay, `materializeTreeView`, and cost readers skip it, and its `seq` is
    *  per node, outside the cursor-uniqueness namespace. */
   kind: 'environment-teardown';
@@ -4042,7 +4186,11 @@ interface SupervisorOpts {
    * - `'release'`: the run will not be resumed, so nothing would ever reconcile or release those
    *   environments. The join barrier releases each one and journals an `environment-teardown`
    *   receipt per environment. Measured 2026-09-11: four settled runs held 18 of a 60-slot
-   *   Sandbox fleet for 19 to 37 hours without it.
+   *   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`.
    * - `'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
@@ -4148,6 +4296,53 @@ interface SpendGap {
   readonly kind: 'never-settled' | 'unreported';
   readonly channels: ReadonlyArray<SpendChannel>;
 }
+/**
+ * The recorded fate of a child whose provider execution was RETAINED: admitted durably, with no
+ * accepted terminal result when local observation stopped (the `RetainedExecutionPendingError`
+ * path). Not a failure classification — the child is `down` either way.
+ *
+ * - `'pending'`: the reservation was reconciled at a floor, the cursor slot is open, and the
+ *   environment is kept so a resume can reconcile the paid execution. Only ever on the in-memory
+ *   `Settled` and the first `agent.child` payload; the journal states it as the `reconciled`
+ *   record and replay never yields it. For an executor without `releaseRetained` it means only
+ *   that nothing could be released.
+ * - `'released'`: root settlement under `retainedAtSettlement: 'release'` destroyed the
+ *   environment (executor-confirmed) before any process recovered the execution; this is the
+ *   node's terminal record. The pool's own admission fault, if the reconcile raised one, is not
+ *   on this record.
+ *
+ * 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.
+ */
+type RetainedExecutionState = 'pending' | 'released';
+/**
+ * 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
+ * sweep wrote are included, and forest-wide so a director's grandchildren count (the population
+ * the observer projection shows). Invariant: `spawned === done + down + cancelled + neverSettled`.
+ * Distinct from a no-winner's `downCount`, the breaker's tally of ordinary down settlements: a
+ * released record is the driver's earlier down re-stated, so the breaker skips it and
+ * `downCount` never includes a retained child, while `down` here does. `spendGaps` stays
+ * root-tree scoped, so on a nested run the two disagree by design.
+ */
+interface FleetYield {
+  /** Every `spawned` record with a parent; the run root and an owned tree's re-rooted owner copy
+   *  are exempt. */
+  readonly spawned: number;
+  readonly done: number;
+  /** `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`. */
+  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;
+}
 /**
  * One channel on which a settled reservation's measured spend exceeded what it reserved.
  * `tokens` is in the pool's charged unit (`chargedTokens`), `usd` is measured dollars, and a
@@ -4200,6 +4395,8 @@ type SupervisedResult<Out> = {
   /** The journaled nodes whose usage accounting is incomplete — the named gaps behind a
    *  `false` `tokensKnown`/`usdKnown` on `spentTotal`. Present exactly when non-empty. */
   spendGaps?: ReadonlyArray<SpendGap>;
+  /** How the fleet ended, see `FleetYield`. Always present: zeros are facts. */
+  fleetYield: FleetYield;
   /** Where `spentTotal` went: `driverInference` = the drivers' own chat turns (metered via
    *  `Scope.meter`); `childWork` = every spawned child's reconciled spend (the journal sum).
    *  `driverInference + childWork === spentTotal` on `iterations`/`tokens`/`usd`; the
@@ -4245,6 +4442,8 @@ type SupervisedResult<Out> = {
   /** The journaled nodes whose usage accounting is incomplete — the named gaps behind a
    *  `false` `tokensKnown`/`usdKnown` on `spentTotal`. Present exactly when non-empty. */
   spendGaps?: ReadonlyArray<SpendGap>;
+  /** How the fleet ended, see `FleetYield`. Always present: zeros are facts. */
+  fleetYield: FleetYield;
   /** Never present on a lifecycle arm — the discriminant, not prose, is what makes
    *  `if (r.reason === 'driver-failed') r.error.message` compile and every other arm refuse it. */
   error?: never;
@@ -4292,6 +4491,8 @@ type SupervisedResult<Out> = {
   /** The journaled nodes whose usage accounting is incomplete — the named gaps behind a
    *  `false` `tokensKnown`/`usdKnown` on `spentTotal`. Present exactly when non-empty. */
   spendGaps?: ReadonlyArray<SpendGap>;
+  /** How the fleet ended, see `FleetYield`. Always present: zeros are facts. */
+  fleetYield: FleetYield;
   /** The driver's own rejection, carried across the typed no-winner boundary so the failure is
    *  recoverable by the caller. A non-`Error` rejection is normalized, never dropped. */
   error: NoWinnerError;
@@ -4341,5 +4542,5 @@ interface WidenGate<Out> {
   readonly judgeExempt?: boolean;
 }
 //#endregion
-export { Spend as $, RetainedInteractiveEnvironmentAdmission as $n, RunProvenance as $r, RuntimeStreamEventSummary as $t, NodeSnapshot as A, RuntimeCanonicalStreamEvent as Ai, ExecutorProgress as An, DefaultVerdict$1 as Ar, EvalRunsExportConfig as At, RootHandle as B, RetainedInteractiveStartMaterial as Bn, LoopPlanDescription as Br, buildLoopSpanNodes as Bt, ExecutorToolCall as C, BackendErrorDetail as Ci, TraceSource as Cn, ReservationHolder as Cr, TraceContext as Ct, NoWinnerError as D, OpenAIChatToolChoice as Di, ActivityLog as Dn, createBudgetPool as Dr, traceContextToEnv as Dt, MaterializedModelIdentity as E, OpenAIChatTool as Ei, sandboxSessionTraceSource as En, ReservationTicket as Er, readTraceContextFromEnv as Et, ResourceLimit as F, ReconnectRetainedInteractiveRunOptions as Fn, LoopEndedPayload as Fr, OtelExportConfig as Ft, Runtime as G, NativeContextContinuationExecution as Gn, LoopTeardownFailedPayload as Gr, generateSpanId as Gt, RootProviderModelEvidence as H, NativeSessionArtifact as Hn, LoopResult as Hr, createOpenInferenceFileExporter as Ht, ResourceSpend as I, RecoverRetainedInteractiveRunOptions as In, LoopIterationDispatchPayload as Ir, OtelExporter as It, SpawnEvent as J, ReconnectRetainedRunOptions as Jn, LoopTraceEvent as Jr, padTraceId as Jt, Scope as K, NativeContextContinuationHandle as Kn, LoopTokenUsage as Kr, loopEventToOtelSpan as Kt, ResultBlobStore as L, RetainedInteractiveAdmissionHook as Ln, LoopIterationEndedPayload as Lr, OtelSpan as Lt, ProfileMaterializationReceipt as M, RuntimeSessionStore as Mi, WorkerProgress as Mn, ExecCtx as Mr, INTELLIGENCE_WIRE_VERSION as Mt, ProviderModelAttemptEvidence as N, RuntimeStreamEvent as Ni, createActivityLog as Nn, Iteration as Nr, LoopSpanNode as Nt, NodeExecutionIdentity as O, RunAgentTaskOptions as Oi, ActivityNote as On, spendFromUsageEvents as Or, EvalRunEvent as Ot, ProviderModelExecutionEvidence as P, readWorkerProgress as Pn, LoopDecisionPayload as Pr, OtelAttribute as Pt, SpawnRejection as Q, RetainedInteractiveAdmission as Qn, OutputAdapter as Qr, RuntimeStreamEventSink as Qt, ResumedKeyState as R, RetainedInteractiveEnvironmentInput as Rn, LoopIterationStartedPayload as Rr, RuntimeEventOtelOptions as Rt, ExecutorTeardownWarning as S, AgentTaskStatus as Si, ToolStepInput as Sn, LeakedReservation as Sr, workerTraceSeamKey as St, MaterializedExecutionIdentity as T, OpenAIChatResponseFormat as Ti, decodeToolPart as Tn, ReservationStage as Tr, mergeTraceEnv as Tt, RootSignal as U, NativeSessionEvidence as Un, LoopSandboxPlacement as Ur, createOtelExporter as Ut, RootMaterialization as V, StartRetainedInteractiveRunOptions as Vn, LoopPlanPayload as Vr, buildRuntimeEventOtelSpans as Vt, RootStreamReceipt as W, NativeSessionFile as Wn, LoopStartedPayload as Wr, exportEvalRuns as Wt, SpawnOpts as X, RecoverRetainedRunOptions as Xn, MountManifestEntry as Xr, RuntimeEventCollector as Xt, SpawnJournal as Y, RecoverRetainedRunIntentOptions as Yn, LoopWinner as Yr, toOtelAttributes as Yt, SpawnPrior as Z, RecoverRetainedRunResult as Zn, MountRecorder as Zr, RuntimeStreamEventCollector as Zt, ExecutorMaterialization as _, AgentRuntimeEvent as _i, timerAt as _n, StartRetainedRunOptions as _r, WorkerTraceResolver as _t, BudgetOverspend as a, RuntimeRunCost as ai, sanitizeAgentRuntimeEvent as an, RetainedRunCancellation as ar, SupervisorOpts as at, ExecutorRegistry as b, AgentTaskRunResult as bi, SessionMessageLike as bn, BudgetReadout as br, workerTraceEnv as bt, EnvironmentTeardownReceipt as c, RuntimeRunPersistenceAdapter as ci, PendingWait as cn, RetainedRunEnvironmentAdmission as cr, UnconfirmedTeardown as ct, ExecutorAccounting as d, startRuntimeRun as di, WaitProbeRegistry as dn, RetainedRunIntentAdmission as dr, WaitOpts as dt, SandboxClient as ei, RuntimeTelemetryOptions as en, RetainedInteractiveIntentAdmission as er, SpendChannel as et, ExecutorCancellation as f, AgentAdapter as fi, WaitRejection as fn, RetainedRunReplayPoint as fr, WidenGate as ft, ExecutorFactory as g, AgentKnowledgeProvider as gi, pollFor as gn, StartRetainedRunInEnvironmentOptions as gr, WorkerTraceUnavailableReason as gt, ExecutorExecutionBinding as h, AgentExecutionBackend as hi, isWaitOutcome as hn, RetainedRunTurnInput as hr, WorkerTraceEvidence as ht, Budget as i, RuntimeRunCompleteInput as ii, createRuntimeStreamEventCollector as in, RetainedRunCancelOptions as ir, Supervisor as it, NodeStatus as j, RuntimeSession as ji, ScopeProgressInput as jn, Driver as jr, EvalRunsExportResult as jt, NodeId as k, RunAgentTaskStreamOptions as ki, DEFAULT_STALL_AFTER_MS as kn, AgentRunSpec as kr, EvalRunGeneration as kt, ExecutionBindingReceipt as l, RuntimeRunRow as li, WaitOutcome as ln, RetainedRunEventOptions as lr, UnknownMaterializationReason as lt, ExecutorContext as m, AgentBackendInput as mi, createWaitProbes as mn, RetainedRunStartMaterial as mr, WorkerInteractiveUnavailableReason as mt, AgentExecutionRef as n, ValidationCtx as ni, SanitizedKnowledgeRequirement as nn, RetainedRunAdmission as nr, SteerableRootHandle as nt, BudgetViolation as o, RuntimeRunHandle as oi, sanitizeKnowledgeReadinessReport as on, RetainedRunDispatchedAdmission as or, TokenUsageProvenance as ot, ExecutorCancellationRequest as p, AgentBackendContext as pi, WaitSpec as pn, RetainedRunSnapshot as pr, WorkerInteractiveSession as pt, Settled as q, NativeContextContinuationInput as qn, LoopTraceEmitter as qr, padSpanId as qt, AgentSpec as r, Validator as ri, createRuntimeEventCollector as rn, RetainedRunAdmissionHook as rr, SupervisedResult as rt, DefaultVerdict as s, RuntimeRunOptions as si, sanitizeRuntimeStreamEvent as sn, RetainedRunEffect as sr, TreeView as st, Agent as t, SelectionReceipt as ti, SanitizedKnowledgeReadinessReport as tn, RetainedInteractiveStartedAdmission as tr, SpendGap as tt, Executor as u, RuntimeRunStatus as ui, WaitProbe as un, RetainedRunHandle as ur, UsageEvent as ut, ExecutorNodeContext as v, AgentRuntimeEventSink as vi, validateWaitSpec as vn, BudgetPool as vr, WorkerTraceSeamCarrier as vt, Handle as w, KnowledgeReadinessDecision as wi, createPushTraceSource as wn, ReservationRejection as wr, createPropagatingTraceEmitter as wt, ExecutorResult as x, AgentTaskSpec as xi, SessionTraceBox as xn, BudgetReconcileFault as xr, workerTraceHeaders as xt, ExecutorProgressEvent as y, AgentTaskContext as yi, waitUntil as yn, BudgetPoolRestore as yr, readWorkerTraceContext as yt, ResumedWork as z, RetainedInteractiveRunHandle as zn, LoopLineageOptions as zr, buildLoopOtelSpans as zt };
-//# sourceMappingURL=types-DBovefLD.d.ts.map
+export { SpawnPrior as $, persistHarnessTranscript as $n, LoopStartedPayload as $r, RuntimeStreamEventCollector as $t, NodeId as A, AgentTaskSpec as Ai, ActivityNote as An, BudgetReconcileFault as Ar, EvalRunEvent as At, ResumedWork as B, RuntimeSession as Bi, RetainedInteractiveEnvironmentInput as Bn, Driver as Br, RuntimeEventOtelOptions as Bt, ExecutorToolCall as C, AgentBackendInput as Ci, SessionTraceBox as Cn, RetainedRunStartMaterial as Cr, workerTraceHeaders as Ct, MaterializedModelIdentity as D, AgentRuntimeEventSink as Di, decodeToolPart as Dn, BudgetPool as Dr, mergeTraceEnv as Dt, MaterializedExecutionIdentity as E, AgentRuntimeEvent as Ei, createPushTraceSource as En, StartRetainedRunOptions as Er, createPropagatingTraceEmitter as Et, ProviderModelExecutionEvidence as F, OpenAIChatTool as Fi, createActivityLog as Fn, ReservationTicket as Fr, LoopSpanNode as Ft, RootSignal as G, HarnessTranscriptCapture as Gn, LoopIterationDispatchPayload as Gr, createOtelExporter as Gt, RootHandle as H, RuntimeStreamEvent as Hi, RetainedInteractiveStartMaterial as Hn, Iteration as Hr, buildLoopSpanNodes as Ht, ResourceLimit as I, OpenAIChatToolChoice as Ii, readWorkerProgress as In, createBudgetPool as Ir, OtelAttribute as It, Scope as J, HarnessTranscriptUnavailable as Jn, LoopLineageOptions as Jr, loopEventToOtelSpan as Jt, RootStreamReceipt as K, HarnessTranscriptEvidence as Kn, LoopIterationEndedPayload as Kr, exportEvalRuns as Kt, ResourceSpend as L, RunAgentTaskOptions as Li, ReconnectRetainedInteractiveRunOptions as Ln, spendFromUsageEvents as Lr, OtelExportConfig as Lt, NodeStatus as M, BackendErrorDetail as Mi, ExecutorProgress as Mn, ReservationHolder as Mr, EvalRunsExportConfig as Mt, ProfileMaterializationReceipt as N, KnowledgeReadinessDecision as Ni, ScopeProgressInput as Nn, ReservationRejection as Nr, EvalRunsExportResult as Nt, NoWinnerError as O, AgentTaskContext as Oi, sandboxSessionTraceSource as On, BudgetPoolRestore as Or, readTraceContextFromEnv as Ot, ProviderModelAttemptEvidence as P, OpenAIChatResponseFormat as Pi, WorkerProgress as Pn, ReservationStage as Pr, INTELLIGENCE_WIRE_VERSION as Pt, SpawnOpts as Q, harnessTranscriptArtifact as Qn, LoopSandboxPlacement as Qr, RuntimeEventCollector as Qt, ResultBlobStore as R, RunAgentTaskStreamOptions as Ri, RecoverRetainedInteractiveRunOptions as Rn, AgentRunSpec as Rr, OtelExporter as Rt, ExecutorTeardownWarning as S, AgentBackendContext as Si, SessionMessageLike as Sn, RetainedRunSnapshot as Sr, workerTraceEnv as St, Handle as T, AgentKnowledgeProvider as Ti, TraceSource as Tn, StartRetainedRunInEnvironmentOptions as Tr, TraceContext as Tt, RootMaterialization as U, StartRetainedInteractiveRunOptions as Un, LoopDecisionPayload as Ur, buildRuntimeEventOtelSpans as Ut, RetainedExecutionState as V, RuntimeSessionStore as Vi, RetainedInteractiveRunHandle as Vn, ExecCtx as Vr, buildLoopOtelSpans as Vt, RootProviderModelEvidence as W, HarnessTranscriptArtifact as Wn, LoopEndedPayload as Wr, createOpenInferenceFileExporter as Wt, SpawnEvent as X, ReadableEnvironment as Xn, LoopPlanPayload as Xr, padTraceId as Xt, Settled as Y, HarnessTranscriptUnavailableReason as Yn, LoopPlanDescription as Yr, padSpanId as Yt, SpawnJournal as Z, captureHarnessTranscript as Zn, LoopResult as Zr, toOtelAttributes as Zt, ExecutorMaterialization as _, RuntimeRunPersistenceAdapter as _i, isWaitOutcome as _n, RetainedRunEnvironmentAdmission as _r, WorkerTraceEvidence as _t, BudgetOverspend as a, MountManifestEntry as ai, createRuntimeEventCollector as an, RecoverRetainedRunOptions as ar, SupervisedResult as at, ExecutorRegistry as b, startRuntimeRun as bi, validateWaitSpec as bn, RetainedRunIntentAdmission as br, WorkerTraceSeamCarrier as bt, EnvironmentTeardownReceipt as c, RunProvenance as ci, sanitizeKnowledgeReadinessReport as cn, RetainedInteractiveEnvironmentAdmission as cr, TokenUsageProvenance as ct, ExecutorAccounting as d, ValidationCtx as di, WaitOutcome as dn, RetainedRunAdmission as dr, UnknownMaterializationReason as dt, LoopTeardownFailedPayload as ei, RuntimeStreamEventSink as en, NativeContextContinuationExecution as er, SpawnRejection as et, ExecutorCancellation as f, Validator as fi, WaitProbe as fn, RetainedRunAdmissionHook as fr, UsageEvent as ft, ExecutorFactory as g, RuntimeRunOptions as gi, createWaitProbes as gn, RetainedRunEffect as gr, WorkerInteractiveUnavailableReason as gt, ExecutorExecutionBinding as h, RuntimeRunHandle as hi, WaitSpec as hn, RetainedRunDispatchedAdmission as hr, WorkerInteractiveSession as ht, Budget as i, LoopWinner as ii, SanitizedKnowledgeRequirement as in, RecoverRetainedRunIntentOptions as ir, SteerableRootHandle as it, NodeSnapshot as j, AgentTaskStatus as ji, DEFAULT_STALL_AFTER_MS as jn, LeakedReservation as jr, EvalRunGeneration as jt, NodeExecutionIdentity as k, AgentTaskRunResult as ki, ActivityLog as kn, BudgetReadout as kr, traceContextToEnv as kt, ExecutionBindingReceipt as l, SandboxClient as li, sanitizeRuntimeStreamEvent as ln, RetainedInteractiveIntentAdmission as lr, TreeView as lt, ExecutorContext as m, RuntimeRunCost as mi, WaitRejection as mn, RetainedRunCancellation as mr, WidenGate as mt, AgentExecutionRef as n, LoopTraceEmitter as ni, RuntimeTelemetryOptions as nn, NativeContextContinuationInput as nr, SpendChannel as nt, BudgetViolation as o, MountRecorder as oi, createRuntimeStreamEventCollector as on, RecoverRetainedRunResult as or, Supervisor as ot, ExecutorCancellationRequest as p, RuntimeRunCompleteInput as pi, WaitProbeRegistry as pn, RetainedRunCancelOptions as pr, WaitOpts as pt, Runtime as q, HarnessTranscriptFile as qn, LoopIterationStartedPayload as qr, generateSpanId as qt, AgentSpec as r, LoopTraceEvent as ri, SanitizedKnowledgeReadinessReport as rn, ReconnectRetainedRunOptions as rr, SpendGap as rt, DefaultVerdict as s, OutputAdapter as si, sanitizeAgentRuntimeEvent as sn, RetainedInteractiveAdmission as sr, SupervisorOpts as st, Agent as t, LoopTokenUsage as ti, RuntimeStreamEventSummary as tn, NativeContextContinuationHandle as tr, Spend as tt, Executor as u, SelectionReceipt as ui, PendingWait as un, RetainedInteractiveStartedAdmission as ur, UnconfirmedTeardown as ut, ExecutorNodeContext as v, RuntimeRunRow as vi, pollFor as vn, RetainedRunEventOptions as vr, WorkerTraceUnavailableReason as vt, FleetYield as w, AgentExecutionBackend as wi, ToolStepInput as wn, RetainedRunTurnInput as wr, workerTraceSeamKey as wt, ExecutorResult as x, AgentAdapter as xi, waitUntil as xn, RetainedRunReplayPoint as xr, readWorkerTraceContext as xt, ExecutorProgressEvent as y, RuntimeRunStatus as yi, timerAt as yn, RetainedRunHandle as yr, WorkerTraceResolver as yt, ResumedKeyState as z, RuntimeCanonicalStreamEvent as zi, RetainedInteractiveAdmissionHook as zn, DefaultVerdict$1 as zr, OtelSpan as zt };
+//# sourceMappingURL=types-F5MG_7Qq.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/agent-runtime",
-  "version": "0.231.1",
+  "version": "0.233.0",
   "description": "Shared task-lifecycle skeleton for agents: a recursive loop kernel for chat turns, one-shot tasks, and multi-attempt loops, with trace capture and eval-gated self-improvement. Domain behavior lives in adapters; scoring and ship-gates in @tangle-network/agent-eval.",
   "homepage": "https://github.com/tangle-network/agent-runtime#readme",
   "repository": {