@tangle-network/agent-runtime 6.0.8 → 8.0.0

package/dist/{types-w3Oo1uRJ.d.ts → types-C_qbnw9N.d.ts}

@@ -8,7 +8,7 @@ import { AgentEvalError, AgentEvalError as AgentEvalError$1, AgentEvalErrorCode,
 import { AgentRunOutcome } from "@tangle-network/sandbox/runtime";
 import { BackendType, CreateRequestOptions, CreateSandboxOptions, CreateSandboxOptions as CreateSandboxOptions$1, PromptOptions, SandboxEvent, SandboxEvent as SandboxEvent$1, SandboxInstance, SandboxInstance as SandboxInstance$1, SandboxResources } from "@tangle-network/sandbox";
 import { z } from "zod";
-import { AgentEnvironment, AgentEnvironment as AgentEnvironment$1, AgentEnvironmentCapabilities, AgentEnvironmentCapabilities as AgentEnvironmentCapabilities$1, AgentEnvironmentEvent, AgentEnvironmentEvent as AgentEnvironmentEvent$1, AgentEnvironmentProvider, AgentEnvironmentProvider as AgentEnvironmentProvider$1, AgentEnvironmentQuery, AgentEnvironmentStatus, AgentEnvironmentSummary, AgentSession, AgentSessionRef, AgentSessionStatus as AgentSessionStatus$1, AgentTurnFailure, AgentTurnInput, AgentTurnInput as AgentTurnInput$1, AgentTurnResult as AgentTurnResult$1, AgentTurnResult as AgentTurnResult$2, CheckpointRef, CheckpointRequest, CreateAgentEnvironmentInput, CreateAgentEnvironmentInput as CreateAgentEnvironmentInput$1, ExecRequest, ExecResult, ForkRequest, PlacementInfo, ResourceRequest, WorkspaceRequest } from "@tangle-network/agent-interface/environment-provider";
+import { AgentEnvironment, AgentEnvironment as AgentEnvironment$1, AgentEnvironmentCapabilities, AgentEnvironmentCapabilities as AgentEnvironmentCapabilities$1, AgentEnvironmentEvent, AgentEnvironmentEvent as AgentEnvironmentEvent$1, AgentEnvironmentProvider, AgentEnvironmentProvider as AgentEnvironmentProvider$1, AgentEnvironmentQuery, AgentEnvironmentStatus, AgentEnvironmentSummary, AgentSession, AgentSessionRef, AgentSessionStatus as AgentSessionStatus$1, AgentTurnFailure, AgentTurnInput, AgentTurnInput as AgentTurnInput$1, AgentTurnResult as AgentTurnResult$1, AgentTurnResult as AgentTurnResult$2, CheckpointRef, CheckpointRequest, CreateAgentEnvironmentInput, CreateAgentEnvironmentInput as CreateAgentEnvironmentInput$1, ExecRequest, ExecResult, ForkRequest, PlacementInfo, ResourceRequest as ResourceRequest$1, WorkspaceRequest } from "@tangle-network/agent-interface/environment-provider";
 import { watch } from "node:fs";
 import { ChildProcess } from "node:child_process";
 import { HarnessId, WorkspacePlanReceipt } from "@tangle-network/agent-profile-materialize";
@@ -65,13 +65,7 @@ type RetainedRunTurnInput = Omit<AgentTurnInput, 'contextTransfer'> & {
   readonly turnId: string;
   readonly contextTransfer?: ContextTransferRequest;
 };
-/**
- * Admission and terminal result for one same-session continuation.
- *
- * The provider resolves `admission` after it durably owns the next exact run
- * reference. `result` resolves when that run reaches its terminal result.
- * @stable
- */
+/** Admission once the next exact reference is durable, and the terminal result. @stable */
 interface NativeContextContinuationHandle {
   readonly admission: Promise<AgentExactRunControlRef>;
   readonly result: Promise<NativeContextContinuationExecution>;
@@ -97,14 +91,7 @@ interface RetainedRunHandle {
   continueNative(request: NativeContextContinuationRequest, turn: NativeContextContinuationInput): Promise<NativeContextContinuationExecution>;
   cancel(options: RetainedRunCancelOptions): Promise<RetainedRunCancellation>;
 }
-/**
- * Sanitized headless intent durable before environment creation.
- *
- * The request digest binds the public create and turn material without
- * retaining secret values. The original start material is required to replay
- * this record after a process crash.
- * @stable
- */
+/** Intent durable before create. The digest omits secrets; replay needs the original start material. @stable */
 interface RetainedRunIntentAdmission {
   readonly phase: 'intent';
   readonly provider: string;
@@ -135,14 +122,7 @@ interface RetainedRunDispatchedAdmission {
   readonly idempotencyKey: string;
   readonly turnId: string;
 }
-/**
- * Sanitized intent durable before an interactive environment create begins.
- *
- * The digest covers the public start and create material without retaining that
- * material. It never carries environment variables, secret values, or provider
- * options. The replay input supplies private values after this check.
- * @stable
- */
+/** Interactive intent durable before create. The digest omits secrets, env, and provider options. @stable */
 interface RetainedInteractiveIntentAdmission {
   readonly phase: 'interactive_intent';
   readonly provider: string;
@@ -174,16 +154,7 @@ interface RetainedInteractiveStartedAdmission {
 type RetainedInteractiveAdmission = RetainedInteractiveIntentAdmission | RetainedInteractiveEnvironmentAdmission | RetainedInteractiveStartedAdmission;
 /** One detached-run admission record the runtime persists before creation or dispatch proceeds. @stable */
 type RetainedRunAdmission = RetainedRunIntentAdmission | RetainedRunEnvironmentAdmission | RetainedRunDispatchedAdmission;
-/**
- * Awaited durability hook for retained admission records.
- *
- * The runtime blocks after the pre-create intent, environment creation, and
- * provider work until the hook resolves. No retained run becomes caller-visible
- * before its exact recovery record is durable. A rejection keeps provider state
- * for recovery when provider work has already started.
- *
- * @stable
- */
+/** Blocks until the admission is durable. A rejection keeps provider state already started. @stable */
 type RetainedRunAdmissionHook = (admission: RetainedRunAdmission) => Promise<void>;
 /** Environment, turn, and optional identity needed to replay one retained start. @stable */
 interface RetainedRunStartMaterial {
@@ -197,11 +168,7 @@ interface RetainedRunStartMaterial {
   readonly turn: RetainedRunTurnInput;
   /** Accepted destination to attach, without creating or replacing its environment. */
   readonly contextTransferReceipt?: ContextTransferReceipt;
-  /**
-   * Explicit dispatch coordinates. When omitted, the runtime mints
-   * deterministic coordinates from `(environment.idempotencyKey, turn.turnId)`
-   * so every process derives the same values.
-   */
+  /** Explicit coordinates. Omitted values are minted from the environment key and turn id. */
   readonly identity?: {
     readonly sessionId: string;
     readonly executionId: string;
@@ -214,6 +181,8 @@ interface StartRetainedRunOptions extends RetainedRunStartMaterial {
   readonly intent?: RetainedRunIntentAdmission;
   readonly onAdmission: RetainedRunAdmissionHook;
   readonly now?: () => number;
+  /** How long create may take after intent is durable. Absent uses the retained materialization bound. */
+  readonly materializationTimeoutMs?: number;
   /** Directory whose `<runId>/observer.jsonl` (intent run id) receives admissions for agent-runtime-top. */
   readonly journalRoot?: string;
 }
@@ -253,48 +222,18 @@ interface RecoverRetainedRunIntentOptions {
   readonly onAdmission: RetainedRunAdmissionHook;
   readonly now?: () => number;
 }
-/**
- * Pre-dispatch admission coordinates for one recovery attempt.
- *
- * A `phase: 'environment'` admission record carries these fields, so a caller
- * can pass that record after a crash before the dispatched record landed.
- *
- * @stable
- */
+/** Environment-phase coordinates, enough to recover before a dispatched record lands. @stable */
 interface RecoverRetainedRunOptions {
   readonly provider: AgentEnvironmentProvider;
   readonly environmentId: string;
   readonly sessionId: string;
   readonly executionId: string;
-  /**
-   * Transfer replay identity, when the crashed run started from an ACCEPTED
-   * context transfer: the original request and its authoritative receipt.
-   * Recovery repeats the receipt-authorized lookup and verifies the receipt's
-   * run binding — without it, an adapter that requires receipt-authorized
-   * lookup answers not_found, and one that does not can return a run the
-   * receipt never bound. Callers that persisted the turn's context-transfer
-   * material supply these; behavior is unchanged for runs that had none.
-   */
+  /** Accepted transfer request. Recovery repeats the receipt-authorized lookup; omit it only when the run had none. */
   readonly contextTransfer?: ContextTransferRequest;
   readonly transferReceipt?: ContextTransferReceipt;
   readonly now?: () => number;
 }
-/**
- * Outcome of one recovery attempt.
- *
- * `recovered` with `via: 'reattached'`: the provider self-identified the
- * original session with a strict exact reference matching the recorded
- * environment coordinates. `recovered` with `via: 'resumed'`: a pre-create
- * intent was replayed through the exact, idempotent create and dispatch; the
- * handle controls the admitted run, whether this call or the crashed one
- * dispatched it. `not_found`: the provider no longer holds the environment;
- * nothing remains to destroy. `unverifiable`: the environment exists but the
- * provider cannot self-identify the session. Never destroy on this outcome:
- * keep the environment, retry `reconnectRetainedRun` with a dispatched
- * admission record, or inspect it with provider-native tools.
- *
- * @stable
- */
+/** `reattached` matched the recorded session. `resumed` replayed intent. `not_found` has nothing to destroy. `unverifiable` keeps the environment. @stable */
 type RecoverRetainedRunResult = {
   readonly outcome: 'recovered';
   readonly via: 'reattached' | 'resumed';
@@ -324,6 +263,12 @@ declare class BackendTransportError extends AgentEvalError {
    * package does not understand, remains unknown to Runtime.
    */
   readonly providerDispatch?: 'not_started';
+  /**
+   * Bridge-owned proof that the refusal came from a full executor semaphore, not a
+   * provider: the request waited on the host's concurrency gate and was refused as
+   * capacity (`executor_saturated`, HTTP 429). Retryable after `Retry-After`.
+   */
+  readonly capacity?: true;
   /**
    * The upstream's own error class when it names one (the bridge's `parse_error`,
    * `not_configured`, a provider's `invalid_request_error`). A class the upstream never
@@ -347,6 +292,7 @@ declare class BackendTransportError extends AgentEvalError {
     remediation?: RuntimeFailureCause['remediation'];
     body?: string;
     providerDispatch?: 'not_started';
+    capacity?: true;
   });
 }
 /**
@@ -2326,6 +2272,28 @@ interface MaterializedExecutionIdentity {
   readonly kind: string;
   readonly id: string;
 }
+/** The box sizes the created environment reported as applied, or an explicit unknown. Known
+ * values come from the environment's normalized observation (`resources.effective`), never from
+ * the create input: the request was admission-validated, not applied, and the applied sizes stay
+ * comparable against what the guest itself reads from its cgroup limits. `origin` and
+ * `observedAt` carry the observation's provenance so an estimate is never mistaken for a
+ * provider-applied size; `accelerator` is the observation's hardware shape. */
+type MaterializedResources = {
+  readonly status: 'known';
+  readonly cpu?: number;
+  readonly memoryMb?: number;
+  readonly diskMb?: number;
+  readonly accelerator?: {
+    readonly kind: string;
+    readonly count: number;
+    readonly memoryMb?: number;
+  };
+  readonly origin: 'estimated' | 'measured' | 'reported';
+  readonly observedAt: string;
+} | {
+  readonly status: 'unknown';
+  readonly reason: string;
+};
 /**
  * Data-only declaration from trusted executor code about the exact sealed plan `execute` uses.
  * Scope snapshots this value and computes the durable receipt; callers never provide digests.
@@ -2340,6 +2308,8 @@ interface ExecutorMaterialization {
   readonly backend: string;
   /** Exact selected model, or an explicit unknown reason. */
   readonly model: MaterializedModelIdentity;
+  /** Applied resources the created environment reported, or an explicit unknown reason. */
+  readonly resources?: MaterializedResources;
   /** Backend-native session/run/request/process identity. */
   readonly execution: MaterializedExecutionIdentity;
   /** Named implementation that turns the effective profile into executable backend inputs. */
@@ -2375,6 +2345,7 @@ type ProfileMaterializationReceipt = {
   readonly runtime: Runtime;
   readonly backend: string;
   readonly model: MaterializedModelIdentity;
+  readonly resources: MaterializedResources;
   readonly execution: MaterializedExecutionIdentity;
   readonly materializer: string;
 } | {
@@ -2659,6 +2630,83 @@ interface BudgetPool {
  * none), an absolute instant. A resumed pool passes the ORIGINAL instant.
  */
 declare function createBudgetPool(root: Budget, runStartedAtMs: number, restore?: BudgetPoolRestore): BudgetPool;
+/** One journal tree in a recursively loaded supervision forest. */
+interface SpawnForestTree {
+  readonly root: NodeId;
+  /** Driver node that owns this tree; absent for the requested root tree. */
+  readonly ownerNodeId?: NodeId;
+  /** Journal tree containing `ownerNodeId`; absent for the requested root tree. */
+  readonly parentTreeRoot?: NodeId;
+  readonly events: ReadonlyArray<SpawnEvent>;
+  readonly view: TreeView;
+}
+/** One event with the journal tree that establishes its cursor namespace. */
+interface SpawnForestEvent {
+  readonly treeRoot: NodeId;
+  readonly event: SpawnEvent;
+}
+/** One flattened node with the journal tree that owns its records. */
+interface SpawnForestNode extends NodeSnapshot {
+  readonly treeRoot: NodeId;
+}
+/** A spawned worker with no terminal record in a cold snapshot. Resume treats the same state as
+ * in-doubt and conservatively retains its reservation. Root nodes and armed waits are excluded. */
+interface SpawnForestInDoubtNode {
+  readonly treeRoot: NodeId;
+  readonly nodeId: NodeId;
+  readonly label: string;
+  readonly runtime: Runtime;
+}
+/** A driver spawn whose owned journal tree was never begun before the process stopped. */
+interface SpawnForestMissingTree {
+  readonly parentTreeRoot: NodeId;
+  readonly ownerNodeId: NodeId;
+  readonly root: NodeId;
+}
+/** Complete cold-readable view of one recursive supervision run. */
+interface SpawnForest {
+  readonly root: NodeId;
+  readonly trees: ReadonlyArray<SpawnForestTree>;
+  readonly nodes: ReadonlyArray<SpawnForestNode>;
+  readonly events: ReadonlyArray<SpawnForestEvent>;
+  readonly inDoubt: ReadonlyArray<SpawnForestInDoubtNode>;
+  readonly missingTrees: ReadonlyArray<SpawnForestMissingTree>;
+}
+/**
+ * Load every journal tree owned by one recursive supervision run and flatten its nodes/events.
+ *
+ * Nested driver tree keys are a Runtime implementation detail; callers should use this reader
+ * instead of deriving or scanning keys themselves. The reader follows only the explicit
+ * `ownedTreeRoot` written after Runtime privately attested a recursive executor; the open runtime
+ * string `driver` is never treated as ownership. Legacy records without `ownedTreeRoot` are
+ * intentionally treated as leaves rather than guessing or scanning convention-derived keys.
+ * This preserves each tree's independent cursor namespace on flattened events.
+ * A driver whose subtree was never begun is reported in `missingTrees`; any spawned non-root node
+ * without a terminal record is reported in `inDoubt`, matching resume's conservative lost-work
+ * interpretation.
+ *
+ * This is a cold/quiescent reader, not a transaction across an actively mutating file. Every value
+ * returned is a detached immutable snapshot, so later journal writes or caller mutation cannot
+ * change the result already observed.
+ */
+declare function loadSpawnForest(journal: SpawnJournal, root: NodeId): Promise<SpawnForest>;
+/** Measured tokens remain usable without claiming the unreported remainder is zero. */
+interface SettledUsage {
+  readonly tokens: {
+    readonly status: 'known' | 'lower-bound' | 'unknown';
+    readonly input: number | null;
+    readonly output: number | null;
+    /** Null when legacy or unfinished work does not establish the number of attempts. */
+    readonly unknownAttempts: number | null;
+  };
+  readonly requestedModel: {
+    readonly id: string | null;
+    readonly harness: string | null;
+    readonly provider: string | null;
+  };
+  /** Observations only; providerModel separately states whether served identity is complete. */
+  readonly observedModels: ReadonlyArray<string>;
+}
 /** Live observation is bounded and process-local. A reconnect explicitly reports expired history. */
 interface WorkerEventCursor {
   readonly epoch: string;
@@ -2866,12 +2914,14 @@ interface UnconfirmedTeardown {
   readonly runtime: Runtime;
   readonly status: NodeStatus;
   /** The provider environments the node may still hold and nothing keeps on purpose, by the
-   *  provider's own id: what an operator's sweeper deletes. Present when the executor names at
-   *  least one (`Executor.heldEnvironments`); absence means nothing was named, never "nothing is
-   *  held". Never contains a kept environment. */
+   *  provider's own id. `reconcileUnconfirmedTeardowns` reads each one by that id and deletes it
+   *  only when the provider still holds it. Present when the executor names at least one
+   *  (`Executor.heldEnvironments`); absence means nothing was named, never "nothing is held".
+   *  Never contains a kept environment. */
   readonly environments?: ReadonlyArray<HeldEnvironment>;
   /** The environments the node holds on purpose, each with `keptFor` set: a retained execution
-   *  a resume reconciles, or a workspace preserved as evidence. A sweeper never deletes these. */
+   *  a resume reconciles, or a workspace preserved as evidence.
+   *  `reconcileUnconfirmedTeardowns` never reads or deletes these. */
   readonly kept?: ReadonlyArray<HeldEnvironment>;
   /** How many teardown requests Runtime sent the executor. */
   readonly attempts?: number;
@@ -2947,27 +2997,19 @@ interface WidenGate<Out> {
    *  must be explicitly argued per cell, never defaulted on). */
   readonly judgeExempt?: boolean;
 }
-/** Provider-observed model identity for the root manager's settled inference turns.
- * Runtime records this only from a Runtime-owned provider/bridge receipt; an authored profile
- * alias is never substituted when the provider omits the identity. */
+/** Provider receipts only; requested aliases never fill missing served identity. */
 type RootProviderModelEvidence = ProviderModelExecutionEvidence;
-/**
- * The root manager's retained provider stream: `<runDir>/root-stream.jsonl`, one line per
- * progress event the root's executor observed, referenced by the content address of the file's
- * bytes and its committed line count. Present exactly when the run had a run directory and a
- * Runtime-driven root that began at least one drive attempt; a caller-supplied harness leaves it
- * absent, never an empty receipt. Distinct from `outRef`, which on a `winner` names the SELECTED
- * CHILD's artifact.
- */
+/** Root executor progress, when captured; outRef instead names selected output. */
 interface RootStreamReceipt {
   /** `sha256:<hex>` over the file's bytes as they were when the receipt was taken. */
   readonly ref: string;
   /** Committed lines in the file. `0` is a root that drove and produced no observable output. */
   readonly events: number;
+  /** Subagent sessions the harness itself spawned, as its `task` tool results named them
+   *  (#1264: a completed subagent reached no record before). Absent when none were observed. */
+  readonly subagentSessionIds?: readonly string[];
 }
-/** One provider/harness inference attempt. An empty observation list means the attempt started but
- * no trusted served model identity arrived before it failed or ended, unless Router explicitly
- * proves that admission rejected it before provider dispatch. */
+/** An empty observation list is unknown served identity unless dispatch was proven not started. */
 interface ProviderModelAttemptEvidence {
   readonly observations: ReadonlyArray<string>;
   readonly identityConflict?: boolean;
@@ -2985,13 +3027,7 @@ type ProviderModelExecutionEvidence = {
   readonly models: ReadonlyArray<string>;
   readonly reason: 'provider-model-missing' | 'provider-model-conflict';
 };
-/**
- * A driver's `act()` rejection, normalized to serializable evidence so it survives the typed
- * no-winner boundary (an `Error` does not cross a structured-clone / JSON hop intact). A
- * non-`Error` rejection normalizes to `{ name: 'NonError', message }` — never dropped.
- * Exported so a consumer handling `reason: 'driver-failed'` names this type instead of retyping
- * its fields.
- */
+/** Serializable act() rejection; non-Errors retain name NonError and their message. */
 interface NoWinnerError {
   name: string;
   message: string;
@@ -2999,227 +3035,88 @@ interface NoWinnerError {
   /** Structural failure evidence captured before the rejection becomes message text. */
   failure?: RuntimeFailureCause;
 }
-/**
- * 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.
- */
+/** Children across the owned forest after the join barrier and release sweep.
+ * spawned === done + down + cancelled + neverSettled. Unlike the breaker's downCount,
+ * down includes released retained children. spendGaps and tree read the whole forest (#1189). */
 interface FleetYield {
-  /** Every `spawned` record with a parent; the run root and an owned tree's re-rooted owner copy
-   *  are exempt. */
+  /** Spawned children; excludes root and synthetic owned-tree root copies. */
   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, or a retained child of a run that
-   *  keeps its environments for a resume (`retainedAtSettlement: 'keep'`). Named after
-   *  `SpendGap`'s `never-settled`. */
+  /** Spawned without a terminal record: crash-orphaned or retained for resume. */
   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. */
+  /** Released without recovery; a subset of down + cancelled. */
   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. */
+  /** Teardown unconfirmed; a disjoint subset of down + cancelled. */
   readonly releaseUnconfirmed: number;
 }
-/** Typed terminal result (M2) — a no-winner is NEVER coerced to a best-effort output. */
+/** Terminal receipt fields accompany every outcome; usage preserves measured lower bounds.
+ * The established union arms remain explicit for consumers of the public declaration. */
 type SupervisedResult<Out> = {
   kind: 'winner';
   out: Out;
   outRef: string;
   verdict?: DefaultVerdict;
   tree: TreeView;
-  /** The run's terminal accounting. `iterations`/`tokens`/`usd` are per-channel journal sums;
-   *  `ms` is the wall clock from supervise start (the ORIGINAL root instant on a resumed run)
-   *  to this terminal state — executors under-report their own `ms` and parallel children
-   *  overlap, so a per-event sum cannot state the run's real duration. `tokensKnown`/`usdKnown`
-   *  are always explicit here: `true` is the checked claim that every spawn reached a terminal
-   *  record and every settled/metered record carried a complete receipt on that channel;
-   *  `false` comes with the unaccounted nodes named in `spendGaps`. */
   spentTotal: Spend;
-  /** Runtime-owned provider evidence for the root manager, when the root executed inference. */
+  readonly usage?: SettledUsage;
   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. */
   readonly continuation?: DriverContinuationRecord;
-  /** The root's caller-supplied attribution as it registered (`SuperviseOptions.execution`):
-   *  a fork's lineage keys, a SearchSpec's `searchSpecDigest`. Absent when the caller set none. */
   readonly execution?: AgentExecutionRef;
-  /** Runtime-owned provider evidence reduced across the complete journal forest. */
   readonly providerModel?: ProviderModelExecutionEvidence;
-  /** Settled children whose teardown stayed unconfirmed after the settlement retry window
-   *  (`teardownConfirmMs`) — the resources this run could not prove destroyed. Each names the
-   *  provider environments a sweeper deletes when its executor reports them, and each is
-   *  journaled as a `teardown-unconfirmed` event. Present exactly when non-empty; a healthy run
-   *  never carries it. */
   teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
-  /** 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
-   *  breakdown's `ms` fields stay executor-reported sums while `spentTotal.ms` is wall clock.
-   *  Present whenever any driver metered. */
   spentBreakdown?: {
     driverInference: Spend;
     childWork: Spend;
   };
 } | ({
-  /**
-   * The LIFECYCLE no-winner arms: the supervisor itself proved why nothing was delivered, so
-   * the reason is complete on its own and there is no driver rejection to hand back. A tripped
-   * breaker or every child down is `all-children-down`, a cascaded abort is `aborted`, the
-   * run's own `budget.deadlineMs` passing is `deadline`, and a spent token, iteration, dollar
-   * or resource pool is `budget-exhausted`. A run with no `deadlineMs` has no deadline ending.
-   * These outrank `driver-failed`: when the driver threw BECAUSE the pool emptied, the
-   * deadline passed or the run was aborted, the lifecycle cause is the explanation.
-   * One down child among delivered siblings is not a lifecycle cause; it rides `downCount`.
-   */
   kind: 'no-winner';
   tree: TreeView;
   downCount: number;
-  /** The conserved spend incurred before the run failed — real cost is paid even when no
-   *  worker delivers, so the caller always learns what the delegation actually spent. Summed
-   *  off the same journal the `winner` path reads, with the same contract: wall-clock `ms`,
-   *  explicit `tokensKnown`/`usdKnown`, gaps named in `spendGaps`. */
   spentTotal: Spend;
-  /** Runtime-owned provider evidence for the root manager, when the root executed inference. */
+  readonly usage?: SettledUsage;
   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. */
   readonly continuation?: DriverContinuationRecord;
-  /** The root's caller-supplied attribution as it registered (`SuperviseOptions.execution`):
-   *  a fork's lineage keys, a SearchSpec's `searchSpecDigest`. Absent when the caller set none. */
   readonly execution?: AgentExecutionRef;
-  /** Runtime-owned provider evidence reduced across the complete journal forest. */
   readonly providerModel?: ProviderModelExecutionEvidence;
-  /** Settled children whose teardown stayed unconfirmed after the settlement retry window
-   *  (`teardownConfirmMs`) — the resources this run could not prove destroyed. Each names the
-   *  provider environments a sweeper deletes when its executor reports them, and each is
-   *  journaled as a `teardown-unconfirmed` event. Present exactly when non-empty; a healthy run
-   *  never carries it. */
   teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
-  /** Budget reservations still open when the run reached its join barrier, each named by the
-   *  assignment, child id, and lifecycle stage that holds it. The conserved-pool identity
-   *  `total ≡ free + reserved + committed` does not hold, so `spentTotal` is a floor rather
-   *  than a measurement — the run still settles with the tree and the spend the journal
-   *  recorded. Present exactly when non-empty; a healthy run never carries it. */
   leakedReservations?: ReadonlyArray<LeakedReservation>;
-  /** 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;
 } & ({
-  /**
-   * `no-children-spawned`: the root ran to completion under budget, selected nothing, and
-   * never spawned a child. Until this arm existed that run settled `all-children-down`
-   * with `downCount: 0`, which reads as a fleet failure to anyone who did not open the
-   * journal; fifteen sandbox-placed directors settled that way in one week while the
-   * actual fault was that the root never recursed.
-   *
-   * `no-result-selected`: the root ran to completion under budget, spawned children, and
-   * selected nothing while no child was down when it settled. Until this arm existed that
-   * run also settled `all-children-down`: on the 2026-09-20 fleet corpus, 46 of the 57
-   * runs carrying that reason had zero down children in their own `fleetYield`, and a
-   * reader of the label learned that banking pages was losing. `all-children-down` now
-   * asserts what its name says: the supervisor observed a down child, a tripped breaker,
-   * or every child down, before the root settled.
-   *
-   * `stopped`: a flow graph's `stop` edge ended the run (`runGraph` names the edge and its
-   * reason on `GraphResult.stopped`). The run returns; it does not throw.
-   */
   reason: 'all-children-down' | 'no-children-spawned' | 'no-result-selected' | 'stopped' | 'budget-exhausted' | 'deadline' | 'aborted';
 } | {
   reason: 'cancelled';
   readonly source: string;
   readonly cancellationReason: string;
   readonly operationId?: string;
-  /** Who stopped the run, as its durable cancel request named them. Absent for an
-   *  in-process abort and for a request written before `cancelRun` required one. */
   readonly operator?: string;
 })) | {
-  /**
-   * The DRIVER-FAULT arm: `act()` rejected and no lifecycle cause (breaker/abort/budget/every
-   * child down) outranks it — so nothing about the tree explains the failure and the driver's
-   * own rejection is the only thing that does. It is therefore REQUIRED here. One down child
-   * among delivered siblings does not outrank it: that count rides `downCount`.
-   * `all-children-down` with `downCount: 0` used to be indistinguishable from an honest empty
-   * result; this arm is that configuration/authoring fault, named.
-   */
   kind: 'no-winner';
   reason: 'driver-failed';
   tree: TreeView;
   downCount: number;
-  /** The conserved spend incurred before the run failed — real cost is paid even when no
-   *  worker delivers, so the caller always learns what the delegation actually spent. Summed
-   *  off the same journal the `winner` path reads, with the same contract: wall-clock `ms`,
-   *  explicit `tokensKnown`/`usdKnown`, gaps named in `spendGaps`. */
   spentTotal: Spend;
-  /** Runtime-owned provider evidence for the root manager, when the root executed inference. */
+  readonly usage?: SettledUsage;
   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. */
   readonly continuation?: DriverContinuationRecord;
-  /** The root's caller-supplied attribution as it registered (`SuperviseOptions.execution`):
-   *  a fork's lineage keys, a SearchSpec's `searchSpecDigest`. Absent when the caller set none. */
   readonly execution?: AgentExecutionRef;
-  /** Runtime-owned provider evidence reduced across the complete journal forest. */
   readonly providerModel?: ProviderModelExecutionEvidence;
-  /** Settled children whose teardown stayed unconfirmed after the settlement retry window
-   *  (`teardownConfirmMs`) — the resources this run could not prove destroyed. Each names the
-   *  provider environments a sweeper deletes when its executor reports them, and each is
-   *  journaled as a `teardown-unconfirmed` event. Present exactly when non-empty; a healthy run
-   *  never carries it. */
   teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
-  /** Budget reservations still open when the run reached its join barrier, each named by the
-   *  assignment, child id, and lifecycle stage that holds it. The conserved-pool identity
-   *  `total ≡ free + reserved + committed` does not hold, so `spentTotal` is a floor rather
-   *  than a measurement — the run still settles with the tree and the spend the journal
-   *  recorded. Present exactly when non-empty; a healthy run never carries it. */
   leakedReservations?: ReadonlyArray<LeakedReservation>;
-  /** 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;
 };
 /** `'queued'` is an admitted child that holds its budget slice and waits for a worker slot
@@ -3252,9 +3149,9 @@ interface SpawnOpts {
    * always run.
    */
   readonly key?: string;
-  /** The settled sibling node this spawn replaces, so a run's record names which worker took over
-   *  whose work. The caller asserts the relation; the coordination `spawn_worker` tool admits only
-   *  a settled worker of the same manager. Journaled on `spawned` and on the `agent.spawn` hook. */
+  /** The sibling node this spawn revises or replaces, so a run's record names which worker took over
+   *  whose work. The caller asserts the relation; the coordination `spawn_worker` tool admits any
+   *  worker of the same manager, live or settled. Journaled on `spawned` and on the `agent.spawn` hook. */
   readonly successorOf?: NodeId;
   /**
    * With `key`: when the key's committed result ended over its budget and its environment is still
@@ -3540,83 +3437,41 @@ interface Budget {
   readonly deadlineMs?: number;
   readonly resources?: Readonly<Record<string, ResourceLimit>>;
 }
-/**
- * Conserved spend, reconciled from the normalized `UsageEvent` stream. Tokens and usd are separate
- * channels (never folded).
- *
- * `boxMinutes` is a REPORTED channel, not a conserved one: it is summed across a run and carried
- * in the journal, and the budget pool never reserves, commits, or refunds against it. `budget.ts`
- * holds the reason.
- */
+/** Conserved spend from the `UsageEvent` stream. Tokens and dollars stay separate.
+ *  `boxMinutes` is reported only: the pool does not reserve against it. */
 interface Spend {
   resources?: Readonly<Record<string, ResourceSpend>>;
   iterations: number;
   tokens: LoopTokenUsage;
-  /** Token accounting is known unless explicitly false. A false value marks work that HAPPENED with
-   *  an unreported token count: `tokens` then carries the known subtotal (often `{0,0}`) and must
-   *  not be read as the measured total. The twin of `usdKnown` on the token channel — an inference
-   *  turn whose provider reported no usage is recorded with this flag rather than omitted, because
-   *  omitting it makes the turn look free. */
+  /** False marks work that happened with an unreported count. `tokens` is then a floor, not the total. */
   tokensKnown?: boolean;
   /** Dollar accounting is known unless explicitly false. A false value must not be treated as $0
    *  when enforcing a dollar-denominated comparison or limit. */
   usdKnown?: boolean;
   usd: number;
-  /** The part of `usd` that is a PRICE rather than a charge, because no provider receipt covered
-   *  the work: a model catalog's own number, or a figure a provider stated but did not bill.
-   *  `usd - usdEstimated` is what a provider is known to have billed. Present only with
-   *  `usdKnown: false`; absence means nothing here was priced, not that `usd` is measured. */
+  /** The priced part of `usd`, present only with `usdKnown: false`. `usd - usdEstimated` was billed. */
   usdEstimated?: number;
   ms: number;
-  /**
-   * Platform box wall time in minutes — the third conserved channel, beside tokens and dollars.
-   *
-   * A run on a subscription seat has no marginal dollar per model call, so box time is the only
-   * real resource it consumes. Before this channel existed such a run reported `$0` with nothing
-   * beside it and was unaccountable by construction.
-   *
-   * ABSENT when nothing was measured. Never `0` for unknown: a zero would claim the box consumed
-   * no platform time, which is a different fact from a box nobody metered. The field is absent
-   * entirely on a run with no box (router, cli-bridge, inline), because "not applicable" is not
-   * the same fact as "unmeasured" either.
-   */
+  /** Platform box minutes. Absent when unmeasured or when no box ran. Never `0` for unknown. */
   boxMinutes?: number;
-  /** True when this record states its box time. `false` says a box RAN and its lifetime could not
-   *  be paired, so `boxMinutes` — when present at all — is a floor, never the total. The twin of
-   *  `tokensKnown` and `usdKnown` on the platform channel. */
+  /** False: a box ran and `boxMinutes`, if present, is a floor. */
   boxMinutesKnown?: boolean;
-  /**
-   * How `boxMinutes` was obtained, in the vocabulary `agent-eval`'s cost ledger already uses
-   * (`CostProvenance`, `cost-ledger.ts`).
-   *
-   * `'observed'` — the platform itself reported the minutes.
-   * `'estimated'` — this runtime derived them from the box lifetime it watched. A derived number
-   *   is not a platform receipt, and the conserved pool never reserves against it.
-   * `'uncaptured'` — a box ran and nothing measured its time. Comes WITHOUT `boxMinutes`.
-   */
+  /** `observed` is the platform's number. `estimated` is derived and not reserved against.
+   *  `uncaptured` means a box ran and comes without `boxMinutes`. */
   boxMinutesProvenance?: 'observed' | 'estimated' | 'uncaptured';
-  /**
-   * How the token counters in `tokens` were obtained, when this record states it.
-   *
-   * ABSENT means every count came from the executor's live stream, which is what every path
-   * reported before harness stores were readable. `'harness-store'` says the harness's own file was
-   * the receipt; `'mixed'` says both sources contributed to this settlement.
-   *
-   * This is a provenance fact, not a confidence one: a store read is the provider's own number and
-   * carries `tokensKnown: true`. The twin of `boxMinutesProvenance` on the token channel.
-   */
+  /** Where `tokens` came from. Absent means the live stream. A store read still has `tokensKnown: true`. */
   tokensProvenance?: TokenUsageProvenance;
+  /** Tokens the live stream had reported when a broken stream's exact result arrived. `tokens` stays the recorded total. */
+  streamedTokens?: LoopTokenUsage;
+  /** Recorded total minus `streamedTokens`, for each counter that grew. Absent when the exact result did not exceed the stream. */
+  unobservedTokens?: LoopTokenUsage;
+  /** False when `iterations` is only the provider-invocation floor: the exact result exceeded the stream, so this count does not name the model calls. */
+  iterationsKnown?: false;
 }
 /** The accounting channels a usage gap leaves incomplete. */
 type SpendChannel = 'tokens' | 'usd' | `resource:${string}`;
-/**
- * One journaled node whose usage accounting is incomplete — the named gap behind a `false`
- * `tokensKnown`/`usdKnown` on a terminal `spentTotal`. `never-settled`: the spawn is durable but
- * no terminal record landed, so the whole subtree is unaccounted on every channel and
- * `spentTotal` charges its budget ceiling instead of a fabricated zero. `unreported`: a settled
- * or metered record landed without a complete provider receipt, so the summed numbers are a
- * floor on the named channels, never the measured total.
- */
+/** A node with missing usage. Recorded subtotals are lower bounds; never-settled
+ * work has no terminal receipt and unreported work has an incomplete one. */
 interface SpendGap {
   readonly id: NodeId;
   /** The spawn label, when the node's `spawned` event is in this journal tree. */
@@ -3636,15 +3491,7 @@ interface BudgetOverspend {
   readonly reserved: number;
   readonly spent: number;
 }
-/**
- * A settled reservation whose measured spend exceeded what it reserved.
- *
- * It records an accounting fact, not an outcome. A child that completed stays `done` with its
- * artifact, and a child that failed stays `down`. The pool commits the true spend, so its free
- * balance already carries the overspend and later reservations are refused on their own.
- * Spend the pool cannot verify (unknown dollars under a dollar cap, unknown or overflowing
- * resource usage) is not an overspend: it fails the child closed instead.
- */
+/** Measured spend past the reservation. The child stays done or down; unverifiable spend fails closed. */
 interface BudgetViolation {
   /** Every overspent channel, in the order tokens, iterations, usd, then resources. Never empty. */
   readonly overspent: ReadonlyArray<BudgetOverspend>;
@@ -3956,13 +3803,8 @@ declare function createPropagatingTraceEmitter(ctx: TraceContext): {
  * `SupervisorSpanRecorder.workerTrace` and threaded to the scope as `SupervisorOpts.workerTrace`.
  */
 type WorkerTraceResolver = (spawningNodeId: string) => TraceContext | undefined;
-/**
- * Owns the conserved pool, the spawn log, the abort cascade, the OTP intensity breaker,
- * and the root handle. `run` executes the root `Agent` to completion; `attach` wires a
- * live `RootHandle` (the Q2 substrate the chat/pi-viz client later consumes).
- *
- * @stable
- */
+/** Runs a root under the conserved pool, durable journal, abort cascade and restart breaker.
+ * @stable */
 interface Supervisor<Task, Out> {
   run(root: Agent<Task, Out>, task: Task, opts: SupervisorOpts): Promise<SupervisedResult<Out>>;
   attach(h: RootHandle<Out>): void;
@@ -3972,20 +3814,14 @@ interface Supervisor<Task, Out> {
 interface RecursiveReservationPolicy {
   readonly ownerShare: number;
 }
-/**
- * What a root runs on during one segment of its run.
- *
- * Its profile's `model.provider`, `model.default`, `model.reasoningEffort` and `harness`, and the
- * package versions the caller ran it under. A run is one id for its whole life; a turn that ends, a lost stream or a dead supervisor is a
- * boundary between entries, and an entry on anything else here starts a new segment.
- */
+/** One root's model, harness and package versions. Changed execution starts a new segment
+ * under the same run id; a turn, lost stream or restart is only a new entry. */
 interface RootSegment {
   readonly provider?: string;
   readonly model?: string;
   readonly reasoningEffort?: ReasoningEffort;
   readonly harness?: string;
-  /** The package versions the caller runs this segment under, by package name (its Runtime among
-   *  them). Runtime records them and never reads them. */
+  /** Caller package versions; recorded without interpretation. */
   readonly stack?: Readonly<Record<string, string>>;
 }
 /** The segment a root enters with this process. */
@@ -4001,6 +3837,8 @@ interface SupervisorOpts {
   readonly budget: Budget;
   /** Exact root profile/task identity supplied by the one-call composition surface. */
   readonly rootIdentity?: NodeExecutionIdentity;
+  /** Authored request, independent of whether the root uses an external executor. */
+  readonly requestedProfile?: import('@tangle-network/agent-interface').AgentProfile;
   /** The segment this entry runs the root in. `rootIdentity` stays the recorded root's; when the
    *  segment differs from the one the run last ran, the journal gains one `root-segment` record. A
    *  fresh run refuses a segment that changes the recorded profile's model or harness. */
@@ -4052,23 +3890,10 @@ interface SupervisorOpts {
    * teardown.
    */
   readonly childSettleGraceMs?: number | null;
-  /**
-   * How long the join barrier keeps retrying a settled child's teardown until the executor
-   * confirms its resources are destroyed. A child's first teardown gets a short acknowledgement
-   * window, and a provider delete that fails or answers late then left the sandbox running: on
-   * 2026-09-20, cancelling 20 Discovery lanes left 2 workers running, and 136 of 612 agents
-   * across that campaign ended with teardown unconfirmed. The barrier re-asks each unconfirmed
-   * child with exponential backoff (starting at 1/300 of this window, doubling, capped at 1/10 of
-   * it) and releases a failed retained environment again under `retainedAtSettlement:
-   * 'release'`. A child still unconfirmed when the window closes is named in
-   * `teardownUnconfirmed` with the environment ids its executor reports, and journaled. The
-   * nodes pending when the window opens are journaled first as `teardown-pending`, so a process
-   * that dies inside the window still leaves their environment ids on record. A retained
-   * environment kept for a resume is not retried, and neither is an answer the executor marks
-   * `permanent`. The window runs after the run's deadline too: a deadline stops work, not
-   * cleanup, so settlement can return up to this long after it. `0` makes one attempt only.
-   * Default: 300000 (5 minutes).
-   */
+  /** Teardown retry window, including after the run deadline. Pending environments are
+   * journaled before retry; unresolved teardown is named in teardownUnconfirmed.
+   * Kept environments and permanent refusals are not retried. Zero makes one attempt.
+   * supervisor-child-join.ts owns DEFAULT_TEARDOWN_CONFIRM_MS and retry backoff. */
   readonly teardownConfirmMs?: number;
   /**
    * Load prior journal state and expose committed settlements through `Scope.resume`.
@@ -4082,35 +3907,13 @@ interface SupervisorOpts {
    * @experimental
    */
   readonly resume?: boolean;
-  /**
-   * What root settlement does with a provider environment that a settled child still holds for a
-   * RETAINED execution (`Executor.releaseRetained`). Such a child settles `down` with its cursor
-   * slot open and its environment alive, because a later process that resumes this run reconciles
-   * the paid execution inside it.
-   *
-   * - `'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. Four settled runs held 18 of a 60-slot
-   *   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 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
-   * `'release'`. A caller that owns finality says so: `supervisePursuit` records a settle record
-   * that refuses re-entry, so it always releases. A process crash never reaches settlement, so it
-   * releases nothing under either value.
-   */
+  /** Held execution fate at root settlement. Release journals environment teardown and closes
+   * each cursor, marking unconfirmed teardown release-unconfirmed. A later resume heals a
+   * crash between confirmed teardown and terminal publication from its durable floor.
+   * Keep preserves environments for resume and is the default when resume is enabled;
+   * otherwise release is the default. supervisePursuit always releases because its sealed
+   * result refuses re-entry. Process death does not itself release environments.
+   * Missing receipts always leave measured terminal usage incomplete. */
   readonly retainedAtSettlement?: 'release' | 'keep';
   readonly now?: () => number;
   readonly signal?: AbortSignal;
@@ -4198,7 +4001,7 @@ type SpawnEvent = {
   key?: string;
   /** Manager-scoped assignment identity used to join unkeyed and keyed work alike. */
   assignmentId?: string;
-  /** The settled sibling node this spawn replaces (`SpawnOpts.successorOf`). */
+  /** The sibling node this spawn revises or replaces (`SpawnOpts.successorOf`). */
   successorOf?: NodeId;
   /** The budget-stopped node whose held environment and session this node continues. */
   continues?: {
@@ -5266,66 +5069,6 @@ declare class FileResultBlobStore implements ResultBlobStore {
   get(outRef: string): Promise<unknown | undefined>;
   private blobPath;
 }
-/** One journal tree in a recursively loaded supervision forest. */
-interface SpawnForestTree {
-  readonly root: NodeId;
-  /** Driver node that owns this tree; absent for the requested root tree. */
-  readonly ownerNodeId?: NodeId;
-  /** Journal tree containing `ownerNodeId`; absent for the requested root tree. */
-  readonly parentTreeRoot?: NodeId;
-  readonly events: ReadonlyArray<SpawnEvent>;
-  readonly view: TreeView;
-}
-/** One event with the journal tree that establishes its cursor namespace. */
-interface SpawnForestEvent {
-  readonly treeRoot: NodeId;
-  readonly event: SpawnEvent;
-}
-/** One flattened node with the journal tree that owns its records. */
-interface SpawnForestNode extends NodeSnapshot {
-  readonly treeRoot: NodeId;
-}
-/** A spawned worker with no terminal record in a cold snapshot. Resume treats the same state as
- * in-doubt and conservatively retains its reservation. Root nodes and armed waits are excluded. */
-interface SpawnForestInDoubtNode {
-  readonly treeRoot: NodeId;
-  readonly nodeId: NodeId;
-  readonly label: string;
-  readonly runtime: Runtime;
-}
-/** A driver spawn whose owned journal tree was never begun before the process stopped. */
-interface SpawnForestMissingTree {
-  readonly parentTreeRoot: NodeId;
-  readonly ownerNodeId: NodeId;
-  readonly root: NodeId;
-}
-/** Complete cold-readable view of one recursive supervision run. */
-interface SpawnForest {
-  readonly root: NodeId;
-  readonly trees: ReadonlyArray<SpawnForestTree>;
-  readonly nodes: ReadonlyArray<SpawnForestNode>;
-  readonly events: ReadonlyArray<SpawnForestEvent>;
-  readonly inDoubt: ReadonlyArray<SpawnForestInDoubtNode>;
-  readonly missingTrees: ReadonlyArray<SpawnForestMissingTree>;
-}
-/**
- * Load every journal tree owned by one recursive supervision run and flatten its nodes/events.
- *
- * Nested driver tree keys are a Runtime implementation detail; callers should use this reader
- * instead of deriving or scanning keys themselves. The reader follows only the explicit
- * `ownedTreeRoot` written after Runtime privately attested a recursive executor; the open runtime
- * string `driver` is never treated as ownership. Legacy records without `ownedTreeRoot` are
- * intentionally treated as leaves rather than guessing or scanning convention-derived keys.
- * This preserves each tree's independent cursor namespace on flattened events.
- * A driver whose subtree was never begun is reported in `missingTrees`; any spawned non-root node
- * without a terminal record is reported in `inDoubt`, matching resume's conservative lost-work
- * interpretation.
- *
- * This is a cold/quiescent reader, not a transaction across an actively mutating file. Every value
- * returned is a detached immutable snapshot, so later journal writes or caller mutation cannot
- * change the result already observed.
- */
-declare function loadSpawnForest(journal: SpawnJournal, root: NodeId): Promise<SpawnForest>;
 /**
  * Materialize a recorded `TreeView` from a journaled event list for inspection. Folds
  * `spawned`/`settled`/`cancelled` into a per-node snapshot in `seq` order, then adds each
@@ -6512,6 +6255,19 @@ type CoordinationEvent = {
   readonly type: 'tool-outcome';
   readonly outcome: ToolOutcomeEvent;
 } |
+/** Server timing of one coordination tool call. Record-only: it never wakes the manager.
+ *  `receivedAt` is the server clock when the handler started, `elapsedMs` is that handler's
+ *  duration, and `responseBytes` is the UTF-8 size of its JSON result or error message. */
+{
+  readonly type: 'tool-timing';
+  readonly call: {
+    readonly tool: string;
+    readonly receivedAt: number;
+    readonly elapsedMs: number;
+    readonly responseBytes: number;
+    readonly ok: boolean;
+  };
+} |
 /** This manager's lead (its parent manager, or the operator for a root) sent it a steer or an
  *  answer. Queued: a manager's harness has no live inbox between turns, so the message is the
  *  input of its next wake instead of a refused delivery. */
@@ -9104,49 +8860,14 @@ interface ResolvedMcpServerLaunch {
  */
 declare function resolveMcpServerLaunch(server: AgentProfileMcpServer, keys: KeyProvider | undefined, label: string): Promise<ResolvedMcpServerLaunch>;
 /**
- * cli-bridge seam. A local OpenAI-compatible bridge that fronts harness CLIs
- * (claude-code / opencode / kimi / pi) behind one HTTP surface. The spawned
- * `AgentProfile` is the sole harness/provider/model and behavioral authority and
- * is forwarded verbatim per request; this seam carries transport data only.
- *
- * The executor opens a resumable cli-bridge session. `sessionId` identifies the
- * harness conversation across turns; each turn also receives its own durable run id.
- * A dropped HTTP reader reattaches to that exact run and explicit cancel is the only
- * operation allowed to stop it. Omit `sessionId` and the executor mints one per spawn.
- *
- * ── HOW TO CONTROL WHAT THE HARNESS LOADS (there is no argv field, by design) ──
- *
- * A worker often needs the harness started in a KNOWN state — no ambient extensions, skills,
- * context files, or prompt templates — because ambient state is how a paired experiment silently
- * loses its pairing: an installed extension that persists memory across runs carries arm A's state
- * into arm B, and nothing reports it.
- *
- * That is what the spawned `AgentProfile` is FOR. `agent_profile`
- * rides every request verbatim, and cli-bridge maps it onto each harness's own native controls:
- *
- *   - Materializing any profile at all already starts the harness isolated from ambient
- *     workspace state — for pi that is `--no-context-files --no-skills --no-prompt-templates`,
- *     applied to every request that carries an `agent_profile`.
- *   - `AgentProfile.extensions.<harness>` is the named, per-harness control channel. An explicit
- *     `extensions: { pi: { load: [] } }` disables ambient extension discovery outright
- *     (pi's `--no-extensions`); listing package names loads exactly those and nothing else.
- *   - `permissions` / `tools` / `mcp` map onto the harness's native tool and server controls.
- *
- * A caller therefore does NOT need to hand-roll an `Executor` to isolate a harness run, and the
- * profile expressing it stays portable: the same declaration means the same thing on a different
- * harness, whereas an argv string means nothing anywhere else.
- *
- * WHY NOT A GENERAL ARGV PASSTHROUGH. `bridgeUrl` addresses a process-spawning server. Forwarding
- * an arbitrary argv array to it would let any caller holding a bearer token choose the flags of a
- * process on the bridge host — which for real harness CLIs includes flags that load code from a
- * path, read a file into the prompt, redirect the working directory, or turn off the isolation the
- * bridge applies. cli-bridge deliberately confines workers (a filesystem jail and deny-by-default
- * network egress), and every one of those confinements is expressed as spawn configuration, so an
- * argv channel is a channel for unwinding them. It would also break this executor's own contract:
- * the durable-run replay protocol, session pinning, and streaming mode are all argv the bridge
- * owns, and a caller-supplied duplicate silently wins or corrupts the parse. The structured profile
- * channel is validated, per-harness, portable, and refuses controls it does not understand — keep
- * new harness capability there.
+ * cli-bridge transport seam. The spawned `AgentProfile` is the harness authority and is forwarded
+ * verbatim; this seam carries transport only. `sessionId` is the harness conversation; each turn has
+ * its own run id. A dropped reader reattaches to that run, and explicit cancel is the only stop.
+ * Omit `sessionId` and the executor mints one. There is no argv field: materializing a profile
+ * isolates the harness from ambient workspace state, `extensions.<harness>` chooses which extensions
+ * load, and `permissions` / `tools` / `mcp` map to the harness's own controls. An argv array would
+ * let a bearer token unwind the bridge's jail and egress policy and collide with the replay,
+ * session, and streaming flags the bridge owns.
  */
 interface BridgeSeam {
   bridgeUrl: string;
@@ -9812,6 +9533,8 @@ interface ProviderSeam extends ProviderExecutorOptions {
    * environment that every co-tenant of a shared box could read.
    */
   shared?: SharedBoxPlacement;
+  /** Largest `spawn_worker` `resources` a worker may request; above it is refused (#1277). */
+  maxWorkerResources?: ResourceRequest;
 }
 /**
  * Router seam WITH tool use — the tool-using router backend. Same direct
@@ -10055,9 +9778,14 @@ interface SpawnResourceReader {
 }
 /**
  * The environment reader: a manager running inside a provider environment whose `read()` serves
- * its own workspace. The provider owns containment — it will not serve a path outside the box —
- * but the relative-path and `..` rules are enforced here too, so the refusal names the rule the
- * manager broke rather than whatever the provider says about an escape it declined.
+ * its own workspace. Containment of relative paths is the provider's property, not this
+ * function's: the tangle sidecar enforces it in `resolveWorkspacePath`
+ * (apps/sidecar/src/lib/workspace.ts:98-155, agent-dev-container) — relative paths stay inside
+ * the sandbox workspace, absolute paths only through an allowlist, `.sidecar/` refused at any
+ * depth because that tree holds the guest's orchestrator token. If that enforcement widened,
+ * this reader would serve files from outside the workspace; the absolute, `..`, and `.sidecar`
+ * refusals below are belt-and-braces so it stays correct for every path shape they can name
+ * (#1284).
  *
  * `read()` returns a string, so an environment cannot hand back bytes that are not UTF-8; the
  * provider has already decoded. The size bound is checked on what arrives.
@@ -10614,37 +10342,29 @@ type SupervisorFinalizer = (ctx: FinalizeContext) => Promise<unknown | undefined
  *  existing caller had: the highest-scoring delivered child's output, `undefined` when nothing
  *  delivered (or the best delivered child carries no artifact). */
 declare const bestDelivered: SupervisorFinalizer;
-/** What the next drive continues, as the drive harness can prove it before the turn starts. */
 interface ReentryContinuity {
-  /** `continued`: the next turn is sent into the harness session that received the last one.
-   *  `new`: a new harness session, which knows only what its task says. */
+  /** `continued` reuses the harness session. `new` knows only this task. */
   readonly session: 'continued' | 'new';
-  /** Whether the next drive runs in the environment the previous drive used. `replaced` names a
-   *  previous environment the provider no longer holds. */
+  /** `replaced` names an environment the provider no longer holds. */
   readonly environment: 'same' | 'replaced' | 'unknown';
   readonly environmentId?: string;
   readonly previousEnvironmentId?: string;
-  /** What the next environment holds of the previous one's files. `restored`: the files as of
-   *  the checkpoint taken at `checkpointAt`; anything written after it is gone. */
+  /** `restored` is the checkpoint at `checkpointAt`. Later writes are gone. */
   readonly workspace: 'kept' | 'restored' | 'lost' | 'unknown';
   readonly checkpointAt?: string;
 }
-/** Continuity when nothing is proven: compose the full state. */
+/** What a re-entry may assume when nothing proved its session, environment or workspace. */
 declare const UNPROVEN_CONTINUITY: ReentryContinuity;
 interface ReentryTaskInput {
-  /** The run's original task, exactly as the first drive received it. */
   readonly originalTask: unknown;
-  /** What the completion check requires, when the caller described it. */
   readonly contract?: string;
-  /** Coordination tools served to this manager. Absent means none are proven available. */
   readonly tools?: ReadonlyArray<string>;
   readonly reentry: DriverReentry;
   readonly continuity: ReentryContinuity;
   readonly state: ManagerReentryState;
-  /** 1-based driver attempt this task starts. */
   readonly attempt: number;
 }
-/** Compose the task for one re-entered drive. */
+/** The task a re-entered driver receives: what changed, why it re-entered, and its objective. */
 declare function composeReentryTask(input: ReentryTaskInput): string;
 /** The read-model a `StopRule` decides from — the run's progress, not its budget. */
 interface ProgressView {
@@ -11382,134 +11102,562 @@ declare function subscriptionUsageLimitSignal(failure: {
   readonly error: string;
   readonly errorCode?: string;
 }): 'subscription-usage-limit' | undefined;
-/** A name→value table in this package's resolver-port shape: construction stays the caller's,
- *  lookup stays lazy, and a table backed by a file, a plugin loader, or a plain object all
- *  satisfy one interface. */
-interface SuperviseRegistryTable<T> {
-  resolve(name: string): T | undefined;
-  /** The names the table holds. The three code-valued tables may omit it, because a caller names
-   *  their entries from data it already has. The profiles table must list them, because a
-   *  director can choose only from a menu it can read. */
-  names?(): readonly string[];
+/** Record-owned policy data; callbacks, panel execution and a host-computed best stay outside. */
+type PortableContinuationPolicy = Omit<ContinuationPolicy, 'append' | 'runPanel' | 'panel' | 'panelUsd' | 'best'> & {
+  readonly panel: 'off';
+};
+/** The canonical policy admission, restricted to portable JSON rather than host callbacks. */
+declare const portableContinuationPolicySchema: z.ZodPipe<z.ZodUnknown, z.ZodTransform<PortableContinuationPolicy, unknown>>;
+/** A flow node's usable settle matched no routes edge leaving it (`unrouted`), or a fired edge named
+ *  a node that still had a running worker (`target-live`). The flow spawned nothing more; the full
+ *  evidence rides on the error, shaped like `GraphEdgeCapError`. */
+declare class GraphRouteError extends Error {
+  readonly reason: 'unrouted' | 'target-live';
+  readonly node: NodeId;
+  readonly workerId: string;
+  readonly ledger: ReadonlyArray<EdgeTraversal>;
+  readonly result: SupervisedResult<unknown>;
+  constructor(unrouted: {
+    readonly reason: 'unrouted' | 'target-live';
+    readonly node: NodeId;
+    readonly workerId: string;
+    readonly detail: string;
+  }, ledger: ReadonlyArray<EdgeTraversal>, result: SupervisedResult<unknown>);
 }
-/**
- * The name→value tables that make the three CODE-valued options expressible as run DATA, and the
- * profiles a director may spawn by name.
- *
- * `deliverable` / `finalizer` / `analysts` are functions and registries, so a recorded
- * run configuration (a JSON row, a campaign spec, a resumed run's options) cannot carry them — and
- * a run with no `deliverable` cannot return a `winner` at all outside the sandbox backend, because
- * the finalizer keeps only children whose oracle passed and nothing else writes that verdict. A
- * caller that owns the code registers it here once and names it from data thereafter.
- *
- * `profiles` is the profiles table: named AgentProfiles that every manager in the tree may spawn
- * with `spawn_worker({ profile: '<name>' })` instead of retyping them. The table is read once, when
- * `supervise` is called: each entry is validated like a root profile and frozen, so every spawn by
- * a name starts from the same bytes. Unless `profileGuidance` or `authorizeSpawn` rewrites the
- * profile, the journal records the entry's digest for the child. Omit the table, or list no names,
- * and nothing about the run changes: `spawn_worker` keeps its object-only `profile`.
+/** Default per-edge traversal cap — the cyclic-graph backstop when an edge names none. */
+declare const defaultEdgeTraversalCap = 32;
+/** A graph node: an id and a canonical `AgentProfile`. The profile is the ONLY way a node is
+ *  described — its `prompt.systemPrompt` is the standing role (the 0.117 canonical resolution;
+ *  never a legacy top-level-only reduction), its tools/mcp/resources are its capabilities. */
+interface GraphNode {
+  readonly id: NodeId;
+  readonly profile: AgentProfile;
+  /** A check node: Runtime runs this command instead of an agent (flow graphs only). Its profile is
+   *  `{ name: id }`; `graphFromStored` writes both. */
+  readonly check?: GraphCheckNode;
+}
+type GraphEdge =
+/** Work flows down. The delegation directive is DATA → versionable, sweepable, optimizable.
+ *  Each spawn of `to` by `from` — and each mid-run steer from `from` to a live `to` worker —
+ *  is one traversal. */
+{
+  readonly kind: 'delegates';
+  readonly from: NodeId;
+  readonly to: NodeId;
+  readonly directive: PromptHandle;
+  /** Cyclic-graph backstop: traversals beyond this REFUSE (fail loud). Default
+   *  {@link defaultEdgeTraversalCap}. */
+  readonly maxTraversals?: number;
+  /** Default continuity for this edge's SPAWN traversals. `'resume'` makes every spawn after
+   *  the node's first re-attach to its most recent SETTLED worker: a NEW live worker whose
+   *  spawn context carries `resume: { ofWorker, sequence }` for the executor seam, spending
+   *  from the same conserved pool — the node's first spawn is effectively `'fresh'`, and a
+   *  spawn while a prior worker is still live refuses loudly (steer is the live channel).
+   *  The driver's per-call `spawn_worker` `continuity` argument overrides either way. Omit =
+   *  `'fresh'` (today's behavior, byte-identical). Caps count resumes exactly like fresh
+   *  spawns. */
+  readonly continuity?: ContinuityMode;
+} |
+/** Findings flow anywhere: an analyst over N nodes' settled traces, delivered to ONE node.
+ *  With a LENS analyst the directive wraps the findings for the recipient; with a NODE analyst
+ *  the directive is the analyst agent's task and the findings are its settle output. */
+{
+  readonly kind: 'analyzes';
+  /** The analyst REFERENCE, in one of two forms: a lens id resolved against
+   *  `RunGraphOptions.analysts` (environment), or the id of a graph NODE with no delegates
+   *  edge pointing at it — then each matching settle spawns that node's pinned profile as a
+   *  tool-equipped analyst WORKER (same spawn machinery, conserved budget, trace join) whose
+   *  task is this edge's directive plus the settled worker's trace evidence and whose settle
+   *  output is the findings. An id that is both a node and a registry lens is refused. */
+  readonly analyst: string;
+  readonly over: ReadonlyArray<NodeId>;
+  readonly to: NodeId;
+  readonly directive: PromptHandle;
+  /** Observability cap: traversals beyond this are LEDGERED as exhausted (`unpropagated`).
+   *  Only delegates caps refuse traversal — they are what close the spawn cycle. */
+  readonly maxTraversals?: number;
+} |
+/**
+ * Fan-out over a list that exists only at run time, then one join. When `from` settles `done`,
+ * the array at `pointer` in its result is expanded: each element becomes the TASK of one item
+ * run, at most `concurrency` at a time, and once every item settled the `join` node runs with
+ * `{ map, source, items, results: [{ index, item, result }], failures: [{ index, item, outcome,
+ * reason }] }`, results in item order. The runtime spawns the items and the join (`from`'s
+ * driver spends no turn on them) through the same authorized spawn path a delegates spawn
+ * takes: each item reserves its budget from the one conserved pool and is pinned to the edge's
+ * profile, so an item's content can never choose what runs.
+ *
+ * An item is either the node `to` (its pinned profile plus this edge's directive) or the nested
+ * `graph`, started per item exactly as `run_graph` starts a graph. Refusals are loud and
+ * ledgered, and the driver is woken with them: a pointer that does not resolve to an array, more
+ * elements than `maxItems`, or a `concurrency` the run's worker-slot bound can never honor.
+ * `concurrency` otherwise THROTTLES (items wait for a free place); it never refuses an item.
+ *
+ * An edge rather than a node-level spec, because every kernel invariant a map must keep already
+ * attaches to edge traversal: pinning admits only the edge's item and join nodes (the spawn
+ * context carries a runtime-authored `map` marker), each item is admitted like a spawn and
+ * reserves from the conserved pool, each item settles under its own deliverable check, and each
+ * expansion, item and join is a ledger row with its journal twin. Topology stays static; only the
+ * traversal count is dynamic, so validation and the one-node-one-profile rule are unchanged.
  */
-interface SuperviseRegistry {
-  readonly deliverables?: SuperviseRegistryTable<DeliverableSpec<unknown>>;
-  readonly finalizers?: SuperviseRegistryTable<SupervisorFinalizer>;
-  readonly analysts?: SuperviseRegistryTable<AnalystRegistry$1>;
-  readonly profiles?: SuperviseRegistryTable<SuperviseProfileEntry> & {
-    names(): readonly string[];
+{
+  readonly kind: 'maps';
+  /** The source node: a delegates target, or the join of another maps edge. Each of its `done`
+   *  settles expands the map once. */
+  readonly from: NodeId;
+  /** RFC 6901 JSON pointer into `from`'s settled result (`''` is the whole result). */
+  readonly pointer: string;
+  /** The item node, run once per element with the element as its task. Exactly one of `to`
+   *  and `graph`. Reachable only through this edge: never a delegates target. */
+  readonly to?: NodeId;
+  /** A graph run per element as one subtask, through the `run_graph` path. */
+  readonly graph?: GraphTopology;
+  /** Receives the ordered results once every item settled. Reachable only through this edge. */
+  readonly join: NodeId;
+  /** The item directive, appended to the item node's instructions per traversal. */
+  readonly directive: PromptHandle;
+  /** Lists longer than this are refused before any item runs. */
+  readonly maxItems: number;
+  /** How many items run at once. */
+  readonly concurrency: number;
+  readonly onItemFailure: MapItemFailurePolicy;
+  /** Each item's budget, merged over the per-worker default as `spawn_worker`'s `budget` is. */
+  readonly itemBudget?: Partial<Budget>;
+} |
+/**
+ * A route in a flow graph (one with `entry`): Runtime traverses it when `from` settles, so no
+ * root decides the order, the branch, the repair loop or the stop. On each usable settle of
+ * `from` its outgoing routes edges are tried in declaration order and the first whose `when`
+ * holds fires; an edge without `when` is the default branch and comes last. A node target is
+ * spawned with `{ from: { node, result }, evidence: { [id]: latest usable result } }` (a join's
+ * target with `{ from: { nodes }, evidence }`, see below) and the directive appended to its pinned instructions; `{ stop }` ends the run with no winner and
+ * `GraphResult.stopped`; `{ finish }` makes this settle part of the run's output.
+ *
+ * A fork lists two or more nodes in `to`: one traversal spawns each of them at once, each under
+ * its own key `route:<edge id>#<traversal>:<node>`. A join lists two or more nodes in `from`: it
+ * fires once every member has settled usably since it last fired, and the target's task is
+ * `{ from: { nodes: <members in declared order> }, evidence }` with each member's latest result
+ * in `evidence`, so it does not depend on which member settled last and a resumed run derives the
+ * same task. A routes edge that spawns a node with a settled worker in this flow (a back edge)
+ * names that node's latest settled worker as the spawn's `successorOf`. A join carries no `when`, and it is the only routes edge
+ * leaving each of its members. A route into a node that still has a running worker throws
+ * {@link GraphRouteError} with reason `target-live`: converging branches use a join.
+ */
+{
+  readonly kind: 'routes';
+  readonly from: NodeId | ReadonlyArray<NodeId>;
+  readonly to: NodeId | ReadonlyArray<NodeId> | {
+    readonly stop: string;
+  } | {
+    readonly finish: string;
   };
+  readonly directive: PromptHandle;
+  /** Absent on the default edge and on every join. A match reads `from` unless it names a node
+   *  in `evidence`. */
+  readonly when?: RouteWhen;
+  /** Nodes whose latest usable result rides the target's task. */
+  readonly evidence?: ReadonlyArray<NodeId>;
+  /** Traversals beyond this are skipped (ledgered `unpropagated`) and matching continues with
+   *  the next edge. Default {@link defaultEdgeTraversalCap}. Every routes cycle, each subcycle
+   *  included, must cross an edge that sets it. */
+  readonly maxTraversals?: number;
+  /** `'resume'` re-attaches each spawn of the target to its latest settled session. Omit =
+   *  `'fresh'`. */
+  readonly continuity?: ContinuityMode;
+};
+/** A topology without the run's own budget and deliverable: the form a `maps` edge runs per item,
+ *  as `run_graph` runs it. With `entry` it is a flow graph. Inside a maps item, the item value is
+ *  the task of every entry whose task is the placeholder `{ item: true }`; a down settle inside the item ends
+ *  that item only, and the maps edge's `onItemFailure` decides the join. */
+interface GraphTopology {
+  readonly nodes: ReadonlyArray<GraphNode>;
+  readonly edges: ReadonlyArray<GraphEdge>;
+  readonly entry?: AgentGraph['entry'];
+  /** Refused here: a maps item's graph and a `run_graph` subtask have no `decideGate`. */
+  readonly gates?: AgentGraph['gates'];
 }
-interface SuperviseOptions {
-  /** Whole-run persistence and ownership. SQL contexts are acquired before replay and compute. */
-  readonly runContext?: RunContext;
-  /** The conserved compute pool for the whole run. */
-  readonly budget: Budget;
-  /** Caller-created live handle for observing, steering, or cancelling this root manager. Runtime
-   * attaches it before execution and detaches it after the join barrier. */
-  readonly rootHandle?: RootHandle<unknown>;
-  /** Caller-owned cancellation for the complete recursive run. Aborting it cascades through the
-   * root scope and every live child, including acquisition and backend execution. */
-  readonly signal?: AbortSignal;
-  /** Trusted candidate and pursuit attribution for the root. The runtime derives profile/task
-   * digests itself from the exact detached values it executes. */
-  readonly execution?: AgentExecutionRef;
-  /** WHERE workers run — derives the worker seam. Provide this OR an explicit `makeWorkerAgent`. */
-  readonly backend?: ExecutorConfig;
-  /** Resolve an authored subscription stage to one eligible seat and a backend pinned to its
-   * credential reference. The callback may report stage exhaustion with `resumeAt`; Runtime
-   * advances the authored chain and never writes credentials into its record. */
-  readonly selectSeat?: SelectSeat;
-  /** The independent completion check for backend-derived workers and direct supervisor
-   *  submissions. Strongly recommended: without it the supervisor cannot submit its own work and
-   *  backend-derived workers fall back to their own validity signal. A `string` names an entry in
-   *  `registry.deliverables`. */
-  readonly deliverable?: DeliverableSpec<unknown> | string;
-  /** Resolve the completion check for one exact authorized backend-derived child. The callback runs
-   * after spawn authorization and receives a detached immutable context. It may return `undefined`
-   * to use the run-wide `deliverable`, or `null` to omit this child's assignment check and continuation.
-   * Null does not turn completion into acceptance or erase existing backend/descendant verdicts.
-   * An unchecked child must declare compatible tools: disable inherited spawn rights and author its
-   * coordination grants without `submit_result` or `read_continuation`. Explicit incompatible
-   * grants remain refused; the authorized profile is never rewritten after this callback. */
-  readonly resolveDeliverable?: (input: DeliverableResolutionInput) => DeliverableSpec<unknown> | null | undefined;
-  /** Name→value tables for the four code-valued options, so a recorded run configuration can name
-   *  them instead of carrying closures. See {@link SuperviseRegistry}. */
-  readonly registry?: SuperviseRegistry;
-  /** Where the coordination MCP binds when the supervisor is harness-driven. Omit = an ephemeral
-   *  port on `127.0.0.1`, which an off-host root cannot reach. A non-loopback host is refused
-   *  unless authentication is configured; provider managers also need a reachable public URL. */
-  readonly coordination?: CoordinationBinding;
-  /** OPT-IN peer mail for the run's workers: sibling-to-sibling `send_mail` / `read_mail`, bounded
-   *  and audited (`CoordinationToolsOptions.peerMail`). The runtime mints one capability URL per
-   *  spawn, serves the mail listener beside the coordination MCP, and hands each worker its
-   *  endpoint on {@link runtime.WorkerSpawnContext.peerMailUrl}.
-   *
-   *  On the backend-derived worker path the runtime also MOUNTS that endpoint, the way a driver
-   *  receives its coordination MCP: out of band on the bridge's `runtime_attachments`, so the
-   *  authored profile digest never moves, and inside the leaf factory, so `authorizeSpawn` has
-   *  already decided the profile. A `bridge` worker therefore calls `send_mail` / `read_mail` as
-   *  native tools. `provider` workers mount it through their runtime MCP attachment capability. `router` and `router-tools` workers run no MCP client, so the URL
-   *  stays the caller's to use; every other backend refuses the spawn rather than mint a
-   *  capability it can never reach. A caller-owned `makeWorkerAgent` owns its own mount.
-   *
-   *  Requires a harness-brained supervisor; a router-brained supervisor is refused rather than
-   *  silently unmailed. */
-  readonly peerMail?: boolean | {
-    limits?: Partial<PeerMailLimits>;
+interface AgentGraph {
+  /** Preserve fully bound literal data when serializing a hydrated graph. */
+  readonly triggerBindings?: readonly [];
+  readonly nodes: ReadonlyArray<GraphNode>;
+  readonly edges: ReadonlyArray<GraphEdge>;
+  /** Termination is mandatory, not optional: the independent completion oracle. */
+  readonly deliverable: DeliverableSpec<unknown> & {
+    readonly checkRef?: string;
+    readonly command?: GraphCommandCheck;
+    readonly when?: RouteWhen;
   };
-  /** Let sibling root managers read each other's recorded evidence. No mutation or steering. Default false. */
-  readonly peerAudit?: boolean;
-  /** False removes observe_agent/read_journal from the root and every authored descendant. Default true. */
-  readonly traceTools?: boolean;
-  /** Override the worker seam directly (tests / advanced) instead of deriving it from `backend`.
-   *  This is caller-owned execution: profile security, spawn authorization, and recursive-driver
-   *  selection below apply only to the backend-derived worker path. `authorizeMessage` still
-   *  governs continuations sent through Runtime's coordination tools. */
-  readonly makeWorkerAgent?: MakeWorkerAgent;
-  /** Override ONLY how an authorized LEAF executes, keeping the whole backend-derived path —
-   *  profile security, spawn authorization, recursive-driver selection, nested supervisors — in
-   *  force. Unlike `makeWorkerAgent`, which replaces that path, this slots inside it: the kernel
-   *  authorizes and classifies every spawn, and a child that is NOT a driver runs through this
-   *  factory instead of `backend`. A child that IS a driver still becomes a nested supervisor, whose
-   *  own leaves use this same factory. Composes with `authorizeSpawn`; `backend` is then optional.
-   *  This is the seam an offline test or a pinning layer (an agent graph) should use. */
-  readonly makeLeafAgent?: MakeWorkerAgent;
-  /** Reconstruct executors for interrupted children on resume, for a run that owns its worker
-   *  factory (`makeWorkerAgent`/`makeLeafAgent`). Backend-derived recursive managers register one
-   *  automatically; a caller-owned factory cannot be, so a leaf whose execution can RE-ATTACH
-   *  across a process boundary (a sandbox session, a CLI bridge session — an executor that
-   *  journals its admission through the retained seam) needs this for a resume to recover the
-   *  in-flight child instead of refusing its key `in-doubt`. The factory receives the
-   *  reconstructed spec and the child's journaled context, including its prior admissions. */
-  readonly recoverExecutor?: ExecutorFactory<unknown>;
-  /** Run harness-brained supervisors here. Automatic execution supports a local `bridge`, or a
-   * provider advertising runtime MCP attachments with authenticated `coordination.publicUrl`.
-   *  Defaults to `backend`; separate it when managers and workers use different services. */
-  readonly driverBackend?: ExecutorConfig;
-  /** Security policy applied to every manager-authored child profile before budget reservation.
-   *  The default blocks local and remote MCP, hooks, and connection grants. Pass an explicit
-   *  allowlist to grant remote MCP hosts or other author-controlled capabilities. */
-  readonly profileSecurity?: AgentProfileSecurityPolicy;
-  /** Product authority over one complete manager-authored spawn. The callback sees the detached,
-   *  immutable profile, task, budget, label, and key together, so approving a profile cannot
+  /** One conserved pool across the whole graph — cycles without conservation never terminate. */
+  readonly budget: Budget;
+  /** Setting it makes this a FLOW graph: Runtime spawns every entry at once, each with its task,
+   *  and traverses `routes` edges itself. No node is a root and no caller brain runs; the run's
+   *  output is `{ [node]: latest usable result }` over its terminal nodes and `finish` sources,
+   *  judged by `deliverable`. A stored route check (`checkRef: 'route'`) may also name a
+   *  non-terminal node: its condition reads that node's latest delivered output, while the output
+   *  stays terminal-only. */
+  readonly entry?: ReadonlyArray<{
+    readonly node: NodeId;
+    readonly task: unknown;
+  }>;
+  /** Flow-graph vertices that are not agents: a routes edge into one awaits
+   *  `RunGraphOptions.decideGate`, and one edge per choice leaves it, matching
+   *  `{ pointer: '/choice', equals: <choice> }`. A `finish` leaving a gate outputs
+   *  `{ [gate]: { choice, by } }`. */
+  readonly gates?: ReadonlyArray<RouteGate>;
+  /** Where nodes run: `cwd` (default) is the run's working directory; `fresh` is a new empty
+   *  directory the run owns, which the host creates and passes as that working directory
+   *  (`graphWorkspace`). */
+  readonly workspace?: 'cwd' | 'fresh';
+  /** The authored root's continuation; a flow has no root manager. */
+  readonly continuation?: PortableContinuationPolicy;
+}
+/** `failed` is a maps item or join that ran and settled without a usable result (down, or
+ *  rejected by its deliverable check); a traversal that never reached a worker is `unpropagated`. */
+type EdgeDeliveryOutcome = 'delivered' | 'stripped' | 'empty' | 'unpropagated' | 'failed';
+/** How one ledgered hop CONTINUED: a spawn traversal stamps its effective spawn mode
+ *  (`'fresh'` | `'resume'`), and every mid-run delivery into an already-live recipient — a
+ *  driver steer leg and every analyzes delivery (routed steer or driver-destined finding) —
+ *  stamps `'steer'`. Zero ambiguity: every row carries exactly one of the three. */
+type TraversalContinuity = ContinuityMode | 'steer';
+/** One recorded edge traversal — the in-memory row; the journal twin is the `edge` SpawnEvent. */
+interface EdgeTraversal {
+  /** Stable edge id: `delegates:<from>-><to>`, `analyzes:<analyst>:<over…>-><to>`,
+   *  `maps:<from>-><to | graph>-><join>`, `routes:<from>#<ordinal>-><to | stop:<reason> |
+   *  finish:<reason>>`, or `routes:entry-><node>` for an entry. */
+  readonly edge: string;
+  readonly kind: 'delegates' | 'analyzes' | 'maps' | 'routes';
+  readonly from: string;
+  readonly to: string;
+  /** The resolved directive reference (`<surface>/v<n>`). */
+  readonly directive: string;
+  /** 1-based per-edge ordinal. */
+  readonly traversal: number;
+  readonly outcome: EdgeDeliveryOutcome;
+  /** How this hop continued — see {@link TraversalContinuity}. */
+  readonly continuity: TraversalContinuity;
+  /** Bytes of directive + payload that actually crossed the edge. */
+  readonly bytes: number;
+  readonly reason?: string;
+  /** The concrete worker node id, once known. A maps expansion names the source worker. */
+  readonly workerId?: string;
+  /** Present on maps rows: the expansion of the source's list, one item by its index, or the
+   *  join. */
+  readonly map?: {
+    readonly phase: 'expand' | 'item' | 'join';
+    readonly index?: number;
+  };
+  /** Present on a gate's decision row (`gate:<id>`, `traversal` = visit): who decided, and what. */
+  readonly gate?: GateDecisionRecord;
+}
+/** A delegates edge exhausted its traversal cap and the run produced no winner: the cap, not the
+ *  task, ended it. Carries the full evidence so failing loud loses nothing. */
+declare class GraphEdgeCapError extends Error {
+  readonly exhaustedEdges: ReadonlyArray<string>;
+  readonly ledger: ReadonlyArray<EdgeTraversal>;
+  readonly result: SupervisedResult<unknown>;
+  constructor(exhaustedEdges: ReadonlyArray<string>, ledger: ReadonlyArray<EdgeTraversal>, result: SupervisedResult<unknown>);
+}
+/**
+ * Forwarded to the root `supervise()` VERBATIM. Everything not owned, transformed, or refused
+ * above belongs here — the default is "a graph honors it", not "someone remembered to add it".
+ */
+declare const GRAPH_FORWARDED_SUPERVISE_OPTIONS: readonly ["parking", "backend", "profileGuidance", "escalateQuestion", "rootHandle", "signal", "execution", "resolveDeliverable", "coordination", "peerMail", "peerAudit", "traceTools", "driverBackend", "profileSecurity", "authorizeSpawn", "router", "driveHarness", "selectSeat", "driverRetry", "onDriverAttempt", "continuation", "childSettleGraceMs", "teardownConfirmMs", "retainedAtSettlement", "resolveDriveHarness", "driveHarnessMaterialization", "resolveSupervisorTools", "extraTools", "executeExtraTool", "recoverExecutor", "perWorker", "reservationPolicy", "deadlineCheckIn", "budgetStopHoldMs", "workerSlots", "watchWorkers", "stallAfterMs", "wake", "runDir", "resume", "segment", "runContext", "steerDir", "stopRule", "onProgressStop", "maxDepth", "maxTurns", "compaction", "now", "allowedModels", "finalizer", "otel", "graphRegistry"];
+/** `backend` and `driverBackend` keep graph-specific documentation below.
+ *
+ * Do not inherit and redeclare them through an indexed access type.
+ * TypeScript 7 correctly treats `SuperviseOptions['backend']` as including `undefined`, which makes
+ * that redeclaration wider than the exact optional property inherited from `SuperviseOptions`.
+ */
+type GraphInheritedSuperviseOption = Exclude<(typeof GRAPH_FORWARDED_SUPERVISE_OPTIONS)[number], 'backend' | 'driverBackend'>;
+/**
+ * Options for one `runGraph` run.
+ *
+ * Extends every forwarded `SuperviseOptions` key, so a graph honors what a `supervise()` run
+ * honors WITHOUT anyone restating it here. Only the graph-specific members and the ones whose
+ * graph semantics differ are declared below; everything else inherits its type AND its
+ * documentation from `SuperviseOptions`, which is the one owner of both.
+ */
+interface RunGraphOptions extends Pick<SuperviseOptions, GraphInheritedSuperviseOption> {
+  /** WHERE worker nodes run — the executor backend. Provide this OR `makeLeafAgent`. Forwarded to
+   *  `supervise()`, which derives every authorized leaf from it. A node that declares
+   *  `agent_runtime_coordination_spawn_worker` becomes a nested supervisor instead, whose own
+   *  leaves are derived the same way. */
+  readonly backend?: Exclude<SuperviseOptions['backend'], undefined>;
+  /** WHERE the ROOT node's harness brain runs — forwarded to `supervise()` verbatim (see
+   *  `SuperviseOptions.driverBackend`). Needed when the root node's profile declares an external
+   *  harness (`codex`, `claude-code`, `opencode`): that root is driven by the harness, not by the
+   *  router brain, and automatic execution supports a local `bridge`. Unlike `supervise()`, this
+   *  does NOT default to `backend`: a graph's `backend` places WORKER nodes, so the root driver
+   *  is selected only by this field. Omit = no harness driver, which is correct for a root whose
+   *  `profile.harness` is omitted or `cli-base` (that root runs on the router brain). */
+  readonly driverBackend?: Exclude<SuperviseOptions['driverBackend'], undefined>;
+  /** Leaf-execution override (offline tests / advanced). `runGraph` still owns node pinning,
+   *  directive delivery, and the edge ledger AROUND this seam — only the leaf `act` is yours.
+   *  Slots INSIDE the kernel's authorized path (`SuperviseOptions.makeLeafAgent`), so a node that
+   *  declares the spawn tool still becomes a nested supervisor even under an offline leaf. */
+  readonly makeLeafAgent?: MakeWorkerAgent;
+  /** The ROOT driver's inference seam — a caller-owned `ToolLoopChat` that makes every root
+   *  model call. Use it when the root's decisions must be caller-owned orchestration (a
+   *  deterministic conversation driver, a persona loop with its own LLM calls) rather than a
+   *  router-derived model call. The graph machinery around the seam is unchanged: node pinning,
+   *  directive delivery, the edge ledger, and the journal twin all run the same shipped path,
+   *  and the root profile keeps prompt control (`prompt-control-execution` materialization —
+   *  `systemPrompt`/`instructions` still apply). What moves to the caller with the brain:
+   *  model selection and provider-identity validation (`expectedModel` cannot be enforced on a
+   *  call the runtime did not place) and per-turn usage reporting (a brain that reports no
+   *  usage meters nothing into the pool). Omit = the router brain derived from the root
+   *  profile — the unchanged default. Mutually exclusive with `driverBackend`, and refused
+   *  when the root profile declares an external harness (that root is driven BY the harness). */
+  readonly brain?: ToolLoopChat;
+  /** Caller-side runtime hooks (telemetry, policy, product extensions). Composed AFTER the
+   *  graph's own spawn-binding hook on the SAME event stream — the graph never swallows the
+   *  seam supervise() exposes. */
+  readonly hooks?: RuntimeHooks;
+  /** The analyst lens registry `analyzes` edges resolve against. ENVIRONMENT — needed only for
+   *  lens analysts; an analyzes edge naming a graph NODE as its analyst needs no registry. */
+  readonly analysts?: AnalystRegistry$1;
+  /** Answers a flow gate while the process holds the run; the wait counts against its deadline.
+   *  ENVIRONMENT, like `analysts`; required when the graph declares gates. */
+  readonly decideGate?: (request: GateRequest) => Promise<GateDecision>;
+  /** Directive registry. Default: the seeded kernel registry (`kernelPromptRegistry()`).
+   *
+   *  NOT `SuperviseOptions.registry`, which is the `SuperviseRegistry` name→value table for
+   *  code-valued options. The two share a name and nothing else, and this one wins here — see
+   *  `GRAPH_REFUSED_SUPERVISE_OPTIONS`. */
+  readonly registry?: PromptRegistry;
+  /** The run journal the edge ledger and every spawn/settle ride. Default: in-memory. */
+  readonly journal?: SpawnJournal;
+  readonly blobs?: ResultBlobStore;
+  readonly runId?: string;
+  /** Product authority over every steer/answer instruction (the filter seam). `runGraph` observes
+   *  what it CHANGES: a narrowed instruction ledgers its steer traversal as `stripped`. */
+  readonly authorizeMessage?: SuperviseOptions['authorizeMessage'];
+  /** Where check nodes run: a fresh Sandbox box per check, created by `client` on the check account,
+   *  from each node's `environment`. Absent = locally, in the run's working directory (a loopback
+   *  Bridge `cwd` or a `cli-in-place` workspace). */
+  readonly checkPlacement?: GraphCheckPlacement;
+}
+interface GraphResult<Out = unknown> {
+  readonly result: SupervisedResult<Out>;
+  /** Every edge traversal, in occurrence order — the observable-edge contract. */
+  readonly ledger: ReadonlyArray<EdgeTraversal>;
+  /** Edge ids whose traversal cap was hit — analyzes exhaustion included (observable here, never
+   *  a refusal). A DELEGATES cap paired with a `no-winner` result THROWS
+   *  ({@link GraphEdgeCapError}) instead of returning: only delegates caps refuse spawns, so only
+   *  they can have ended the run. A LIFECYCLE no-winner (`aborted` / `budget-exhausted`) returns
+   *  normally even with an exhausted delegates cap — the abort or the pool, not the cap, ended
+   *  that run, and the exhaustion stays observable here. */
+  readonly exhaustedEdges: ReadonlyArray<string>;
+  readonly runId: string;
+  /** Why a flow graph ended early: a `stop` edge fired (`edge` names it), or a flow node settled
+   *  down (no `edge`; `reason` is `down: <worker reason>`) or, where a route was needed, without a
+   *  usable result (no `edge`; `reason` is `unusable: <why>`). Live flow workers are aborted. */
+  readonly stopped?: {
+    readonly code?: string;
+    readonly edge?: string;
+    readonly at: NodeId;
+    readonly workerId: string;
+    readonly reason: string;
+  };
+}
+/** `RunGraphOptions` with the brain REQUIRED — the shape the `/testing` entry's
+ *  `runGraphWithTestBrain` keeps accepting now that `brain` is a production option. */
+interface RunGraphTestOptions extends RunGraphOptions {
+  readonly brain: ToolLoopChat;
+}
+/**
+ * Execute an {@link AgentGraph}. A flow graph (`entry` set) runs from its entries and routes edges
+ * under a runtime-owned root that places no model call. Otherwise the root node becomes the
+ * supervisor (`supervise()` — the execution core), each worker node is spawnable BY NODE ID
+ * (`spawn_worker` with `profile: { name: '<node id>' }`; the node's canonical profile is pinned by
+ * the graph), each
+ * delegates directive is appended to the worker profile's `prompt.instructions` per traversal,
+ * and each analyzes edge becomes an analyst-on-settle route with a real DESTINATION. Every
+ * traversal is ledgered and journaled.
+ */
+declare function runGraph(graph: AgentGraph, opts: RunGraphOptions): Promise<GraphResult>;
+/** Alias for graph tests written before `RunGraphOptions.brain` was production. The production
+ *  entry accepts the same shape; this wrapper only keeps the `/testing` import path working. */
+declare function runGraphWithTestBrain(graph: AgentGraph, opts: RunGraphTestOptions): Promise<GraphResult>;
+/** An environment-owned check command, run outside the agent's conversation. */
+interface GraphCommandCheck {
+  readonly command: string;
+  readonly timeoutMs?: number;
+}
+/** A graph node that runs a command instead of an agent: no model, no seat. Locally it runs in the
+ *  run's working directory; with `RunGraphOptions.checkPlacement` it runs in a fresh Sandbox box
+ *  built from `environment`, through the box runner a declared check uses. */
+interface GraphCheckNode {
+  readonly command: string;
+  /** Default 15 minutes. */
+  readonly timeoutMs?: number;
+  /** The box image under `checkPlacement`; required there, unused locally. */
+  readonly environment?: string;
+  /** Domains a box may reach. Absent or empty: egress is blocked. Unused locally. */
+  readonly egress?: readonly string[];
+  /** Environment variable names the command needs; a missing one fails the node. In a box they
+   *  resolve only from the placement's `env`, the run owner's secrets. */
+  readonly secrets?: readonly string[];
+  /** The box's size under `checkPlacement`. */
+  readonly resources?: SandboxResources;
+}
+/** Where check nodes run in boxes: the run owner's own account. A check node is a step of the
+ *  graph, not a judge, so `builderAccounts` is optional and never refuses the owner's account. */
+interface GraphCheckPlacement extends Omit<DeclaredCheckPlacement, 'builderAccounts' | 'env'> {
+  readonly builderAccounts?: DeclaredCheckPlacement['builderAccounts'];
+  /** The owner's secrets, or a resolver called before each box run so short-lived tokens stay
+   *  fresh. Absent: no secrets. */
+  readonly env?: Readonly<Record<string, string | undefined>> | ((request: {
+    readonly node: string;
+    readonly secrets: readonly string[];
+    readonly signal: AbortSignal;
+  }) => Promise<Readonly<Record<string, string | undefined>>>);
+}
+/** A check node's settled output. `json` is the last stdout line when it parses as an object. */
+interface GraphCheckOutput {
+  readonly pass: boolean;
+  readonly exitCode: number | null;
+  /** The last 64 KiB of stdout followed by stderr. */
+  readonly output: string;
+  readonly json?: Record<string, unknown>;
+}
+interface GraphFromStoredOptions {
+  readonly trigger?: Readonly<Record<string, unknown>>;
+  readonly checks?: Readonly<Record<string, AgentGraph['deliverable']['check'] | GraphCommandCheck>>;
+}
+/** The leaves of a flow's check nodes, for `supervise()`'s leaf path. */
+interface GraphCheckNodes {
+  readonly names: ReadonlyArray<string>;
+  readonly leaf: MakeWorkerAgent;
+}
+/** A name→value table in this package's resolver-port shape: construction stays the caller's,
+ *  lookup stays lazy, and a table backed by a file, a plugin loader, or a plain object all
+ *  satisfy one interface. */
+interface SuperviseRegistryTable<T> {
+  resolve(name: string): T | undefined;
+  /** The names the table holds. The three code-valued tables may omit it, because a caller names
+   *  their entries from data it already has. The profiles table must list them, because a
+   *  director can choose only from a menu it can read. */
+  names?(): readonly string[];
+}
+/**
+ * The name→value tables that make the three CODE-valued options expressible as run DATA, and the
+ * profiles a director may spawn by name.
+ *
+ * `deliverable` / `finalizer` / `analysts` are functions and registries, so a recorded
+ * run configuration (a JSON row, a campaign spec, a resumed run's options) cannot carry them — and
+ * a run with no `deliverable` cannot return a `winner` at all outside the sandbox backend, because
+ * the finalizer keeps only children whose oracle passed and nothing else writes that verdict. A
+ * caller that owns the code registers it here once and names it from data thereafter.
+ *
+ * `profiles` is the profiles table: named AgentProfiles that every manager in the tree may spawn
+ * with `spawn_worker({ profile: '<name>' })` instead of retyping them. The table is read once, when
+ * `supervise` is called: each entry is validated like a root profile and frozen, so every spawn by
+ * a name starts from the same bytes. Unless `profileGuidance` or `authorizeSpawn` rewrites the
+ * profile, the journal records the entry's digest for the child. Omit the table, or list no names,
+ * and nothing about the run changes: `spawn_worker` keeps its object-only `profile`.
+ */
+interface SuperviseRegistry {
+  readonly deliverables?: SuperviseRegistryTable<DeliverableSpec<unknown>>;
+  readonly finalizers?: SuperviseRegistryTable<SupervisorFinalizer>;
+  readonly analysts?: SuperviseRegistryTable<AnalystRegistry$1>;
+  readonly profiles?: SuperviseRegistryTable<SuperviseProfileEntry> & {
+    names(): readonly string[];
+  };
+}
+interface SuperviseOptions {
+  /** Whole-run persistence and ownership. SQL contexts are acquired before replay and compute. */
+  readonly runContext?: RunContext;
+  /** The conserved compute pool for the whole run. */
+  readonly budget: Budget;
+  /** Caller-created live handle for observing, steering, or cancelling this root manager. Runtime
+   * attaches it before execution and detaches it after the join barrier. */
+  readonly rootHandle?: RootHandle<unknown>;
+  /** Caller-owned cancellation for the complete recursive run. Aborting it cascades through the
+   * root scope and every live child, including acquisition and backend execution. */
+  readonly signal?: AbortSignal;
+  /** Trusted candidate and pursuit attribution for the root. The runtime derives profile/task
+   * digests itself from the exact detached values it executes. */
+  readonly execution?: AgentExecutionRef;
+  /** WHERE workers run — derives the worker seam. Provide this OR an explicit `makeWorkerAgent`. */
+  readonly backend?: ExecutorConfig;
+  /** Resolve an authored subscription stage to one eligible seat and a backend pinned to its
+   * credential reference. The callback may report stage exhaustion with `resumeAt`; Runtime
+   * advances the authored chain and never writes credentials into its record. */
+  readonly selectSeat?: SelectSeat;
+  /** The independent completion check for backend-derived workers and direct supervisor
+   *  submissions. Strongly recommended: without it the supervisor cannot submit its own work and
+   *  backend-derived workers fall back to their own validity signal. A `string` names an entry in
+   *  `registry.deliverables`. */
+  readonly deliverable?: DeliverableSpec<unknown> | string;
+  /** Resolve the completion check for one exact authorized backend-derived child. The callback runs
+   * after spawn authorization and receives a detached immutable context. It may return `undefined`
+   * to use the run-wide `deliverable`, or `null` to omit this child's assignment check and continuation.
+   * Null does not turn completion into acceptance or erase existing backend/descendant verdicts.
+   * An unchecked child must declare compatible tools: disable inherited spawn rights and author its
+   * coordination grants without `submit_result` or `read_continuation`. Explicit incompatible
+   * grants remain refused; the authorized profile is never rewritten after this callback. */
+  readonly resolveDeliverable?: (input: DeliverableResolutionInput) => DeliverableSpec<unknown> | null | undefined;
+  /** Name→value tables for the four code-valued options, so a recorded run configuration can name
+   *  them instead of carrying closures. See {@link SuperviseRegistry}. */
+  readonly registry?: SuperviseRegistry;
+  /** Where the coordination MCP binds when the supervisor is harness-driven. Omit = an ephemeral
+   *  port on `127.0.0.1`, which an off-host root cannot reach. A non-loopback host is refused
+   *  unless authentication is configured; provider managers also need a reachable public URL. */
+  readonly coordination?: CoordinationBinding;
+  /** OPT-IN peer mail for the run's workers: sibling-to-sibling `send_mail` / `read_mail`, bounded
+   *  and audited (`CoordinationToolsOptions.peerMail`). The runtime mints one capability URL per
+   *  spawn, serves the mail listener beside the coordination MCP, and hands each worker its
+   *  endpoint on {@link runtime.WorkerSpawnContext.peerMailUrl}.
+   *
+   *  On the backend-derived worker path the runtime also MOUNTS that endpoint, the way a driver
+   *  receives its coordination MCP: out of band on the bridge's `runtime_attachments`, so the
+   *  authored profile digest never moves, and inside the leaf factory, so `authorizeSpawn` has
+   *  already decided the profile. A `bridge` worker therefore calls `send_mail` / `read_mail` as
+   *  native tools. `provider` workers mount it through their runtime MCP attachment capability. `router` and `router-tools` workers run no MCP client, so the URL
+   *  stays the caller's to use; every other backend refuses the spawn rather than mint a
+   *  capability it can never reach. A caller-owned `makeWorkerAgent` owns its own mount.
+   *
+   *  Requires a harness-brained supervisor; a router-brained supervisor is refused rather than
+   *  silently unmailed. */
+  readonly peerMail?: boolean | {
+    limits?: Partial<PeerMailLimits>;
+  };
+  /** Let sibling root managers read each other's recorded evidence. No mutation or steering. Default false. */
+  readonly peerAudit?: boolean;
+  /** False removes observe_agent/read_journal from the root and every authored descendant. Default true. */
+  readonly traceTools?: boolean;
+  /** Override the worker seam directly (tests / advanced) instead of deriving it from `backend`.
+   *  This is caller-owned execution: profile security, spawn authorization, and recursive-driver
+   *  selection below apply only to the backend-derived worker path. `authorizeMessage` still
+   *  governs continuations sent through Runtime's coordination tools. */
+  readonly makeWorkerAgent?: MakeWorkerAgent;
+  /** Override ONLY how an authorized LEAF executes, keeping the whole backend-derived path —
+   *  profile security, spawn authorization, recursive-driver selection, nested supervisors — in
+   *  force. Unlike `makeWorkerAgent`, which replaces that path, this slots inside it: the kernel
+   *  authorizes and classifies every spawn, and a child that is NOT a driver runs through this
+   *  factory instead of `backend`. A child that IS a driver still becomes a nested supervisor, whose
+   *  own leaves use this same factory. Composes with `authorizeSpawn`; `backend` is then optional.
+   *  This is the seam an offline test or a pinning layer (an agent graph) should use. */
+  readonly makeLeafAgent?: MakeWorkerAgent;
+  /** Reconstruct executors for interrupted children on resume, for a run that owns its worker
+   *  factory (`makeWorkerAgent`/`makeLeafAgent`). Backend-derived recursive managers register one
+   *  automatically; a caller-owned factory cannot be, so a leaf whose execution can RE-ATTACH
+   *  across a process boundary (a sandbox session, a CLI bridge session — an executor that
+   *  journals its admission through the retained seam) needs this for a resume to recover the
+   *  in-flight child instead of refusing its key `in-doubt`. The factory receives the
+   *  reconstructed spec and the child's journaled context, including its prior admissions. */
+  readonly recoverExecutor?: ExecutorFactory<unknown>;
+  /** Run harness-brained supervisors here. Automatic execution supports a local `bridge`, or a
+   * provider advertising runtime MCP attachments with authenticated `coordination.publicUrl`.
+   *  Defaults to `backend`; separate it when managers and workers use different services. */
+  readonly driverBackend?: ExecutorConfig;
+  /** Security policy applied to every manager-authored child profile before budget reservation.
+   *  The default blocks local and remote MCP, hooks, and connection grants. Pass an explicit
+   *  allowlist to grant remote MCP hosts or other author-controlled capabilities. */
+  readonly profileSecurity?: AgentProfileSecurityPolicy;
+  /** Product authority over one complete manager-authored spawn. The callback sees the detached,
+   *  immutable profile, task, budget, label, and key together, so approving a profile cannot
    *  authorize a different task. Return the exact allowed profile (which may be narrowed) plus
    *  trusted candidate/pursuit attribution, or throw to refuse the whole spawn before reservation. */
   readonly authorizeSpawn?: (input: {
@@ -11556,10 +11704,11 @@ interface SuperviseOptions {
    *  Flow graphs keep derivation for native child drivers; their root uses Runtime's deterministic
    *  brain and makes no model call through this backend. */
   readonly rootDriverFromBackend?: boolean;
-  /** Pre-journal profile resolution for the spawn pre-flight: the profile a driver authored →
-   *  the profile that will run (`CoordinationToolsOptions.resolveSpawnProfile`). A pinning layer
-   *  sets this alongside `authorizeSpawn` so the backend gate and the authorization see the same
-   *  canonical profile. Identity-free and synchronous; throw to refuse. */
+  /** Pre-journal profile resolution: the profile a driver authored → the profile that will run
+   *  (`CoordinationToolsOptions.resolveSpawnProfile`), for the spawn itself and its pre-flight
+   *  gate alike (#1281). A pinning layer sets this alongside `authorizeSpawn` so the backend
+   *  gate and the authorization see the same canonical profile. Identity-free and synchronous;
+   *  throw to refuse. */
   readonly resolveSpawnProfile?: (profile: AgentProfile) => AgentProfile;
   /** OPT-IN standing guidance from the profile knowledge base
    *  (`@tangle-network/agent-interface/profile-kb`). `'profile-kb'` composes harness guidance,
@@ -11739,787 +11888,431 @@ interface SuperviseOptions {
   /** The flow the root manager runs: an AgentGraph with `entry` sets it, together with its
    *  runtime-owned root, which makes no model call. See `RouteFlow`. Omit = none. */
   readonly routeFlow?: RouteFlow;
+  /** The leaves of `routeFlow`'s check nodes: a route spawn of one runs its command, not an agent.
+   *  An AgentGraph's check nodes set it. Omit = none. */
+  readonly checkNodes?: GraphCheckNodes;
   /** Answers each gate visit of `routeFlow`; `runGraph` sets it from `RunGraphOptions.decideGate`,
    *  replaying a decision the run journal already holds. Omit = none. */
   readonly decideGate?: DecideGate;
   /**
    * Watch every worker's LIVE tool trace with the online detector panel and raise a `finding` the
    * moment one loops or error-storms — so the supervisor learns it mid-run (in its next wake)
-   * instead of at settle. Pairs with a steerable worker: the finding is the evidence, `steer_agent`
-   * is the correction. Requires a backend whose executor exposes a trace source (the steerable
-   * sandbox worker and the pi wrapper do); other runtimes are simply not watched.
-   *
-   * Omit = off (status quo — no online watching, no extra events).
-   */
-  readonly watchWorkers?: WorkerWatchOptions;
-  /** Idle time after which `observe_agent` reports a running worker as `stalled`. A derived read
-   *  at observation time — nothing is killed or retried. Omit = the runtime default. */
-  readonly stallAfterMs?: number;
-  /** How Runtime wakes a manager that ended its turn with work open: the heartbeat, the debounce
-   *  that coalesces events into one wake, and the deadline warning. Omit = the defaults in
-   *  `./wake` (15 min, 2 s, 15 min). */
-  readonly wake?: ManagerWakePolicy;
-  /** Default continuity per worker PROFILE NAME: `'resume'` makes each spawn of that name after
-   *  the first re-attach to the node's most recent SETTLED worker — a NEW live worker whose spawn
-   *  context carries the prior worker's identity (`WorkerSpawnContext.resume`), which the executor
-   *  seam re-attaches with. `spawn_worker`'s per-call `continuity` argument overrides in either
-   *  direction; `runGraph` derives this from delegates-edge `continuity`. Omit = every spawn is
-   *  `'fresh'` (status quo). See `CoordinationToolsOptions.continuityByProfile` for the
-   *  refusal semantics (no-prior / while-live / with-key) and the process-local resume boundary. */
-  readonly continuityByProfile?: Readonly<Record<string, ContinuityMode>>;
-  /** Worker output store. Defaults to in-memory. */
-  readonly blobs?: ResultBlobStore;
-  /**
-   * Make the run DURABLE: journal + result blobs + the coordination side-log are file-backed under
-   * this directory (`createFileRunContext`), fsynced per write, and the supervisor reads the prior
-   * tree first. Re-running with the same `runDir` AND the same `runId` resumes only when the exact
-   * root profile/task identity and declared budget match. The original absolute deadline and prior
-   * measured spend are restored before new admission. The built-in driver is resume-aware: children
-   * that already settled, including their exact execution identities, are replayed onto
-   * `Scope.resume` (and into the driver's settled ledger + its first context), keyed assignments
-   * (`spawn_worker`'s `key`) resolve to their committed results instead of re-running, pending
-   * waits re-arm on their original deadlines, and the coordination log loads prior questions,
-   * findings, and instruction receipts. The router arm receives all three in its resume brief; the
-   * external arm seeds prior questions while findings and receipts remain in the durable log.
-   * Instruction receipts are evidence and are never delivered automatically to a replacement
-   * worker. The final result spans both processes' work. Unset = in-memory, fresh every call.
-   *
-   * The boundary that remains: work that was IN FLIGHT when the process died is not recovered —
-   * the built-in executors cannot re-attach to a dead process's executions. Each such keyed
-   * assignment resumes as `in-doubt`, its full declared reservation stays charged, and its
-   * token/dollar telemetry remains unknown. Runtime refuses a replacement under that key until the
-   * exact prior execution is recovered, so restart cannot duplicate work or slide the deadline.
-   *
-   * `runId` matters here: it defaults to the constant `'supervise'`, which is fine for a single
-   * resumable run per directory but collides across concurrent runs sharing one `runDir`.
-   */
-  readonly runDir?: string;
-  /** Hand a root with only a long wait and no live descendants to the caller's existing keeper.
-   * Requires runDir. Rejects with RunParkedError after the idle threshold, retaining wakeAt in
-   * the spawn journal without writing a terminal result. The caller must handle parking and
-   * resume the same runDir/runId at wakeAt. Omit to keep waits in this process. */
-  readonly parking?: RunParkingPolicy;
-  /** Advanced test seam: opt into resume-first when the durable stores are caller-supplied
-   * (`journal` + `blobs` / `runContext`) instead of derived from `runDir`. The normal durable path
-   * is `runDir` or a `runContext` (see `docs/durability.md`). Exactly what the file
-   * context sets automatically: load the prior tree for `runId` before starting fresh, refuse a
-   * reused id without it. Ignored when `runDir` is also set — the file context owns the flag. */
-  readonly resume?: boolean;
-  /**
-   * The segment this entry runs the root in. A run keeps one id for its whole life: a turn that
-   * ends, a lost stream and a dead supervisor are boundaries between entries, and a resume may move
-   * the root to another model, provider, reasoning effort or harness, or onto another stack, as a
-   * new segment of the same run. `profile` stays the root profile the run recorded, so its identity,
-   * coordination owner and settled children resume unchanged; the root executes that profile with
-   * `model.provider`, `model.default`, `model.reasoningEffort` and `harness` replaced where given. `stack` names the
-   * package versions the caller runs this entry under, its Runtime among them; Runtime records it
-   * and never reads it. When the segment differs from the one the run last ran, the journal gains
-   * one `root-segment` record with the time and `reason`. A different task, or any other profile
-   * change, is still a resume identity mismatch: that is a new run. A fresh run records its first
-   * segment and refuses a model or harness change: a new run takes them from its profile.
-   *
-   * A harness change starts a new native session: a session of one harness cannot continue in
-   * another. The root re-enters with its objective and the run's state, in a workspace restored
-   * from its latest checkpoint when the provider holds one.
-   */
-  readonly segment?: {
-    readonly provider?: string;
-    readonly model?: string;
-    readonly reasoningEffort?: ReasoningEffort;
-    readonly harness?: AgentProfile['harness'];
-    readonly stack?: Readonly<Record<string, string>>;
-    readonly reason: string;
-  };
-  /** Durable steer directory when it differs from the run-control directory. */
-  readonly steerDir?: string;
-  /** Override the spawn journal directly (advanced; `runDir` is the ordinary durable path). Pair
-   *  with `blobs` — a journal whose result payloads live in a different store cannot replay. */
-  readonly journal?: SpawnJournal;
-  /**
-   * PROGRESS-derived stop rule (BOTH arms). Ends a run that has stopped LEARNING before it
-   * exhausts a ceiling — the answer to "a run should end because it is done or stuck, not because
-   * it ran out". It composes with the budget guards and can never override one.
-   *
-   * The evaluation boundary differs by arm because the loop does: a router-brained supervisor is
-   * evaluated before each of its own inference turns; a harness-brained supervisor is evaluated on
-   * each worker settle, and a stop aborts its stop signal so the harness ends at its next turn
-   * boundary. Both arms fold the same settled ledger through the same evaluator.
-   *
-   * Build it from `supervise/stop-rules`: `plateau({window, minDelta})`,
-   * `noProgressFor({ms, settles})`, `allWorkersStalled({...})`, combined with `anyOf`/`allOf`. The
-   * thresholds are policy and stay with you; the enforcement lives in the runtime. Omit = ceilings
-   * only (unchanged behavior).
-   *
-   * A record may declare the plateau rule as data, `{ plateau: { window, minDelta } }`, so no
-   * product module builds it.
-   */
-  readonly stopRule?: StopRule | {
-    readonly plateau: PlateauOptions;
-  };
-  /** One-shot notification of WHY a `stopRule` ended the run (BOTH arms) — so a caller records the
-   *  reason instead of inferring an early stop from an unexhausted budget. */
-  readonly onProgressStop?: (reason: string) => void;
-  /** Recursion ceiling for the tree (root = 0). The conserved pool is what bounds depth, since each
-   *  level's slice comes out of the level above; this only stops a runaway recursion. Omit =
-   *  `DEFAULT_MAX_DEPTH` (16). */
-  readonly maxDepth?: number;
-  /** Turn cap for the supervisor's OWN loop (BOTH arms). Router arm: inference turns of the
-   *  driver's tool loop. Harness arm: turns the harness reports, counted off its `iteration`
-   *  stream — reaching the cap aborts the stop signal, so the harness ends at its next turn
-   *  boundary rather than mid-request. `0` lifts the cap on both arms and leaves the conserved
-   *  pool, the deadline, and abort as the bounds; a negative value is refused. Omit = the router
-   *  arm's default cap, and no turn cap on the harness arm. */
-  readonly maxTurns?: number;
-  /** Give the supervisor brain a chapter-lifecycle on its OWN context window (ROUTER ARM ONLY —
-   *  a harness owns its own context window and its own compaction, so this is refused for a
-   *  harness-brained supervisor rather than silently ignored): once its coordination transcript
-   *  exceeds `thresholdTokens` it distills to a compact progress note and continues, instead of
-   *  re-billing the whole transcript every turn (the cost that makes the LLM-brain front door lose
-   *  to a dumb-Ralph respawn). The live `Scope` roster is the durable state across chapters.
-   *  Default off. `distill` defaults to a brain self-summary + the settled-worker roster. */
-  readonly compaction?: ToolLoopCompactionOptions;
-  readonly runId?: string;
-  readonly now?: () => number;
-  /** Restrict the run to this subset of models. When set, every configured model — the
-   *  supervisor router model, the profile's model, and the backend's model — must be a member,
-   *  or `supervise()` throws a `ConfigError` before any compute is spent. Unset = unrestricted.
-   *
-   *  This is a MODEL-ID filter, not a route filter. The compared values are the bare ids a profile
-   *  declares — `model.default`, `model.small`, `subagents[].model`, `modes[].model`. The composed
-   *  wire id (`harness/provider/model`) is never built here and never compared, so an entry written
-   *  in qualified form matches nothing, and a child that names an allowed id is admitted whatever
-   *  harness and provider its own profile declares. Pin the route with `authorizeSpawn`: it reads
-   *  the authored child profile and may refuse the spawn before any reservation. */
-  readonly allowedModels?: readonly string[];
-  /** How the settled-worker ledger becomes the run's output. Default `bestDelivered` — the single
-   *  highest-scoring DELIVERED child (the exact behavior every existing caller had). Alternatives:
-   *  `collectDelivered` (every verified distinct output with provenance — a Pareto set / recorded
-   *  disagreement) or a custom `SupervisorFinalizer`. Whatever the finalizer, it operates on
-   *  structurally DELIVERED outputs only — an undelivered or invalid child stays ineligible. A
-   *  `string` names an entry in `registry.finalizers`. */
-  readonly finalizer?: SupervisorFinalizer | string;
-  /** Lifecycle observers for the whole recursive tree (`Scope` re-seeds them into every nested
-   *  scope). Composed with the `otel` recorder below when both are set. Omit = no observers, which
-   *  is the behavior every existing caller has. */
-  readonly hooks?: RuntimeHooks;
-  /**
-   * OPT-IN OTLP tracing: emit one span per supervised node (opened at spawn, closed at settle,
-   * parented to its parent node's span) plus an `LLM` child span per metered driver turn, so the
-   * tree is readable by any trace viewer instead of only by a journal parser. See `otel-spans.ts`.
+   * instead of at settle. Pairs with a steerable worker: the finding is the evidence, `steer_agent`
+   * is the correction. Requires a backend whose executor exposes a trace source (the steerable
+   * sandbox worker and the pi wrapper do); other runtimes are simply not watched.
    *
-   * Omit and the run emits nothing, allocates no recorder, and installs no hook — telemetry is
-   * never a default. Present with no reachable endpoint (no `exportConfig.endpoint` and no
-   * `OTEL_EXPORTER_OTLP_ENDPOINT`) is also a no-op. The spawn journal is untouched either way:
-   * spans are telemetry, never the replay/resume record.
+   * Omit = off (status quo — no online watching, no extra events).
    */
-  readonly otel?: Omit<SupervisorSpanOptions, 'runId' | 'now' | 'namespace'>;
-}
-/** The product-authorized result for one complete spawn request. Attribution is never accepted
- * from the manager itself; it enters only through this trusted callback. */
-interface AuthorizedSpawn {
-  readonly profile: AgentProfile;
-  readonly execution?: AgentExecutionRef;
-}
-/** Exact trusted context after a manager-authored spawn has passed product authorization. */
-interface AuthorizedSpawnContext {
-  readonly profile: AgentProfile;
-  readonly parent: AgentProfile;
-  readonly parentIdentity: NodeExecutionIdentity;
-  readonly execution: NodeExecutionIdentity;
-  readonly parentNodeId: string;
-  readonly assignmentId: string;
-  readonly task: unknown;
-  readonly budget: Budget;
-  readonly label: string;
-  readonly key?: string;
-  readonly depth: number;
-}
-/** Exact trusted context for selecting one backend-derived leaf's completion check. */
-type DeliverableResolutionInput = AuthorizedSpawnContext;
-/** Test-only one-call shape, exported only through the package's explicit `/testing` entry. */
-interface SuperviseTestOptions extends SuperviseOptions {
-  readonly brain: ToolLoopChat;
-}
-/**
- * Build the worker seam from a backend (WHERE workers run) + an optional completion oracle (the
- * deliverable check that makes "settled ⟺ delivered" true — the guard against "ran but didn't
- * deliver"). The ONE place a backend becomes a spawnable worker.
- *
- * `seams` exists because this path builds the leaf executor EAGERLY and hands it back as a BYO
- * `executorSpec.executor`. The registry resolves a BYO executor without ever consulting the
- * per-child `ExecutorContext` the `Scope` seeds, so anything the scope would have supplied is
- * invisible here and has to be passed in. It is a FUNCTION because it is resolved once per worker
- * construction, so a caller may hand back something the run only learns later — which is exactly how
- * `supervise()` gives a traced run's workers their trace context without ordering the span recorder
- * ahead of the worker seam.
- *
- * Continuity: the `bridge` backend honors `continuity: 'resume'` by session re-attachment. A
- * bridge session id IS the harness conversation key (cli-bridge maps it to the CLI's own resume —
- * opencode `-s <id>`, claude `--resume`), so this seam records the session id each supervised
- * spawn was bound to, keyed by the worker id the Scope assigned, and a resume spawn binds the
- * prior worker's recorded session id instead of deriving a fresh one. The record is process-local
- * by construction, which matches the kernel's resume boundary (a prior process's workers are not
- * resume targets). Every other backend keeps failing loud: their executors have no re-attachable
- * session, and accepting the spawn would ledger `continuity: 'resume'` over a brand-new session —
- * a stamp asserting something that never happened.
- */
-declare function workerFromBackend(backend: ExecutorConfig, deliverable?: DeliverableSpec<unknown>, seams?: () => Readonly<Record<string, unknown>>): MakeWorkerAgent;
-/** Capabilities a data-only consumer may require before building an opted-in run. `graphTools`:
- *  a manager whose profile grants `run_graph` can start an agent graph as one subtask. */
-declare const superviseFleetCapabilities: Readonly<{
-  peerAudit: true;
-  traceTools: true;
-  graphTools: true;
-}>;
-/** One-call supervisor: build + run a supervisor from its exact profile. @stable */
-declare function supervise(profile: SupervisorProfile, task: unknown, opts: SuperviseOptions): Promise<{
-  execution?: AgentExecutionRef;
-  rootProviderModel: ProviderModelExecutionEvidence;
-  kind: "no-winner";
-  tree: TreeView;
-  downCount: number;
-  spentTotal: Spend;
-  rootStream?: RootStreamReceipt;
-  rootHarnessTranscript?: HarnessTranscriptEvidence;
-  continuation?: DriverContinuationRecord;
-  providerModel?: ProviderModelExecutionEvidence;
-  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
-  leakedReservations?: ReadonlyArray<LeakedReservation>;
-  spendGaps?: ReadonlyArray<SpendGap>;
-  fleetYield: FleetYield;
-  error?: never;
-  reason: "all-children-down" | "no-children-spawned" | "no-result-selected" | "stopped" | "budget-exhausted" | "deadline" | "aborted";
-} | {
-  execution?: AgentExecutionRef;
-  rootProviderModel: ProviderModelExecutionEvidence;
-  kind: "no-winner";
-  tree: TreeView;
-  downCount: number;
-  spentTotal: Spend;
-  rootStream?: RootStreamReceipt;
-  rootHarnessTranscript?: HarnessTranscriptEvidence;
-  continuation?: DriverContinuationRecord;
-  providerModel?: ProviderModelExecutionEvidence;
-  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
-  leakedReservations?: ReadonlyArray<LeakedReservation>;
-  spendGaps?: ReadonlyArray<SpendGap>;
-  fleetYield: FleetYield;
-  error?: never;
-  reason: "cancelled";
-  source: string;
-  cancellationReason: string;
-  operationId?: string;
-  operator?: string;
-} | {
-  execution?: AgentExecutionRef;
-  rootProviderModel: ProviderModelExecutionEvidence;
-  kind: "no-winner";
-  reason: "driver-failed";
-  tree: TreeView;
-  downCount: number;
-  spentTotal: Spend;
-  rootStream?: RootStreamReceipt;
-  rootHarnessTranscript?: HarnessTranscriptEvidence;
-  continuation?: DriverContinuationRecord;
-  providerModel?: ProviderModelExecutionEvidence;
-  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
-  leakedReservations?: ReadonlyArray<LeakedReservation>;
-  spendGaps?: ReadonlyArray<SpendGap>;
-  fleetYield: FleetYield;
-  error: NoWinnerError;
-} | {
-  execution?: AgentExecutionRef;
-  rootProviderModel: ProviderModelExecutionEvidence;
-  kind: "winner";
-  out: unknown;
-  outRef: string;
-  verdict?: import("@tangle-network/agent-eval").DefaultVerdict;
-  tree: TreeView;
-  spentTotal: Spend;
-  rootStream?: RootStreamReceipt;
-  rootHarnessTranscript?: HarnessTranscriptEvidence;
-  continuation?: DriverContinuationRecord;
-  providerModel?: ProviderModelExecutionEvidence;
-  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
-  spendGaps?: ReadonlyArray<SpendGap>;
-  fleetYield: FleetYield;
-  spentBreakdown?: {
-    driverInference: Spend;
-    childWork: Spend;
-  };
-}>;
-/** Deterministic scripted-brain path for tests. Not exported from Runtime's main entry. */
-declare function superviseWithTestBrain(profile: SupervisorProfile, task: unknown, opts: SuperviseTestOptions): Promise<{
-  execution?: AgentExecutionRef;
-  rootProviderModel: ProviderModelExecutionEvidence;
-  kind: "no-winner";
-  tree: TreeView;
-  downCount: number;
-  spentTotal: Spend;
-  rootStream?: RootStreamReceipt;
-  rootHarnessTranscript?: HarnessTranscriptEvidence;
-  continuation?: DriverContinuationRecord;
-  providerModel?: ProviderModelExecutionEvidence;
-  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
-  leakedReservations?: ReadonlyArray<LeakedReservation>;
-  spendGaps?: ReadonlyArray<SpendGap>;
-  fleetYield: FleetYield;
-  error?: never;
-  reason: "all-children-down" | "no-children-spawned" | "no-result-selected" | "stopped" | "budget-exhausted" | "deadline" | "aborted";
-} | {
-  execution?: AgentExecutionRef;
-  rootProviderModel: ProviderModelExecutionEvidence;
-  kind: "no-winner";
-  tree: TreeView;
-  downCount: number;
-  spentTotal: Spend;
-  rootStream?: RootStreamReceipt;
-  rootHarnessTranscript?: HarnessTranscriptEvidence;
-  continuation?: DriverContinuationRecord;
-  providerModel?: ProviderModelExecutionEvidence;
-  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
-  leakedReservations?: ReadonlyArray<LeakedReservation>;
-  spendGaps?: ReadonlyArray<SpendGap>;
-  fleetYield: FleetYield;
-  error?: never;
-  reason: "cancelled";
-  source: string;
-  cancellationReason: string;
-  operationId?: string;
-  operator?: string;
-} | {
-  execution?: AgentExecutionRef;
-  rootProviderModel: ProviderModelExecutionEvidence;
-  kind: "no-winner";
-  reason: "driver-failed";
-  tree: TreeView;
-  downCount: number;
-  spentTotal: Spend;
-  rootStream?: RootStreamReceipt;
-  rootHarnessTranscript?: HarnessTranscriptEvidence;
-  continuation?: DriverContinuationRecord;
-  providerModel?: ProviderModelExecutionEvidence;
-  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
-  leakedReservations?: ReadonlyArray<LeakedReservation>;
-  spendGaps?: ReadonlyArray<SpendGap>;
-  fleetYield: FleetYield;
-  error: NoWinnerError;
-} | {
-  execution?: AgentExecutionRef;
-  rootProviderModel: ProviderModelExecutionEvidence;
-  kind: "winner";
-  out: unknown;
-  outRef: string;
-  verdict?: import("@tangle-network/agent-eval").DefaultVerdict;
-  tree: TreeView;
-  spentTotal: Spend;
-  rootStream?: RootStreamReceipt;
-  rootHarnessTranscript?: HarnessTranscriptEvidence;
-  continuation?: DriverContinuationRecord;
-  providerModel?: ProviderModelExecutionEvidence;
-  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
-  spendGaps?: ReadonlyArray<SpendGap>;
-  fleetYield: FleetYield;
-  spentBreakdown?: {
-    driverInference: Spend;
-    childWork: Spend;
-  };
-}>;
-/**
- * Start a run as a version of a settled run: the parent's recorded root inputs plus one change.
- *
- * The call's `profile`, `task` and `budget` must be the parent's, byte for byte, as its sealed
- * journal records them. Runtime applies `change` to that profile and runs the result in a new
- * run directory. The parent directory is read and never written.
- */
-interface PursuitFork {
-  /** The settled parent's run directory. */
-  readonly runDir: string;
-  /** The sha256 of the parent's `result.json` bytes: the sealed point the fork starts from. */
-  readonly settleDigest: Sha256Digest;
-  /** The one change, applied to the parent's root profile. Its `id` is recorded. */
-  readonly change: AgentProfileDiff;
+  readonly watchWorkers?: WorkerWatchOptions;
+  /** Idle time after which `observe_agent` reports a running worker as `stalled`. A derived read
+   *  at observation time — nothing is killed or retried. Omit = the runtime default. */
+  readonly stallAfterMs?: number;
+  /** How Runtime wakes a manager that ended its turn with work open: the heartbeat, the debounce
+   *  that coalesces events into one wake, and the deadline warning. Omit = the defaults in
+   *  `./wake` (15 min, 2 s, 15 min). */
+  readonly wake?: ManagerWakePolicy;
+  /** Default continuity per worker PROFILE NAME: `'resume'` makes each spawn of that name after
+   *  the first re-attach to the node's most recent SETTLED worker — a NEW live worker whose spawn
+   *  context carries the prior worker's identity (`WorkerSpawnContext.resume`), which the executor
+   *  seam re-attaches with. `spawn_worker`'s per-call `continuity` argument overrides in either
+   *  direction; `runGraph` derives this from delegates-edge `continuity`. Omit = every spawn is
+   *  `'fresh'` (status quo). See `CoordinationToolsOptions.continuityByProfile` for the
+   *  refusal semantics (no-prior / while-live / with-key) and the process-local resume boundary. */
+  readonly continuityByProfile?: Readonly<Record<string, ContinuityMode>>;
+  /** Worker output store. Defaults to in-memory. */
+  readonly blobs?: ResultBlobStore;
+  /**
+   * Make the run DURABLE: journal + result blobs + the coordination side-log are file-backed under
+   * this directory (`createFileRunContext`), fsynced per write, and the supervisor reads the prior
+   * tree first. Re-running with the same `runDir` AND the same `runId` resumes only when the exact
+   * root profile/task identity and declared budget match. The original absolute deadline and prior
+   * measured spend are restored before new admission. The built-in driver is resume-aware: children
+   * that already settled, including their exact execution identities, are replayed onto
+   * `Scope.resume` (and into the driver's settled ledger + its first context), keyed assignments
+   * (`spawn_worker`'s `key`) resolve to their committed results instead of re-running, pending
+   * waits re-arm on their original deadlines, and the coordination log loads prior questions,
+   * findings, and instruction receipts. The router arm receives all three in its resume brief; the
+   * external arm seeds prior questions while findings and receipts remain in the durable log.
+   * Instruction receipts are evidence and are never delivered automatically to a replacement
+   * worker. The final result spans both processes' work. Unset = in-memory, fresh every call.
+   *
+   * The boundary that remains: work that was IN FLIGHT when the process died is not recovered —
+   * the built-in executors cannot re-attach to a dead process's executions. Each such keyed
+   * assignment resumes as `in-doubt`, its full declared reservation stays charged, and its
+   * token/dollar telemetry remains unknown. Runtime refuses a replacement under that key until the
+   * exact prior execution is recovered, so restart cannot duplicate work or slide the deadline.
+   *
+   * `runId` matters here: it defaults to the constant `'supervise'`, which is fine for a single
+   * resumable run per directory but collides across concurrent runs sharing one `runDir`.
+   */
+  readonly runDir?: string;
+  /** Hand a root with only a long wait and no live descendants to the caller's existing keeper.
+   * Requires runDir. Rejects with RunParkedError after the idle threshold, retaining wakeAt in
+   * the spawn journal without writing a terminal result. The caller must handle parking and
+   * resume the same runDir/runId at wakeAt. Omit to keep waits in this process. */
+  readonly parking?: RunParkingPolicy;
+  /** Advanced test seam: opt into resume-first when the durable stores are caller-supplied
+   * (`journal` + `blobs` / `runContext`) instead of derived from `runDir`. The normal durable path
+   * is `runDir` or a `runContext` (see `docs/durability.md`). Exactly what the file
+   * context sets automatically: load the prior tree for `runId` before starting fresh, refuse a
+   * reused id without it. Ignored when `runDir` is also set — the file context owns the flag. */
+  readonly resume?: boolean;
   /**
-   * Fork a parent whose journal holds a node without a terminal record, an unbegun owned tree, an
-   * unconfirmed teardown, or work in flight. Such a node may still act, and a fork never replays
-   * the parent's children, so it can only duplicate work outside the fork's tree. The root then
-   * records those node ids as `forkParentUncertainNodes`. Omit it to refuse such a parent.
+   * The segment this entry runs the root in. A run keeps one id for its whole life: a turn that
+   * ends, a lost stream and a dead supervisor are boundaries between entries, and a resume may move
+   * the root to another model, provider, reasoning effort or harness, or onto another stack, as a
+   * new segment of the same run. `profile` stays the root profile the run recorded, so its identity,
+   * coordination owner and settled children resume unchanged; the root executes that profile with
+   * `model.provider`, `model.default`, `model.reasoningEffort` and `harness` replaced where given. `stack` names the
+   * package versions the caller runs this entry under, its Runtime among them; Runtime records it
+   * and never reads it. When the segment differs from the one the run last ran, the journal gains
+   * one `root-segment` record with the time and `reason`. A different task, or any other profile
+   * change, is still a resume identity mismatch: that is a new run. A fresh run records its first
+   * segment and refuses a model or harness change: a new run takes them from its profile.
+   *
+   * A harness change starts a new native session: a session of one harness cannot continue in
+   * another. The root re-enters with its objective and the run's state, in a workspace restored
+   * from its latest checkpoint when the provider holds one.
    */
-  readonly acceptUncertain?: boolean;
-}
-/**
- * The `execution.correlation` keys a fork records on its root. Runtime writes them; a caller that
- * supplies one is refused. `lineageRootRunId` is the first run of the chain of parents, so the
- * spend of every version of one lineage groups under one id.
- */
-declare const RUN_FORK_CORRELATION_KEYS: readonly ["forkParentRunId", "forkParentSettleDigest", "forkProfileDiffId", "lineageRootRunId"];
-/** A flow node's usable settle matched no routes edge leaving it (`unrouted`), or a fired edge named
- *  a node that still had a running worker (`target-live`). The flow spawned nothing more; the full
- *  evidence rides on the error, shaped like `GraphEdgeCapError`. */
-declare class GraphRouteError extends Error {
-  readonly reason: 'unrouted' | 'target-live';
-  readonly node: NodeId;
-  readonly workerId: string;
-  readonly ledger: ReadonlyArray<EdgeTraversal>;
-  readonly result: SupervisedResult<unknown>;
-  constructor(unrouted: {
-    readonly reason: 'unrouted' | 'target-live';
-    readonly node: NodeId;
-    readonly workerId: string;
-    readonly detail: string;
-  }, ledger: ReadonlyArray<EdgeTraversal>, result: SupervisedResult<unknown>);
-}
-/** Default per-edge traversal cap — the cyclic-graph backstop when an edge names none. */
-declare const defaultEdgeTraversalCap = 32;
-/** An environment-owned check command, run outside the agent's conversation. */
-interface GraphCommandCheck {
-  readonly command: string;
-  readonly timeoutMs?: number;
-}
-interface GraphFromStoredOptions {
-  readonly trigger?: Readonly<Record<string, unknown>>;
-  readonly checks?: Readonly<Record<string, AgentGraph['deliverable']['check'] | GraphCommandCheck>>;
-}
-/** A graph node: an id and a canonical `AgentProfile`. The profile is the ONLY way a node is
- *  described — its `prompt.systemPrompt` is the standing role (the 0.117 canonical resolution;
- *  never a legacy top-level-only reduction), its tools/mcp/resources are its capabilities. */
-interface GraphNode {
-  readonly id: NodeId;
-  readonly profile: AgentProfile;
-}
-type GraphEdge =
-/** Work flows down. The delegation directive is DATA → versionable, sweepable, optimizable.
- *  Each spawn of `to` by `from` — and each mid-run steer from `from` to a live `to` worker —
- *  is one traversal. */
-{
-  readonly kind: 'delegates';
-  readonly from: NodeId;
-  readonly to: NodeId;
-  readonly directive: PromptHandle;
-  /** Cyclic-graph backstop: traversals beyond this REFUSE (fail loud). Default
-   *  {@link defaultEdgeTraversalCap}. */
-  readonly maxTraversals?: number;
-  /** Default continuity for this edge's SPAWN traversals. `'resume'` makes every spawn after
-   *  the node's first re-attach to its most recent SETTLED worker: a NEW live worker whose
-   *  spawn context carries `resume: { ofWorker, sequence }` for the executor seam, spending
-   *  from the same conserved pool — the node's first spawn is effectively `'fresh'`, and a
-   *  spawn while a prior worker is still live refuses loudly (steer is the live channel).
-   *  The driver's per-call `spawn_worker` `continuity` argument overrides either way. Omit =
-   *  `'fresh'` (today's behavior, byte-identical). Caps count resumes exactly like fresh
-   *  spawns. */
-  readonly continuity?: ContinuityMode;
-} |
-/** Findings flow anywhere: an analyst over N nodes' settled traces, delivered to ONE node.
- *  With a LENS analyst the directive wraps the findings for the recipient; with a NODE analyst
- *  the directive is the analyst agent's task and the findings are its settle output. */
-{
-  readonly kind: 'analyzes';
-  /** The analyst REFERENCE, in one of two forms: a lens id resolved against
-   *  `RunGraphOptions.analysts` (environment), or the id of a graph NODE with no delegates
-   *  edge pointing at it — then each matching settle spawns that node's pinned profile as a
-   *  tool-equipped analyst WORKER (same spawn machinery, conserved budget, trace join) whose
-   *  task is this edge's directive plus the settled worker's trace evidence and whose settle
-   *  output is the findings. An id that is both a node and a registry lens is refused. */
-  readonly analyst: string;
-  readonly over: ReadonlyArray<NodeId>;
-  readonly to: NodeId;
-  readonly directive: PromptHandle;
-  /** Observability cap: traversals beyond this are LEDGERED as exhausted (`unpropagated`).
-   *  Only delegates caps refuse traversal — they are what close the spawn cycle. */
-  readonly maxTraversals?: number;
-} |
-/**
- * Fan-out over a list that exists only at run time, then one join. When `from` settles `done`,
- * the array at `pointer` in its result is expanded: each element becomes the TASK of one item
- * run, at most `concurrency` at a time, and once every item settled the `join` node runs with
- * `{ map, source, items, results: [{ index, item, result }], failures: [{ index, item, outcome,
- * reason }] }`, results in item order. The runtime spawns the items and the join (`from`'s
- * driver spends no turn on them) through the same authorized spawn path a delegates spawn
- * takes: each item reserves its budget from the one conserved pool and is pinned to the edge's
- * profile, so an item's content can never choose what runs.
- *
- * An item is either the node `to` (its pinned profile plus this edge's directive) or the nested
- * `graph`, started per item exactly as `run_graph` starts a graph. Refusals are loud and
- * ledgered, and the driver is woken with them: a pointer that does not resolve to an array, more
- * elements than `maxItems`, or a `concurrency` the run's worker-slot bound can never honor.
- * `concurrency` otherwise THROTTLES (items wait for a free place); it never refuses an item.
- *
- * An edge rather than a node-level spec, because every kernel invariant a map must keep already
- * attaches to edge traversal: pinning admits only the edge's item and join nodes (the spawn
- * context carries a runtime-authored `map` marker), each item is admitted like a spawn and
- * reserves from the conserved pool, each item settles under its own deliverable check, and each
- * expansion, item and join is a ledger row with its journal twin. Topology stays static; only the
- * traversal count is dynamic, so validation and the one-node-one-profile rule are unchanged.
- */
-{
-  readonly kind: 'maps';
-  /** The source node: a delegates target, or the join of another maps edge. Each of its `done`
-   *  settles expands the map once. */
-  readonly from: NodeId;
-  /** RFC 6901 JSON pointer into `from`'s settled result (`''` is the whole result). */
-  readonly pointer: string;
-  /** The item node, run once per element with the element as its task. Exactly one of `to`
-   *  and `graph`. Reachable only through this edge: never a delegates target. */
-  readonly to?: NodeId;
-  /** A graph run per element as one subtask, through the `run_graph` path. */
-  readonly graph?: GraphTopology;
-  /** Receives the ordered results once every item settled. Reachable only through this edge. */
-  readonly join: NodeId;
-  /** The item directive, appended to the item node's instructions per traversal. */
-  readonly directive: PromptHandle;
-  /** Lists longer than this are refused before any item runs. */
-  readonly maxItems: number;
-  /** How many items run at once. */
-  readonly concurrency: number;
-  readonly onItemFailure: MapItemFailurePolicy;
-  /** Each item's budget, merged over the per-worker default as `spawn_worker`'s `budget` is. */
-  readonly itemBudget?: Partial<Budget>;
-} |
-/**
- * A route in a flow graph (one with `entry`): Runtime traverses it when `from` settles, so no
- * root decides the order, the branch, the repair loop or the stop. On each usable settle of
- * `from` its outgoing routes edges are tried in declaration order and the first whose `when`
- * holds fires; an edge without `when` is the default branch and comes last. A node target is
- * spawned with `{ from: { node, result }, evidence: { [id]: latest usable result } }` (a join's
- * target with `{ from: { nodes }, evidence }`, see below) and the directive appended to its pinned instructions; `{ stop }` ends the run with no winner and
- * `GraphResult.stopped`; `{ finish }` makes this settle part of the run's output.
- *
- * A fork lists two or more nodes in `to`: one traversal spawns each of them at once, each under
- * its own key `route:<edge id>#<traversal>:<node>`. A join lists two or more nodes in `from`: it
- * fires once every member has settled usably since it last fired, and the target's task is
- * `{ from: { nodes: <members in declared order> }, evidence }` with each member's latest result
- * in `evidence`, so it does not depend on which member settled last and a resumed run derives the
- * same task. A routes edge that spawns a node with a settled worker in this flow (a back edge)
- * names that node's latest settled worker as the spawn's `successorOf`. A join carries no `when`, and it is the only routes edge
- * leaving each of its members. A route into a node that still has a running worker throws
- * {@link GraphRouteError} with reason `target-live`: converging branches use a join.
- */
-{
-  readonly kind: 'routes';
-  readonly from: NodeId | ReadonlyArray<NodeId>;
-  readonly to: NodeId | ReadonlyArray<NodeId> | {
-    readonly stop: string;
-  } | {
-    readonly finish: string;
+  readonly segment?: {
+    readonly provider?: string;
+    readonly model?: string;
+    readonly reasoningEffort?: ReasoningEffort;
+    readonly harness?: AgentProfile['harness'];
+    readonly stack?: Readonly<Record<string, string>>;
+    readonly reason: string;
   };
-  readonly directive: PromptHandle;
-  /** Absent on the default edge and on every join. A match reads `from` unless it names a node
-   *  in `evidence`. */
-  readonly when?: RouteWhen;
-  /** Nodes whose latest usable result rides the target's task. */
-  readonly evidence?: ReadonlyArray<NodeId>;
-  /** Traversals beyond this are skipped (ledgered `unpropagated`) and matching continues with
-   *  the next edge. Default {@link defaultEdgeTraversalCap}. Every routes cycle, each subcycle
-   *  included, must cross an edge that sets it. */
-  readonly maxTraversals?: number;
-  /** `'resume'` re-attaches each spawn of the target to its latest settled session. Omit =
-   *  `'fresh'`. */
-  readonly continuity?: ContinuityMode;
-};
-/** A topology without the run's own budget and deliverable: the form a `maps` edge runs per item,
- *  as `run_graph` runs it. With `entry` it is a flow graph. Inside a maps item, the item value is
- *  the task of every entry whose task is the placeholder `{ item: true }`; a down settle inside the item ends
- *  that item only, and the maps edge's `onItemFailure` decides the join. */
-interface GraphTopology {
-  readonly nodes: ReadonlyArray<GraphNode>;
-  readonly edges: ReadonlyArray<GraphEdge>;
-  readonly entry?: AgentGraph['entry'];
-  /** Refused here: a maps item's graph and a `run_graph` subtask have no `decideGate`. */
-  readonly gates?: AgentGraph['gates'];
-}
-interface AgentGraph {
-  /** Preserve fully bound literal data when serializing a hydrated graph. */
-  readonly triggerBindings?: readonly [];
-  readonly nodes: ReadonlyArray<GraphNode>;
-  readonly edges: ReadonlyArray<GraphEdge>;
-  /** Termination is mandatory, not optional: the independent completion oracle. */
-  readonly deliverable: DeliverableSpec<unknown> & {
-    readonly checkRef?: string;
-    readonly command?: GraphCommandCheck;
-    readonly when?: RouteWhen;
+  /** Durable steer directory when it differs from the run-control directory. */
+  readonly steerDir?: string;
+  /** Override the spawn journal directly (advanced; `runDir` is the ordinary durable path). Pair
+   *  with `blobs` — a journal whose result payloads live in a different store cannot replay. */
+  readonly journal?: SpawnJournal;
+  /**
+   * PROGRESS-derived stop rule (BOTH arms). Ends a run that has stopped LEARNING before it
+   * exhausts a ceiling — the answer to "a run should end because it is done or stuck, not because
+   * it ran out". It composes with the budget guards and can never override one.
+   *
+   * The evaluation boundary differs by arm because the loop does: a router-brained supervisor is
+   * evaluated before each of its own inference turns; a harness-brained supervisor is evaluated on
+   * each worker settle, and a stop aborts its stop signal so the harness ends at its next turn
+   * boundary. Both arms fold the same settled ledger through the same evaluator.
+   *
+   * Build it from `supervise/stop-rules`: `plateau({window, minDelta})`,
+   * `noProgressFor({ms, settles})`, `allWorkersStalled({...})`, combined with `anyOf`/`allOf`. The
+   * thresholds are policy and stay with you; the enforcement lives in the runtime. Omit = ceilings
+   * only (unchanged behavior).
+   *
+   * A record may declare the plateau rule as data, `{ plateau: { window, minDelta } }`, so no
+   * product module builds it.
+   */
+  readonly stopRule?: StopRule | {
+    readonly plateau: PlateauOptions;
   };
-  /** One conserved pool across the whole graph — cycles without conservation never terminate. */
+  /** One-shot notification of WHY a `stopRule` ended the run (BOTH arms) — so a caller records the
+   *  reason instead of inferring an early stop from an unexhausted budget. */
+  readonly onProgressStop?: (reason: string) => void;
+  /** Recursion ceiling for the tree (root = 0). The conserved pool is what bounds depth, since each
+   *  level's slice comes out of the level above; this only stops a runaway recursion. Omit =
+   *  `DEFAULT_MAX_DEPTH` (16). */
+  readonly maxDepth?: number;
+  /** Turn cap for the supervisor's OWN loop (BOTH arms). Router arm: inference turns of the
+   *  driver's tool loop. Harness arm: turns the harness reports, counted off its `iteration`
+   *  stream — reaching the cap aborts the stop signal, so the harness ends at its next turn
+   *  boundary rather than mid-request. `0` lifts the cap on both arms and leaves the conserved
+   *  pool, the deadline, and abort as the bounds; a negative value is refused. Omit = the router
+   *  arm's default cap, and no turn cap on the harness arm. */
+  readonly maxTurns?: number;
+  /** Give the supervisor brain a chapter-lifecycle on its OWN context window (ROUTER ARM ONLY —
+   *  a harness owns its own context window and its own compaction, so this is refused for a
+   *  harness-brained supervisor rather than silently ignored): once its coordination transcript
+   *  exceeds `thresholdTokens` it distills to a compact progress note and continues, instead of
+   *  re-billing the whole transcript every turn (the cost that makes the LLM-brain front door lose
+   *  to a dumb-Ralph respawn). The live `Scope` roster is the durable state across chapters.
+   *  Default off. `distill` defaults to a brain self-summary + the settled-worker roster. */
+  readonly compaction?: ToolLoopCompactionOptions;
+  readonly runId?: string;
+  readonly now?: () => number;
+  /** Restrict the run to this subset of models. When set, every configured model — the
+   *  supervisor router model, the profile's model, and the backend's model — must be a member,
+   *  or `supervise()` throws a `ConfigError` before any compute is spent. Unset = unrestricted.
+   *
+   *  This is a MODEL-ID filter, not a route filter. The compared values are the bare ids a profile
+   *  declares — `model.default`, `model.small`, `subagents[].model`, `modes[].model`. The composed
+   *  wire id (`harness/provider/model`) is never built here and never compared, so an entry written
+   *  in qualified form matches nothing, and a child that names an allowed id is admitted whatever
+   *  harness and provider its own profile declares. Pin the route with `authorizeSpawn`: it reads
+   *  the authored child profile and may refuse the spawn before any reservation. */
+  readonly allowedModels?: readonly string[];
+  /** How the settled-worker ledger becomes the run's output. Default `bestDelivered` — the single
+   *  highest-scoring DELIVERED child (the exact behavior every existing caller had). Alternatives:
+   *  `collectDelivered` (every verified distinct output with provenance — a Pareto set / recorded
+   *  disagreement) or a custom `SupervisorFinalizer`. Whatever the finalizer, it operates on
+   *  structurally DELIVERED outputs only — an undelivered or invalid child stays ineligible. A
+   *  `string` names an entry in `registry.finalizers`. */
+  readonly finalizer?: SupervisorFinalizer | string;
+  /** Lifecycle observers for the whole recursive tree (`Scope` re-seeds them into every nested
+   *  scope). Composed with the `otel` recorder below when both are set. Omit = no observers, which
+   *  is the behavior every existing caller has. */
+  readonly hooks?: RuntimeHooks;
+  /**
+   * OPT-IN OTLP tracing: emit one span per supervised node (opened at spawn, closed at settle,
+   * parented to its parent node's span) plus an `LLM` child span per metered driver turn, so the
+   * tree is readable by any trace viewer instead of only by a journal parser. See `otel-spans.ts`.
+   *
+   * Omit and the run emits nothing, allocates no recorder, and installs no hook — telemetry is
+   * never a default. Present with no reachable endpoint (no `exportConfig.endpoint` and no
+   * `OTEL_EXPORTER_OTLP_ENDPOINT`) is also a no-op. The spawn journal is untouched either way:
+   * spans are telemetry, never the replay/resume record.
+   */
+  readonly otel?: Omit<SupervisorSpanOptions, 'runId' | 'now' | 'namespace'>;
+}
+/** The product-authorized result for one complete spawn request. Attribution is never accepted
+ * from the manager itself; it enters only through this trusted callback. */
+interface AuthorizedSpawn {
+  readonly profile: AgentProfile;
+  readonly execution?: AgentExecutionRef;
+}
+/** Exact trusted context after a manager-authored spawn has passed product authorization. */
+interface AuthorizedSpawnContext {
+  readonly profile: AgentProfile;
+  readonly parent: AgentProfile;
+  readonly parentIdentity: NodeExecutionIdentity;
+  readonly execution: NodeExecutionIdentity;
+  readonly parentNodeId: string;
+  readonly assignmentId: string;
+  readonly task: unknown;
   readonly budget: Budget;
-  /** Setting it makes this a FLOW graph: Runtime spawns every entry at once, each with its task,
-   *  and traverses `routes` edges itself. No node is a root and no caller brain runs; the run's
-   *  output is `{ [node]: latest usable result }` over its terminal nodes and `finish` sources,
-   *  judged by `deliverable`. A stored route check (`checkRef: 'route'`) may also name a
-   *  non-terminal node: its condition reads that node's latest delivered output, while the output
-   *  stays terminal-only. */
-  readonly entry?: ReadonlyArray<{
-    readonly node: NodeId;
-    readonly task: unknown;
-  }>;
-  /** Flow-graph vertices that are not agents: a routes edge into one awaits
-   *  `RunGraphOptions.decideGate`, and one edge per choice leaves it, matching
-   *  `{ pointer: '/choice', equals: <choice> }`. A `finish` leaving a gate outputs
-   *  `{ [gate]: { choice, by } }`. */
-  readonly gates?: ReadonlyArray<RouteGate>;
+  readonly label: string;
+  readonly key?: string;
+  readonly depth: number;
 }
-/** `failed` is a maps item or join that ran and settled without a usable result (down, or
- *  rejected by its deliverable check); a traversal that never reached a worker is `unpropagated`. */
-type EdgeDeliveryOutcome = 'delivered' | 'stripped' | 'empty' | 'unpropagated' | 'failed';
-/** How one ledgered hop CONTINUED: a spawn traversal stamps its effective spawn mode
- *  (`'fresh'` | `'resume'`), and every mid-run delivery into an already-live recipient — a
- *  driver steer leg and every analyzes delivery (routed steer or driver-destined finding) —
- *  stamps `'steer'`. Zero ambiguity: every row carries exactly one of the three. */
-type TraversalContinuity = ContinuityMode | 'steer';
-/** One recorded edge traversal — the in-memory row; the journal twin is the `edge` SpawnEvent. */
-interface EdgeTraversal {
-  /** Stable edge id: `delegates:<from>-><to>`, `analyzes:<analyst>:<over…>-><to>`,
-   *  `maps:<from>-><to | graph>-><join>`, `routes:<from>#<ordinal>-><to | stop:<reason> |
-   *  finish:<reason>>`, or `routes:entry-><node>` for an entry. */
-  readonly edge: string;
-  readonly kind: 'delegates' | 'analyzes' | 'maps' | 'routes';
-  readonly from: string;
-  readonly to: string;
-  /** The resolved directive reference (`<surface>/v<n>`). */
-  readonly directive: string;
-  /** 1-based per-edge ordinal. */
-  readonly traversal: number;
-  readonly outcome: EdgeDeliveryOutcome;
-  /** How this hop continued — see {@link TraversalContinuity}. */
-  readonly continuity: TraversalContinuity;
-  /** Bytes of directive + payload that actually crossed the edge. */
-  readonly bytes: number;
-  readonly reason?: string;
-  /** The concrete worker node id, once known. A maps expansion names the source worker. */
-  readonly workerId?: string;
-  /** Present on maps rows: the expansion of the source's list, one item by its index, or the
-   *  join. */
-  readonly map?: {
-    readonly phase: 'expand' | 'item' | 'join';
-    readonly index?: number;
+/** Exact trusted context for selecting one backend-derived leaf's completion check. */
+type DeliverableResolutionInput = AuthorizedSpawnContext;
+/** Test-only one-call shape, exported only through the package's explicit `/testing` entry. */
+interface SuperviseTestOptions extends SuperviseOptions {
+  readonly brain: ToolLoopChat;
+}
+/**
+ * Build the worker seam from a backend (WHERE workers run) + an optional completion oracle (the
+ * deliverable check that makes "settled ⟺ delivered" true — the guard against "ran but didn't
+ * deliver"). The ONE place a backend becomes a spawnable worker.
+ *
+ * `seams` exists because this path builds the leaf executor EAGERLY and hands it back as a BYO
+ * `executorSpec.executor`. The registry resolves a BYO executor without ever consulting the
+ * per-child `ExecutorContext` the `Scope` seeds, so anything the scope would have supplied is
+ * invisible here and has to be passed in. It is a FUNCTION because it is resolved once per worker
+ * construction, so a caller may hand back something the run only learns later — which is exactly how
+ * `supervise()` gives a traced run's workers their trace context without ordering the span recorder
+ * ahead of the worker seam.
+ *
+ * Continuity: the `bridge` backend honors `continuity: 'resume'` by session re-attachment. A
+ * bridge session id IS the harness conversation key (cli-bridge maps it to the CLI's own resume —
+ * opencode `-s <id>`, claude `--resume`), so this seam records the session id each supervised
+ * spawn was bound to, keyed by the worker id the Scope assigned, and a resume spawn binds the
+ * prior worker's recorded session id instead of deriving a fresh one. The record is process-local
+ * by construction, which matches the kernel's resume boundary (a prior process's workers are not
+ * resume targets). Every other backend keeps failing loud: their executors have no re-attachable
+ * session, and accepting the spawn would ledger `continuity: 'resume'` over a brand-new session —
+ * a stamp asserting something that never happened.
+ */
+declare function workerFromBackend(backend: ExecutorConfig, deliverable?: DeliverableSpec<unknown>, seams?: () => Readonly<Record<string, unknown>>): MakeWorkerAgent;
+/** Capabilities a data-only consumer may require before building an opted-in run. `graphTools`:
+ *  a manager whose profile grants `run_graph` can start an agent graph as one subtask. */
+declare const superviseFleetCapabilities: Readonly<{
+  peerAudit: true;
+  traceTools: true;
+  graphTools: true;
+}>;
+/** One-call supervisor: build + run a supervisor from its exact profile. @stable */
+declare function supervise(profile: SupervisorProfile, task: unknown, opts: SuperviseOptions): Promise<{
+  execution?: AgentExecutionRef;
+  rootProviderModel: ProviderModelExecutionEvidence;
+  kind: "no-winner";
+  tree: TreeView;
+  downCount: number;
+  spentTotal: Spend;
+  usage?: SettledUsage;
+  rootStream?: RootStreamReceipt;
+  rootHarnessTranscript?: HarnessTranscriptEvidence;
+  continuation?: DriverContinuationRecord;
+  providerModel?: ProviderModelExecutionEvidence;
+  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
+  leakedReservations?: ReadonlyArray<LeakedReservation>;
+  spendGaps?: ReadonlyArray<SpendGap>;
+  fleetYield: FleetYield;
+  error?: never;
+  reason: "all-children-down" | "no-children-spawned" | "no-result-selected" | "stopped" | "budget-exhausted" | "deadline" | "aborted";
+} | {
+  execution?: AgentExecutionRef;
+  rootProviderModel: ProviderModelExecutionEvidence;
+  kind: "no-winner";
+  tree: TreeView;
+  downCount: number;
+  spentTotal: Spend;
+  usage?: SettledUsage;
+  rootStream?: RootStreamReceipt;
+  rootHarnessTranscript?: HarnessTranscriptEvidence;
+  continuation?: DriverContinuationRecord;
+  providerModel?: ProviderModelExecutionEvidence;
+  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
+  leakedReservations?: ReadonlyArray<LeakedReservation>;
+  spendGaps?: ReadonlyArray<SpendGap>;
+  fleetYield: FleetYield;
+  error?: never;
+  reason: "cancelled";
+  source: string;
+  cancellationReason: string;
+  operationId?: string;
+  operator?: string;
+} | {
+  execution?: AgentExecutionRef;
+  rootProviderModel: ProviderModelExecutionEvidence;
+  kind: "no-winner";
+  reason: "driver-failed";
+  tree: TreeView;
+  downCount: number;
+  spentTotal: Spend;
+  usage?: SettledUsage;
+  rootStream?: RootStreamReceipt;
+  rootHarnessTranscript?: HarnessTranscriptEvidence;
+  continuation?: DriverContinuationRecord;
+  providerModel?: ProviderModelExecutionEvidence;
+  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
+  leakedReservations?: ReadonlyArray<LeakedReservation>;
+  spendGaps?: ReadonlyArray<SpendGap>;
+  fleetYield: FleetYield;
+  error: NoWinnerError;
+} | {
+  execution?: AgentExecutionRef;
+  rootProviderModel: ProviderModelExecutionEvidence;
+  kind: "winner";
+  out: unknown;
+  outRef: string;
+  verdict?: import("@tangle-network/agent-eval").DefaultVerdict;
+  tree: TreeView;
+  spentTotal: Spend;
+  usage?: SettledUsage;
+  rootStream?: RootStreamReceipt;
+  rootHarnessTranscript?: HarnessTranscriptEvidence;
+  continuation?: DriverContinuationRecord;
+  providerModel?: ProviderModelExecutionEvidence;
+  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
+  spendGaps?: ReadonlyArray<SpendGap>;
+  fleetYield: FleetYield;
+  spentBreakdown?: {
+    driverInference: Spend;
+    childWork: Spend;
   };
-  /** Present on a gate's decision row (`gate:<id>`, `traversal` = visit): who decided, and what. */
-  readonly gate?: GateDecisionRecord;
-}
-/** A delegates edge exhausted its traversal cap and the run produced no winner: the cap, not the
- *  task, ended it. Carries the full evidence so failing loud loses nothing. */
-declare class GraphEdgeCapError extends Error {
-  readonly exhaustedEdges: ReadonlyArray<string>;
-  readonly ledger: ReadonlyArray<EdgeTraversal>;
-  readonly result: SupervisedResult<unknown>;
-  constructor(exhaustedEdges: ReadonlyArray<string>, ledger: ReadonlyArray<EdgeTraversal>, result: SupervisedResult<unknown>);
-}
-/**
- * Forwarded to the root `supervise()` VERBATIM. Everything not owned, transformed, or refused
- * above belongs here — the default is "a graph honors it", not "someone remembered to add it".
- */
-declare const GRAPH_FORWARDED_SUPERVISE_OPTIONS: readonly ["parking", "backend", "profileGuidance", "escalateQuestion", "rootHandle", "signal", "execution", "resolveDeliverable", "coordination", "peerMail", "peerAudit", "traceTools", "driverBackend", "profileSecurity", "authorizeSpawn", "router", "driveHarness", "selectSeat", "driverRetry", "onDriverAttempt", "continuation", "childSettleGraceMs", "teardownConfirmMs", "retainedAtSettlement", "resolveDriveHarness", "driveHarnessMaterialization", "resolveSupervisorTools", "extraTools", "executeExtraTool", "recoverExecutor", "perWorker", "reservationPolicy", "deadlineCheckIn", "budgetStopHoldMs", "workerSlots", "watchWorkers", "stallAfterMs", "wake", "runDir", "resume", "segment", "runContext", "steerDir", "stopRule", "onProgressStop", "maxDepth", "maxTurns", "compaction", "now", "allowedModels", "finalizer", "otel", "graphRegistry"];
-/** `backend` and `driverBackend` keep graph-specific documentation below.
- *
- * Do not inherit and redeclare them through an indexed access type.
- * TypeScript 7 correctly treats `SuperviseOptions['backend']` as including `undefined`, which makes
- * that redeclaration wider than the exact optional property inherited from `SuperviseOptions`.
- */
-type GraphInheritedSuperviseOption = Exclude<(typeof GRAPH_FORWARDED_SUPERVISE_OPTIONS)[number], 'backend' | 'driverBackend'>;
+}>;
+/** Deterministic scripted-brain path for tests. Not exported from Runtime's main entry. */
+declare function superviseWithTestBrain(profile: SupervisorProfile, task: unknown, opts: SuperviseTestOptions): Promise<{
+  execution?: AgentExecutionRef;
+  rootProviderModel: ProviderModelExecutionEvidence;
+  kind: "no-winner";
+  tree: TreeView;
+  downCount: number;
+  spentTotal: Spend;
+  usage?: SettledUsage;
+  rootStream?: RootStreamReceipt;
+  rootHarnessTranscript?: HarnessTranscriptEvidence;
+  continuation?: DriverContinuationRecord;
+  providerModel?: ProviderModelExecutionEvidence;
+  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
+  leakedReservations?: ReadonlyArray<LeakedReservation>;
+  spendGaps?: ReadonlyArray<SpendGap>;
+  fleetYield: FleetYield;
+  error?: never;
+  reason: "all-children-down" | "no-children-spawned" | "no-result-selected" | "stopped" | "budget-exhausted" | "deadline" | "aborted";
+} | {
+  execution?: AgentExecutionRef;
+  rootProviderModel: ProviderModelExecutionEvidence;
+  kind: "no-winner";
+  tree: TreeView;
+  downCount: number;
+  spentTotal: Spend;
+  usage?: SettledUsage;
+  rootStream?: RootStreamReceipt;
+  rootHarnessTranscript?: HarnessTranscriptEvidence;
+  continuation?: DriverContinuationRecord;
+  providerModel?: ProviderModelExecutionEvidence;
+  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
+  leakedReservations?: ReadonlyArray<LeakedReservation>;
+  spendGaps?: ReadonlyArray<SpendGap>;
+  fleetYield: FleetYield;
+  error?: never;
+  reason: "cancelled";
+  source: string;
+  cancellationReason: string;
+  operationId?: string;
+  operator?: string;
+} | {
+  execution?: AgentExecutionRef;
+  rootProviderModel: ProviderModelExecutionEvidence;
+  kind: "no-winner";
+  reason: "driver-failed";
+  tree: TreeView;
+  downCount: number;
+  spentTotal: Spend;
+  usage?: SettledUsage;
+  rootStream?: RootStreamReceipt;
+  rootHarnessTranscript?: HarnessTranscriptEvidence;
+  continuation?: DriverContinuationRecord;
+  providerModel?: ProviderModelExecutionEvidence;
+  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
+  leakedReservations?: ReadonlyArray<LeakedReservation>;
+  spendGaps?: ReadonlyArray<SpendGap>;
+  fleetYield: FleetYield;
+  error: NoWinnerError;
+} | {
+  execution?: AgentExecutionRef;
+  rootProviderModel: ProviderModelExecutionEvidence;
+  kind: "winner";
+  out: unknown;
+  outRef: string;
+  verdict?: import("@tangle-network/agent-eval").DefaultVerdict;
+  tree: TreeView;
+  spentTotal: Spend;
+  usage?: SettledUsage;
+  rootStream?: RootStreamReceipt;
+  rootHarnessTranscript?: HarnessTranscriptEvidence;
+  continuation?: DriverContinuationRecord;
+  providerModel?: ProviderModelExecutionEvidence;
+  teardownUnconfirmed?: ReadonlyArray<UnconfirmedTeardown>;
+  spendGaps?: ReadonlyArray<SpendGap>;
+  fleetYield: FleetYield;
+  spentBreakdown?: {
+    driverInference: Spend;
+    childWork: Spend;
+  };
+}>;
 /**
- * Options for one `runGraph` run.
+ * Start a run as a version of a settled run: the parent's recorded root inputs plus one change.
  *
- * Extends every forwarded `SuperviseOptions` key, so a graph honors what a `supervise()` run
- * honors WITHOUT anyone restating it here. Only the graph-specific members and the ones whose
- * graph semantics differ are declared below; everything else inherits its type AND its
- * documentation from `SuperviseOptions`, which is the one owner of both.
+ * The call's `profile`, `task` and `budget` must be the parent's, byte for byte, as its sealed
+ * journal records them. Runtime applies `change` to that profile and runs the result in a new
+ * run directory. The parent directory is read and never written.
  */
-interface RunGraphOptions extends Pick<SuperviseOptions, GraphInheritedSuperviseOption> {
-  /** WHERE worker nodes run — the executor backend. Provide this OR `makeLeafAgent`. Forwarded to
-   *  `supervise()`, which derives every authorized leaf from it. A node that declares
-   *  `agent_runtime_coordination_spawn_worker` becomes a nested supervisor instead, whose own
-   *  leaves are derived the same way. */
-  readonly backend?: Exclude<SuperviseOptions['backend'], undefined>;
-  /** WHERE the ROOT node's harness brain runs — forwarded to `supervise()` verbatim (see
-   *  `SuperviseOptions.driverBackend`). Needed when the root node's profile declares an external
-   *  harness (`codex`, `claude-code`, `opencode`): that root is driven by the harness, not by the
-   *  router brain, and automatic execution supports a local `bridge`. Unlike `supervise()`, this
-   *  does NOT default to `backend`: a graph's `backend` places WORKER nodes, so the root driver
-   *  is selected only by this field. Omit = no harness driver, which is correct for a root whose
-   *  `profile.harness` is omitted or `cli-base` (that root runs on the router brain). */
-  readonly driverBackend?: Exclude<SuperviseOptions['driverBackend'], undefined>;
-  /** Leaf-execution override (offline tests / advanced). `runGraph` still owns node pinning,
-   *  directive delivery, and the edge ledger AROUND this seam — only the leaf `act` is yours.
-   *  Slots INSIDE the kernel's authorized path (`SuperviseOptions.makeLeafAgent`), so a node that
-   *  declares the spawn tool still becomes a nested supervisor even under an offline leaf. */
-  readonly makeLeafAgent?: MakeWorkerAgent;
-  /** The ROOT driver's inference seam — a caller-owned `ToolLoopChat` that makes every root
-   *  model call. Use it when the root's decisions must be caller-owned orchestration (a
-   *  deterministic conversation driver, a persona loop with its own LLM calls) rather than a
-   *  router-derived model call. The graph machinery around the seam is unchanged: node pinning,
-   *  directive delivery, the edge ledger, and the journal twin all run the same shipped path,
-   *  and the root profile keeps prompt control (`prompt-control-execution` materialization —
-   *  `systemPrompt`/`instructions` still apply). What moves to the caller with the brain:
-   *  model selection and provider-identity validation (`expectedModel` cannot be enforced on a
-   *  call the runtime did not place) and per-turn usage reporting (a brain that reports no
-   *  usage meters nothing into the pool). Omit = the router brain derived from the root
-   *  profile — the unchanged default. Mutually exclusive with `driverBackend`, and refused
-   *  when the root profile declares an external harness (that root is driven BY the harness). */
-  readonly brain?: ToolLoopChat;
-  /** Caller-side runtime hooks (telemetry, policy, product extensions). Composed AFTER the
-   *  graph's own spawn-binding hook on the SAME event stream — the graph never swallows the
-   *  seam supervise() exposes. */
-  readonly hooks?: RuntimeHooks;
-  /** The analyst lens registry `analyzes` edges resolve against. ENVIRONMENT — needed only for
-   *  lens analysts; an analyzes edge naming a graph NODE as its analyst needs no registry. */
-  readonly analysts?: AnalystRegistry$1;
-  /** Answers a flow gate while the process holds the run; the wait counts against its deadline.
-   *  ENVIRONMENT, like `analysts`; required when the graph declares gates. */
-  readonly decideGate?: (request: GateRequest) => Promise<GateDecision>;
-  /** Directive registry. Default: the seeded kernel registry (`kernelPromptRegistry()`).
-   *
-   *  NOT `SuperviseOptions.registry`, which is the `SuperviseRegistry` name→value table for
-   *  code-valued options. The two share a name and nothing else, and this one wins here — see
-   *  `GRAPH_REFUSED_SUPERVISE_OPTIONS`. */
-  readonly registry?: PromptRegistry;
-  /** The run journal the edge ledger and every spawn/settle ride. Default: in-memory. */
-  readonly journal?: SpawnJournal;
-  readonly blobs?: ResultBlobStore;
-  readonly runId?: string;
-  /** Product authority over every steer/answer instruction (the filter seam). `runGraph` observes
-   *  what it CHANGES: a narrowed instruction ledgers its steer traversal as `stripped`. */
-  readonly authorizeMessage?: SuperviseOptions['authorizeMessage'];
-}
-interface GraphResult<Out = unknown> {
-  readonly result: SupervisedResult<Out>;
-  /** Every edge traversal, in occurrence order — the observable-edge contract. */
-  readonly ledger: ReadonlyArray<EdgeTraversal>;
-  /** Edge ids whose traversal cap was hit — analyzes exhaustion included (observable here, never
-   *  a refusal). A DELEGATES cap paired with a `no-winner` result THROWS
-   *  ({@link GraphEdgeCapError}) instead of returning: only delegates caps refuse spawns, so only
-   *  they can have ended the run. A LIFECYCLE no-winner (`aborted` / `budget-exhausted`) returns
-   *  normally even with an exhausted delegates cap — the abort or the pool, not the cap, ended
-   *  that run, and the exhaustion stays observable here. */
-  readonly exhaustedEdges: ReadonlyArray<string>;
-  readonly runId: string;
-  /** Why a flow graph ended early: a `stop` edge fired (`edge` names it), or a flow node settled
-   *  down (no `edge`; `reason` is `down: <worker reason>`) or, where a route was needed, without a
-   *  usable result (no `edge`; `reason` is `unusable: <why>`). Live flow workers are aborted. */
-  readonly stopped?: {
-    readonly code?: string;
-    readonly edge?: string;
-    readonly at: NodeId;
-    readonly workerId: string;
-    readonly reason: string;
-  };
-}
-/** `RunGraphOptions` with the brain REQUIRED — the shape the `/testing` entry's
- *  `runGraphWithTestBrain` keeps accepting now that `brain` is a production option. */
-interface RunGraphTestOptions extends RunGraphOptions {
-  readonly brain: ToolLoopChat;
+interface PursuitFork {
+  /** The settled parent's run directory. */
+  readonly runDir: string;
+  /** The sha256 of the parent's `result.json` bytes: the sealed point the fork starts from. */
+  readonly settleDigest: Sha256Digest;
+  /** The one change, applied to the parent's root profile. Its `id` is recorded. */
+  readonly change: AgentProfileDiff;
+  /**
+   * Fork a parent whose journal holds a node without a terminal record, an unbegun owned tree, an
+   * unconfirmed teardown, or work in flight. Such a node may still act, and a fork never replays
+   * the parent's children, so it can only duplicate work outside the fork's tree. The root then
+   * records those node ids as `forkParentUncertainNodes`. Omit it to refuse such a parent.
+   */
+  readonly acceptUncertain?: boolean;
 }
 /**
- * Execute an {@link AgentGraph}. A flow graph (`entry` set) runs from its entries and routes edges
- * under a runtime-owned root that places no model call. Otherwise the root node becomes the
- * supervisor (`supervise()` — the execution core), each worker node is spawnable BY NODE ID
- * (`spawn_worker` with `profile: { name: '<node id>' }`; the node's canonical profile is pinned by
- * the graph), each
- * delegates directive is appended to the worker profile's `prompt.instructions` per traversal,
- * and each analyzes edge becomes an analyst-on-settle route with a real DESTINATION. Every
- * traversal is ledgered and journaled.
+ * The `execution.correlation` keys a fork records on its root. Runtime writes them; a caller that
+ * supplies one is refused. `lineageRootRunId` is the first run of the chain of parents, so the
+ * spend of every version of one lineage groups under one id.
  */
-declare function runGraph(graph: AgentGraph, opts: RunGraphOptions): Promise<GraphResult>;
-/** Alias for graph tests written before `RunGraphOptions.brain` was production. The production
- *  entry accepts the same shape; this wrapper only keeps the `/testing` import path working. */
-declare function runGraphWithTestBrain(graph: AgentGraph, opts: RunGraphTestOptions): Promise<GraphResult>;
+declare const RUN_FORK_CORRELATION_KEYS: readonly ["forkParentRunId", "forkParentSettleDigest", "forkProfileDiffId", "lineageRootRunId"];
 type ObserverRecordKind = 'event' | 'decision';
 /**
  * One immutable record in the observer plane. `sequence` is journal order, not
@@ -13169,6 +12962,9 @@ interface IsolatedCheckBox {
   };
   /** `customerId` from `Sandbox.getIdentity()` for every Sandbox key the judged run holds. */
   builderAccounts: readonly [string, ...string[]];
+  /** The check is the run's own step in its owner's account (a graph check node), not a judge:
+   *  `builderAccounts` is not consulted, and the box keeps a durable home. */
+  ownerStep?: true;
   /** Sandbox environment or image that holds the check's toolchain. */
   environment: string;
   /** Set `memoryMB` to require the API to report a finite granted limit before upload. */
@@ -15391,11 +15187,14 @@ interface PrivateCasArtifactPort extends AgentCandidateOutputArtifactPort {
 declare function createPrivateCasArtifactPort(root: string, namespace: string, options?: PrivateCasOptions): PrivateCasArtifactPort;
 /** Profile-exact adapter for packages that consume agent-eval's ChatClient contract.
  * Every call still enters Runtime through createExecutor -> streamAgentTurn, and every
- * behavioral field is checked against the exact AgentProfile before any transport runs. */
+ * behavioral field is checked against the exact AgentProfile before any transport runs.
+ * Optional `headers` are forwarded on every Router request. Runtime's own content-type,
+ * authorization, idempotency-key, and x-correlation-id keep precedence. */
 declare function profileChatClient(args: {
   profile: AgentProfile;
   executor: ExecutorConfig;
   context: string;
+  headers?: Readonly<Record<string, string>>;
 }): ChatClient;
 /** Profile-exact adapter for agent-eval's external optimizer callback.
  * Eval validates and freezes the provider-neutral request; Runtime owns the exact
@@ -15405,6 +15204,7 @@ declare function profileOptimizerModelCall(args: {
   executor: ExecutorConfig;
   context: string;
   pricing?: CustomTokenPricing;
+  headers?: Readonly<Record<string, string>>;
 }): ExternalOptimizerModelCall;
 interface ResolveSandboxClientOptions {
   /** The execution transport for the driven loop. */
@@ -15472,48 +15272,11 @@ interface ClaimRetainedInteractiveControlOptions {
  * @stable
  */
 declare function claimRetainedInteractiveControl(options: ClaimRetainedInteractiveControlOptions): Promise<AgentInteractiveSessionControlClaim>;
-/**
- * Dispatch one detached, replayable run and return only after exact durable
- * coordinates are confirmed by the provider and persisted by the caller.
- *
- * The required `onAdmission` hook first records a digest-only intent before
- * creation or receipt-authorized attachment, then records recovery coordinates and the verified exact control
- * reference. The returned promise resolves only after the dispatched admission
- * is durable, so a crash cannot lose a successful start's exact reference.
- *
- * @stable
- */
+/** Dispatch one replayable run. Intent is durable before create; the promise resolves after dispatch is durable. @stable */
 declare function startRetainedRun(options: StartRetainedRunOptions): Promise<RetainedRunHandle>;
-/**
- * Dispatch a fresh retained session inside an existing provider environment.
- *
- * This operation reuses only the environment. It does not append to a prior
- * harness chat and does not claim native conversation continuity. The caller
- * must use `RetainedRunHandle.continueNative` for a verified same-chat turn.
- *
- * @stable
- */
+/** Fresh session in an existing environment. A same-chat turn uses `continueNative`. @stable */
 declare function startRetainedRunInEnvironment(options: StartRetainedRunInEnvironmentOptions): Promise<RetainedRunHandle>;
-/**
- * Rebuild the exact run named by a persisted pre-create intent or pre-dispatch
- * admission coordinates, or report why the provider cannot prove it.
- *
- * An intent recovery replays the exact original start material through
- * `startRetainedRun`; a changed replay is rejected before provider creation.
- *
- * `not_found`: the provider no longer holds the environment, so nothing
- * remains to destroy. `recovered`: the provider self-identified the session
- * with a strict exact reference matching the recorded coordinates.
- * `unverifiable`: the environment exists but the provider cannot
- * self-identify the session — no session accessor, an accessor that throws,
- * a lazy accessor with no stored reference, or a loose reference. That
- * outcome is never destroy-safe: keep the environment, retry
- * `reconnectRetainedRun` with a dispatched admission record, or inspect the
- * environment with provider-native tools. A session that self-identifies
- * with different coordinates throws: something live is not the recorded run.
- *
- * @stable
- */
+/** Replay a persisted intent, or reattach coordinates the provider can prove. `unverifiable` keeps the environment; different coordinates throw. @stable */
 declare function recoverRetainedRun(options: RecoverRetainedRunIntentOptions): Promise<RecoverRetainedRunResult>;
 declare function recoverRetainedRun(options: RecoverRetainedRunOptions): Promise<RecoverRetainedRunResult>;
 /** Rebuild a retained-run client without retaining any object from the starter. @stable */
@@ -16011,6 +15774,12 @@ interface StreamAgentTurnOptions {
   callId?: string;
   /** Caller trace tag retained in evidence and forwarded when the transport supports it. */
   correlationId?: string;
+  /**
+   * Request headers inherited by the executor. Network transports forward these after assembling
+   * the request, and Runtime's own content-type, authorization, idempotency-key, and
+   * x-correlation-id replace any caller value of the same name.
+   */
+  propagatedHeaders?: Readonly<Record<string, string>>;
   /**
    * Opt-in tool-part projection for box and executor backends: sandbox tool
    * parts additionally surface in-stream as
@@ -16535,11 +16304,15 @@ interface StoredGraphContent {
   readonly nodes: ReadonlyArray<{
     readonly id: string;
     readonly profile: AgentProfile;
+    /** A check node; its profile is `{ name: id }`. */
+    readonly check?: GraphCheckNode;
   }>;
   readonly deliverable: Pick<AgentGraph['deliverable'], 'describe' | 'checkRef' | 'command' | 'when'>;
   /** A flow graph's entry and gates; absent for any other graph. */
   readonly entry?: AgentGraph['entry'];
   readonly gates?: AgentGraph['gates'];
+  readonly workspace?: AgentGraph['workspace'];
+  readonly continuation?: AgentGraph['continuation'];
 }
 /** A graph as stored. Observed imports retain unknown directives and budgets;
  * they describe what happened and cannot be replayed as executable graphs. */
@@ -16761,6 +16534,17 @@ interface LoadedGraphFile {
 }
 /** Compile canonical YAML/JSON to content-addressed graph data. Host resolvers may perform I/O. */
 declare function loadGraphFile(file: string, options?: LoadGraphFileOptions): Promise<LoadedGraphFile>;
+/**
+ * The directory a graph run's nodes work in. `workspace: cwd` (the default) is `cwd`. `workspace:
+ * fresh` is a new empty directory the run owns, `<root>/<runId>` (default root
+ * `~/.tangle/workspaces`); a resumed run with the same id reuses it. The host passes the result as
+ * the backend's working directory, where agent and check nodes both run.
+ */
+declare function graphWorkspace(graph: Pick<AgentGraph, 'workspace'>, options: {
+  readonly cwd: string;
+  readonly runId: string;
+  readonly root?: string;
+}): Promise<string>;
 /** The same data grammar as routes; no executable expressions or additional operators. */
 declare const graphRouteWhenSchema: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
   equals: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
@@ -16811,7 +16595,24 @@ declare const graphFileSchema: z.ZodObject<{
     profile: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     seat: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
     needs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    check: z.ZodOptional<z.ZodObject<{
+      command: z.ZodString;
+      timeoutMs: z.ZodOptional<z.ZodNumber>;
+      environment: z.ZodOptional<z.ZodString>;
+      egress: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      secrets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      resources: z.ZodOptional<z.ZodObject<{
+        cpuCores: z.ZodOptional<z.ZodNumber>;
+        memoryMB: z.ZodOptional<z.ZodNumber>;
+        diskGB: z.ZodOptional<z.ZodNumber>;
+      }, z.core.$strict>>;
+    }, z.core.$strict>>;
   }, z.core.$strict>>;
+  workspace: z.ZodOptional<z.ZodEnum<{
+    fresh: "fresh";
+    cwd: "cwd";
+  }>>;
+  continuation: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodTransform<PortableContinuationPolicy, unknown>>>;
   entry: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
     node: z.ZodString;
     task: z.ZodUnknown;
@@ -17234,6 +17035,9 @@ interface RemoteSupervisorControl extends RemoteSupervisorReader {
 declare function connectRemoteSupervisor(spec: HttpMcpServerSpec): Promise<RemoteSupervisorReader>;
 /** Connect with the dedicated /control capability, keeping credentials on the protected transport. */
 declare function connectRemoteSupervisorControl(access: CoordinationControlAccess): Promise<RemoteSupervisorControl>;
+/** An `escalateQuestion` that writes each `ask_parent` question to `questions/<id>.json` for an
+ *  out-of-process observer, who answers through `writeWorkerSteer` on the root (#1165). */
+declare function fileEscalateQuestion(rootDir: string, runId: string): EscalateQuestion;
 /** One atomically admitted down-leg request for an exact worker id. @stable */
 interface WorkerSteerRequest {
   readonly schemaVersion: 1;
@@ -18304,6 +18108,8 @@ interface SettledWorker {
    *  children's results, each readable in full through `observe_agent({ outRef })`. */
   readonly subtree?: SubtreeSummary;
 }
+/** The machine a worker asks for: the canonical create-time resource request. */
+type ResourceRequest = NonNullable<CreateAgentEnvironmentInput['resources']>;
 /** Immutable task, allocation, identity attribution, and semantic key supplied while a manager's
  * complete worker profile is prepared for one spawn. */
 interface WorkerSpawnContext {
@@ -18317,6 +18123,8 @@ interface WorkerSpawnContext {
   readonly budget: Budget;
   /** Detached, deeply immutable task bytes from this spawn request. */
   readonly task: unknown;
+  /** The machine `spawn_worker` requested, admitted under the backend's `maxWorkerResources`. */
+  readonly resources?: ResourceRequest;
   /** Exact trace label selected for this spawn. */
   readonly label: string;
   /** Semantic restart key, when the manager supplied one. */
@@ -18338,8 +18146,8 @@ interface WorkerSpawnContext {
   readonly continuity?: ContinuityMode;
   /** Present iff `continuity === 'resume'`: the lineage the executor seam re-attaches with. */
   readonly resume?: WorkerResumeContext;
-  /** The settled worker this spawn replaces, when the manager named one (`spawn_worker`'s
-   *  `successorOf`). Runtime admits only a settled worker of the same manager and journals the
+  /** The worker this spawn revises or replaces, when the manager named one (`spawn_worker`'s
+   *  `successorOf`). Runtime admits only a worker of the same manager, live or settled, and journals the
    *  relation on the new node, so the run record shows who took over whose work. A seam may read
    *  it to hand the successor its predecessor's workspace or retained output; Runtime mounts
    *  nothing on its behalf. Independent of `resume`, which re-attaches the same node's session. */
@@ -18534,11 +18342,12 @@ interface CoordinationToolsOptions {
   readonly preflightSpawn?: SpawnPreflight;
   /**
    * OPT-IN pre-journal PROFILE resolution: maps the profile a driver authored to the profile that
-   * will actually run, before `preflightSpawn` asks the backend about it. A layer that pins
-   * profiles by name (an agent graph) installs this so the gate judges the canonical profile —
-   * its real model, tools and harness — never the `{ name }` stub the driver wrote. Synchronous,
-   * throw-on-refusal, identity-free: it sees only the profile, never the assignment or budget,
-   * because both are minted AFTER the pre-journal point. Omit = the authored profile is used.
+   * will actually run — both the spawn and `preflightSpawn`'s gate see the resolved profile. A
+   * layer that pins profiles by name (an agent graph) installs this so the canonical profile —
+   * its real model, tools and harness — runs, never the `{ name }` stub the driver wrote (#1281).
+   * Synchronous, throw-on-refusal, identity-free: it sees only the profile, never the assignment
+   * or budget, because both are minted AFTER the pre-journal point. Omit = the authored profile
+   * is used.
    */
   readonly resolveSpawnProfile?: (profile: AgentProfile) => AgentProfile;
   /**
@@ -18646,6 +18455,7 @@ interface SpawnPreflightContext {
   readonly label: string;
   readonly key?: string;
   readonly task: unknown;
+  readonly resources?: ResourceRequest;
 }
 /** The gate `CoordinationToolsOptions.preflightSpawn` installs. */
 type SpawnPreflight = (profile: AgentProfile, context: SpawnPreflightContext) => Promise<SpawnRefusal | undefined>;
@@ -18802,6 +18612,9 @@ interface DriverAttemptRecord {
   readonly durationMs: number;
   /** Absent when the attempt completed. */
   readonly error?: string;
+  /** With `error`: the deepest cause's stack, redacted and bounded, so a failure the message
+   *  alone cannot place still names its throw site (#2347). */
+  readonly errorStack?: string;
   /** Validated producer attribution, including its reset hint when supplied. */
   readonly failure?: AgentTurnFailure;
   readonly classification?: DriverFailureClass;
@@ -18863,26 +18676,9 @@ interface DriverAttemptRecord {
  *  already closed: the manager's own `stop` or a progress stop rule. A barren streak is never a
  *  refusal: it pauses the next continuation (`barrenPauseMs`). */
 type DriverRepromptRefusal = 'closed' | Extract<DriverAttemptStop, 'aborted' | 'budget-exhausted' | 'deadline' | 'max-attempts'>;
-/**
- * How one driver failure is answered.
- *
- *  - `terminal`: Runtime's own refusal, or a request that fails identically forever. The run ends.
- *  - `transient`: a foreign accident. A streak in which nothing ran is retried as an outage for
- *    `transientOutageMs`; after that, and for a failure that did work, `maxAttempts` and the
- *    barren streak bound it.
- *  - `unavailable`: the upstream cannot serve now (quota, rate limit, overload, or the router's
- *    own provider credential refused). The driver pauses and re-enters, and only the deadline, the
- *    budget, and cancellation bound the pauses.
- */
+/** `terminal` ends the run. `transient` is an outage until `transientOutageMs`, then the attempt bounds. `unavailable` pauses until the deadline, budget, or cancel. */
 type DriverFailureClass = 'transient' | 'terminal' | 'unavailable';
-/**
- * What one driver loop did, counted from its attempt records: the numbers a run's settle record
- * carries so a reader can tell genuine continuations from failure retries without the journal.
- *
- * Measured motive: the most genuine continuations in any recorded lab run was 11
- * (evidence-compiler-j, which won), while the two larger counts, 32 and 12, were re-entries after
- * failed turns. One `attempts` number hid which was which.
- */
+/** Attempt counts split continuations from failure retries. One `attempts` number hid which was which. */
 interface DriverLoopRecord {
   /** Driver invocations started (the attempt numbers the loop reached). */
   readonly attempts: number;
@@ -18933,46 +18729,16 @@ interface DriverContinuationRecord extends DriverLoopRecord {
   readonly continuations: ReadonlyArray<ContinuationEntry>;
 }
 /**
- * Why a retained execution has no accepted terminal result, classified where the cause is still
- * a typed value rather than a string in a journal.
- *
- * One reason string used to cover two situations that call for opposite operator responses
- * (#1204): an execution whose status genuinely cannot be determined — refusing to replace it is
- * correct, and the operator must reconcile before retrying or pay twice for one turn — and a
- * provider that broke its contract, where the reader or provider needs repair before the original
- * execution can be reconciled. Six exhibits in three days wore the first name for the second fault.
- *
- * - `'unobservable'`: the execution may have run and nothing local can say. The safety refusal.
- *   Anything unclassifiable lands here, and so does a 4xx, a not-found, or a client deadline hit
- *   AFTER admission: the provider cannot resolve what it admitted, which is exactly the case the
- *   refusal exists for, not a rejected request.
- * - `'provider-contract'`: the provider answered with something its own contract forbids — a
- *   `RetainedRunProviderContractError` naming a broken answer (an `*_INVALID`, `*_CHANGED`,
- *   `*_DUPLICATE`, `*_MISSING` code), an event bound to another run.
- * - `'request-rejected'`: the request itself was refused BEFORE it ran — a schema violation
- *   (`ZodError`), an HTTP 4xx at admission, a capacity refusal at admission that carries an
- *   upstream capacity `code` and no HTTP status (the account owner's credential command refused a
- *   fresh dispatch before the dispatch request existed), an unsupported credential route, or a
- *   dispatch that Sandbox did not admit
- *   because another execution owns the session or turn. Never named after admission.
- * - `'transport'`: the provider or a gateway in front of it failed — an HTTP 5xx, a socket
- *   error, a platform service answering with a server error. Status is in doubt only because
- *   the transport was.
- * - `'nested-recovery'`: a nested manager's own recovery could not be reconstructed. Stated by
- *   the thrower, never inferred.
- *
- * Classification reads the cause's structure — class name, `code`, HTTP `status`, a Zod issue
- * list — and two untyped Sandbox refusals' text, never other message text: the provider is not a
- * dependency of this package and its messages are not a contract. #1204's exhibit 3 (an event
- * without a stable id) is delivered rather than thrown since agent-provider-tangle 1.4.0; its
- * exhibit 6 is typed as `JsonBoundError` (`code: 'JSON_BOUND_VIOLATION'`) since 1.5.0 and lands
- * with the schema violations. A provider still throwing plain `Error`s lands on `'unobservable'`,
- * which is the safe side.
- *
- * One `RetainedRunProviderContractError` is NOT one meaning. The runtime mints it both when the
- * provider answered wrongly and when a READ of the provider failed (`RETAINED_RESULT_READ_FAILED`,
- * `RETAINED_CONTROL_REF_READ_FAILED`). The second kind is a wrapper: what it wraps decides, in a
- * post-admission context, and a wrapper around nothing classifiable is exhibit 4.
+ * Why a retained execution has no accepted terminal result. `unobservable` means it may have run
+ * and nothing local can say, including a 4xx, not-found, or client deadline after admission, and
+ * any plain `Error`. `provider-contract` is an answer the provider's contract forbids, or an event
+ * bound to another run. `request-rejected` is a refusal before the request ran: schema, admission
+ * 4xx, admission capacity code, unsupported credential route, or a session owned by another
+ * execution. `transport` is HTTP 5xx, a socket error, or a platform server error. `nested-recovery`
+ * is stated by the thrower. Classification reads class, `code`, HTTP `status`, and a Zod issue
+ * list, plus two untyped Sandbox refusal strings, never other message text. A
+ * `RetainedRunProviderContractError` for `RETAINED_RESULT_READ_FAILED` or
+ * `RETAINED_CONTROL_REF_READ_FAILED` is classified by what it wraps.
  */
 type RetainedPendingCause = 'unobservable' | 'provider-contract' | 'request-rejected' | 'transport' | 'nested-recovery';
 /**
@@ -19624,5 +19390,5 @@ interface KnowledgeReadinessDecision {
   blockingGapIds: string[];
   nonBlockingGapIds: string[];
 }
-export { AgentEnvironmentStatus as $, startRuntimeRun as $S, McpToolAnnotations as $_, startRetainedRunInEnvironment as $a, NodeExecutionIdentity as $b, ShapeContext as $c, FinalizeContext as $d, CliWorktreeBridgeSeam as $f, DecideGate as $g, HarnessUsage as $h, StructuralRolloutResult as $i, PursuitNodePlatform as $l, DelegationResultPayload as $m, safeWorkerFile as $n, SuperviseOptionsForDispatch as $o, SandboxUsageLedger as $p, graphDigest as $r, HarvestFailure as $s, settledWorkerOut as $t, createInMemoryRunContext as $u, readRunCancelRequest as $v, HarnessFileBinding as $x, SpendGap as $y, DriverContinuationRecord as A, RetainedRunIntentAdmission as AC, LoopResult as AS, MapItemFailurePolicy as A_, Deliverable as Aa, BudgetPoolRestore as Ab, ScopeAnalyzeInput as Ac, SupervisorAgentDeps as Ad, ResolveSpawnResourcePathsResult as Af, bestSoFar as Ag, ExecutorResultMapping as Ah, ChatWorkerSeamOptions as Ai, IsolatedCheckOutputFailure as Al, runDetachedTurn as Am, SearchSpecOwnedOption as An, RegistryAnalyzeProjection as Ao, ProviderExecutorOptions as Ap, workerFromInteractiveProvider as Ar, StrategyShotResult as As, boxSurfaceReader as At, PursuitFork as Au, openSqlRunStore as Av, readWorkerProgress as Ax, RuntimeStreamEventSink as Ay, PeerAuditAccess as B, OutputAdapter as BS, PeerMailOutcome as B_, createSandboxLineage as Ba, createBudgetPool as Bb, WidenLineage as Bc, PlateauOptions as Bd, EventSubscription as Bf, WorktreeCheckRunner as Bg, sentinelCompletion as Bh, profileRichnessFinding as Bi, VersionJudge as Bl, SubmitOutput as Bm, TraceRootArtifact as Bn, BenchmarkCell as Bo, ResolvedMcpServerLaunch as Bp, LoadGraphFileOptions as Br, Strategy as Bs, WorktreePatchArtifact as Bt, SuperviseRegistry as Bu, FileResultBlobStore as Bv, HarnessTranscriptBinding as Bx, createWorkerSlots as By, RuntimeFailureCause as C, RetainedRunCancelOptions as CC, LoopEndedPayload as CS, ContinuationInstruction as C_, EvolutionStrategy as Ca, Scope as Cb, Panel as Cc, CoordinationToolFace as Cd, ContinuationProfile as Cf, renderLeaderboardSvg as Cg, FileDelegationStoreOptions as Ch, DelegateOptions as Ci, IsolatedCheckBox as Cl, FleetHandle as Cm, FencedSqlRunContext as Cn, loopUntil as Co, ROUTER_CLIENT_HEADER as Cp, profileRegistry as Cr, AgenticSurface as Cs, BoxSurfaceReaderOptions as Ct, TraversalContinuity as Cu, RunLocalHarnessOptions as Cv, ActivityNote as Cx, OtelExporter as Cy, RetainedPendingCause as D, RetainedRunEnvironmentAdmission as DC, LoopLineageOptions as DS, DownMessageDeliveryOutcome as D_, TournamentRow as Da, WorkerEventEntry as Db, PipelineStage as Dc, ObserveSupervisorNodeEvent as Dd, DriverContractState as Df, AnytimeTaskCurve as Dg, CheckVerdict as Dh, ChatSessionStore as Di, runIsolatedCheck as Dl, createSiblingSandboxExecutor as Dm, SEARCH_SPEC_CORRELATION_KEY as Dn, verify as Do, AgentEnvironmentProviderRegistry as Dp, InteractiveWorkerKeyInput as Dr, CorpusReadbackOptions as Ds, SurfaceReadOutcome as Dt, GraphFromStoredOptions as Du, CodexTokenUsage as Dv, TeamProgress as Dx, loopEventToOtelSpan as Dy, EvidencePendingEvent as E, RetainedRunEffect as EC, LoopIterationStartedPayload as ES, DownMessageDeliveryAttempt as E_, TournamentCell as Ea, WorkerEventCursor as Eb, PanelVerdict as Ec, DriveHarnessOwnerContext as Ed, admitContinuationPolicy as Ef, AnytimeStrategySummary as Eg, CheckUnavailableError as Eh, ChatCompletionsTransport as Ei, IsolatedCheckResult as El, createFleetWorkspaceExecutor as Em, CompiledSearchSpec as En, selectValidWinner as Eo, AgentEnvironmentProviderRef as Ep, InteractiveWorkerEnvironment as Er, ArtifactHandle as Es, SurfaceReadBox as Et, GraphCommandCheck as Eu, LocalHarness as Ev, ScopeProgressInput as Ex, createOtelExporter as Ey, CoordinationTools as F, StartRetainedRunInEnvironmentOptions as FC, LoopTraceEmitter as FS, DEFAULT_PEER_MAIL_LIMITS as F_, SandboxRunAbortError as Fa, ReservationRejection as Fb, TrajectoryReportOptions as Fc, SupervisorToolInvocationContext as Fd, environmentReader as Ff, WaterfallSpan as Fg, CompletionEvidence as Fh, ProfileRichness as Fi, NextPursuitVersionInput as Fl, DelegationResumeTick as Fm, settledToIteration as Fn, observationFromRegistry as Fo, ProviderPlacement as Fp, graphFromSessionFacts as Fr, runAgentic as Fs, failuresAnalyst as Ft, workerFromBackend as Fu, SpawnForestInDoubtNode as Fv, RetainedInteractiveRunHandle as Fx, createRuntimeEventCollector as Fy, SpawnRefusalCause as G, Validator as GS, PeerMailboxOptions as G_, S3PrivateCasStoreOptions as Ga, SpawnModelSubstitution as Gb, LoopShape as Gc, anyOf as Gd, DelegateHandlerOptions as Gf, AwaitWakeInput as Gg, CodexRolloutStoreReader as Gh, CheckRunContext as Gi, SupervisePursuitOptions as Gl, DelegateUiAuditArgs as Gm, WorkerSteerAcknowledgement as Gn, BenchmarkTaskRow as Go, secretEnvOfMcpServer as Gp, GraphRegistryDir as Gr, assertStrategyContract as Gs, attachWorker as Gt, SeatStage as Gu, SpawnJournalReadResult as Gv, HarnessTranscriptUnavailableReason as Gx, readRunParking as Gy, SpawnPreflight as H, SandboxClient as HS, PeerMailRefusal as H_, AcquireOptions as Ha, ExecutorContext as Hb, WinnerStrategy as Hc, StopDecision as Hd, McpEventRecord as Hf, WorktreeHarnessResult as Hg, CodexForkBoundary as Hh, RunCancellationReason as Hi, assertPursuitVersions as Hl, DelegateCodeConfig as Hm, RunTraceSources as Hn, BenchmarkLift as Ho, mcpSecretEnvMetadataKey as Hp, loadGraphFile as Hr, StrategyCtx as Hs, AttachWorkerOptions as Ht, SeatSegment as Hu, SpawnJournalCursor as Hv, HarnessTranscriptEvidence as Hx, RunParkedError as Hy, CoordinationToolsOptions as I, StartRetainedRunOptions as IC, LoopTraceEvent as IS, PEER_MAIL_WIRE_KEY as I_, TurnResult as Ia, ReservationShortfall as Ib, Verify as Ic, ManagerWakePolicy as Id, resolveSpawnResourcePaths as If, createWaterfallCollector as Ig, CompletionPolicy as Ih, ProfileRichnessThresholds as Ii, PursuitVersionChain as Il, DelegationRunContext as Im, createScope as In, McpEndpoint as Io, BridgeHarnessStore as Ip, graphFileSchema as Ir, sample as Is, AuthoredHarness as It, AuthorizedSpawn as Iu, SpawnForestMissingTree as Iv, RetainedInteractiveStartMaterial as Ix, createRuntimeStreamEventCollector as Iy, AgentEnvironment$1 as J, RuntimeRunHandle as JS, isPeerMailEnvelope as J_, PrivateCasNamespaceObject as Ja, ExecutorExecutionBinding as Jb, PersonaContext as Jc, ReentryContinuity as Jd, createExecutorRegistry as Jf, LeadMessage as Jg, CodexStoreDelta as Jh, CheckSourceCtx as Ji, supervisePursuit as Jl, DelegationError as Jm, cancelWorker as Jn, runBenchmark as Jo, SandboxToolPartState as Jp, GraphSelection as Jr, sampleThenRefine as Js, NOTE_MAX_CHARS as Jt, InMemoryRunContext as Ju, RunState as Jv, captureHarnessTranscript as Jx, BudgetViolation as Jy, SuperviseProfileEntry as K, RuntimeRunCompleteInput as KS, claimsAuthority as K_, createS3PrivateCasStore as Ka, AgentExecutionRef as Kb, Outcome as Kc, noProgressFor as Kd, DelegateResult as Kf, CoordinationEvent as Kg, CodexRolloutStoreRef as Kh, CheckRunner as Ki, SupervisedPursuitResult as Kl, DelegateUiAuditConfig as Km, WorkerSteerRequest as Kn, Environment as Ko, SandboxLeafOut as Kp, GraphRunQuery as Kr, authorStrategy as Ks, readWorkerInteractiveBinding as Kt, SelectSeat as Ku, readSpawnJournal as Kv, ReadableEnvironment as Kx, Budget as Ky, GraphSubtaskPreparation as L, LoopWinner as LS, PeerMailEnvelope as L_, openSandboxRun as La, ReservationStage as Lb, VerifySpec as Lc, SupervisorProfile as Ld, McpServer as Lf, RunAgentRoundsOptions as Lg, CompletionVerdict as Lh, asAuthoredProfile as Li, PursuitVersionStop as Ll, DelegationTaskQueue as Lm, ScopeArgs as Ln, McpEnvironmentOptions as Lo, BridgeModelCredential as Lp, graphRouteWhenSchema as Lr, AuthorStrategyOptions as Ls, WorktreeFanoutOptions as Lt, AuthorizedSpawnContext as Lu, SpawnForestNode as Lv, StartRetainedInteractiveRunOptions as Lx, sanitizeKnowledgeReadinessReport as Ly, DriverRepromptRefusal as M, RetainedRunSnapshot as MC, LoopStartedPayload as MS, MapSpawnMarker as M_, OpenSandboxRunOptions as Ma, LeakedReservation as Mb, SteerContext as Mc, SupervisorNodeContext as Md, SpawnResourceBytes as Mf, renderAnytimeTable as Mg, mapExecutorResult as Mh, chatWorkerSeam as Mi, validateIsolatedCheckOutputs as Ml, DelegationRecord as Mm, compileSearchSpec as Mn, buildSteerContext as Mo, ProviderPromptOptions as Mp, createInPlaceCliExecutor as Mr, breadthStrategy as Ms, harvestSurfaceDiffs as Mt, supervise as Mu, materializeTreeView as Mv, RecoverRetainedInteractiveRunOptions as Mx, RuntimeTelemetryOptions as My, BlockedToolReport as N, RetainedRunStartMaterial as NC, LoopTeardownFailedPayload as NS, MapTraversalEvent as N_, OpenSandboxRunPromptOptions as Na, ReservationFloor as Nb, TrajectoryNode as Nc, SupervisorNodeContextSeed as Nd, SpawnResourceRead as Nf, WaterfallCollector as Ng, verdictFromJudgeScore as Nh, createChatSessionStore as Ni, JudgedPursuitVersion as Nl, DelegationResumeContext as Nm, searchPresets as Nn, createScopeAnalyst as No, providerAsExecutor as Np, GraphSessionObservationOptions as Nr, depthStrategy as Ns, AnalystAuthoring as Nt, superviseFleetCapabilities as Nu, SpawnForest as Nv, RetainedInteractiveAdmissionHook as Nx, SanitizedKnowledgeReadinessReport as Ny, DriverAttemptRecord as O, RetainedRunEventOptions as OC, LoopPlanDescription as OS, DownMessageEvent as O_, runStrategyEvolution as Oa, WorkerEventPage as Ob, RenderCorpusToInstructionsOptions as Oc, ResolveDriveHarness as Od, DriverReentry as Of, anytimeReport as Og, CompletionCheckContext as Oh, ChatTransportExecutorOptions as Oi, IsolatedCheckOutputDeclaration as Ol, DetachedTurn as Om, SearchSpec as On, widen as Oo, createAgentEnvironmentProviderRegistry as Op, InteractiveWorkerOptions as Or, RunAgenticOptions as Os, SurfaceReader as Ot, defaultEdgeTraversalCap as Ou, CodexExecutionPolicy as Ov, WorkerProgress as Ox, RuntimeEventCollector as Oy, CoordinationStats as P, RetainedRunTurnInput as PC, LoopTokenUsage as PS, AUTHORITY_MARKERS as P_, SandboxRun as Pa, ReservationHolder as Pb, TrajectoryReport as Pc, SupervisorToolDescriptor as Pd, SpawnResourceReader as Pf, WaterfallReport as Pg, CompletionAnalyst as Ph, AuthoredProfile as Pi, NextPursuitVersion as Pl, DelegationResumeDriver as Pm, searchSpecDigest as Pn, registryScopeAnalyst as Po, UnavailablePausePolicy as Pp, ObservedSessionFacts as Pr, refine as Ps, analystsFromRegistry as Pt, superviseWithTestBrain as Pu, SpawnForestEvent as Pv, RetainedInteractiveEnvironmentInput as Px, SanitizedKnowledgeRequirement as Py, AgentEnvironmentQuery as Q, RuntimeRunStatus as QS, JsonRpcResponse as Q_, startRetainedRun as Qa, MaterializedModelIdentity as Qb, ShapeBudget as Qc, DeliveredOutput as Qd, CliSeam as Qf, WorkerWatchOptions as Qg, readCodexRolloutSession as Qh, StructuralRolloutPolicy as Qi, PursuitNodeCost as Ql, DelegationProgress as Qm, readWorkerSteerRequests as Qn, SuperviseDispatchOptions as Qo, SandboxServedBackend as Qp, graphCorpusSummary as Qr, HarvestError as Qs, composeWorkerEvidence as Qt, createFileRunContext as Qu, cancelRun as Qv, HARNESS_TRANSCRIPT_READ_LIMITS as Qx, SpendChannel as Qy, GraphSubtasks as R, MountManifestEntry as RS, PeerMailEvent as R_, SandboxLineage as Ra, ReservationTicket as Rb, Widen as Rc, AllWorkersStalledOptions as Rd, McpServerOptions as Rf, runAgentRounds as Rg, completionAuthorizes as Rh, assessAuthoredProfile as Ri, PursuitVersions as Rl, DelegationTaskQueueOptions as Rm, TRACE_ROOT_SCHEMA as Rn, createMcpEnvironment as Ro, BridgeSeam as Rp, GraphFileResolutionError as Rr, AuthoredStrategy as Rs, worktreeFanout as Rt, SuperviseOptions as Ru, SpawnForestTree as Rv, HARNESS_TRANSCRIPT_SETTLE_TIMEOUT_MS as Rx, DeadlineCheckIn as Ry, RuntimeStreamEvent as S, RetainedRunAdmissionHook as SC, LoopDecisionPayload as SS, AuthorizedDownMessage as S_, EvolutionReport as Sa, ResumedWork as Sb, LoopUntilState as Sc, supervisorAgentWithTestBrain as Sd, ContinuationPolicy as Sf, renderLeaderboardMarkdown as Sg, FileDelegationStore as Sh, graphDesignerExtraTools as Si, readDeclaredCheck as Sl, DelegationExecutor as Sm, validateStoredGraph as Sn, flatWidenGate as So, sharedBoxPlacement as Sp, pickBestProfile as Sr, AgenticRunResult as Ss, createVerifierEnvironment as St, RunGraphTestOptions as Su, LocalHarnessResult as Sv, ActivityLog as Sx, OtelExportStats as Sy, RuntimeFailureOwner as T, RetainedRunDispatchedAdmission as TC, LoopIterationEndedPayload as TS, DownMessageAuthorizationInput as T_, StrategyTournament as Ta, WidenGate as Tb, PanelSpec as Tc, DriveHarness as Td, VerdictSummary as Tf, AnytimeReport as Tg, CoderTask as Th, delegate as Ti, IsolatedCheckOptions as Tl, SiblingSandboxExecutorOptions as Tm, createFencedSqlRunContext as Tn, pipeline as To, sharedWorkerClientName as Tp, recordProfileRun as Tr, AgenticTool as Ts, SurfaceDiff as Tt, runGraphWithTestBrain as Tu, LOCAL_HARNESSES as Tv, ExecutorProgress as Tx, buildLoopOtelSpans as Ty, SpawnPreflightContext as U, SelectionReceipt as US, PeerMailSendInput as U_, acquireSandbox as Ua, ExecutorFactory as Ub, DefinePersona as Uc, StopRule as Ud, McpEventSource as Uf, WorktreeProfileMaterializationReceipt as Ug, CodexRolloutIdentity as Uh, CheckExecChannel as Ui, SuperviseGraphPursuitOptions as Ul, DelegateResearchArgs as Um, runToolSpans as Un, BenchmarkReport as Uo, resolveMcpServerLaunch as Up, GraphCorpusGroup as Ur, StrategyResult as Us, WorkerInteractiveBinding as Ut, SeatSelection as Uu, SpawnJournalReadOptions as Uv, HarnessTranscriptFile as Ux, RunParkingPolicy as Uy, SettledWorker as V, RunProvenance as VS, PeerMailReadout as V_, SandboxEvidenceReceipt as Va, AgentSpec as Vb, WidenSpec as Vc, ProgressView as Vd, EventSubscriptionStore as Vf, WorktreeCommandResult as Vg, stopSentinel as Vh, supervisorInstructions as Vi, VersionVerdict as Vl, DelegateCodeArgs as Vm, TraceSummary as Vn, BenchmarkConfig as Vo, envKeyProvider as Vp, LoadedGraphFile as Vr, StrategyArtifacts as Vs, createWorktreeCliExecutor as Vt, SuperviseRegistryTable as Vu, replaySpawnTree as Vv, HarnessTranscriptCapture as Vx, ParkedRun as Vy, SpawnRefusal as W, ValidationCtx as WS, PeerMailbox as W_, S3PrivateCasStore as Wa, ExecutorRegistry as Wb, DefinePersonaInput as Wc, allWorkersStalled as Wd, DelegateError as Wf, GitRunner as Wg, CodexRolloutSession as Wh, CheckOutcome as Wi, SupervisePursuitError as Wl, DelegateResearchConfig as Wm, WorkerCancellation as Wn, BenchmarkStrategySummary as Wo, resolveSecretEnv as Wp, GraphCorpusSummary as Wr, adaptiveRefine as Ws, WorkerInteractiveProviderSource as Wt, SeatSelectionInput as Wu, SpawnJournalReadRecord as Wv, HarnessTranscriptUnavailable as Wx, RunParkingRecord as Wy, AgentEnvironmentEvent$1 as X, RuntimeRunPersistenceAdapter as XS, peerMailVerbNames as X_, reconnectRetainedRun as Xa, ExecutorNodeContext as Xb, RunPersonified as Xc, UNPROVEN_CONTINUITY as Xd, createExecutor as Xf, ManagerWake as Xg, createCodexRolloutStoreReader as Xh, StructuralRolloutConfig as Xi, PursuitObserverDelivery as Xl, DelegationHistoryArgs as Xm, readWorkerCancellation as Xn, LoopDispatchOptions as Xo, mapSandboxEvent as Xp, StoredGraphInput as Xr, strategyAuthorSystemPrompt as Xs, WorkerEvidenceInput as Xt, RunContext as Xu, RunCancelRequest as Xv, persistHarnessTranscript as Xx, ResourceSpend as Xy, AgentEnvironmentCapabilities$1 as Y, RuntimeRunOptions as YS, peerMailTools as Y_, PrivateCasNamespaceRetirement as Ya, ExecutorMaterialization as Yb, PersonaExecutors as Yc, ReentryTaskInput as Yd, ExecutorConfig as Yf, ManagerReentryState as Yg, addHarnessUsage as Yh, RepairStop as Yi, RunReopen as Yl, DelegationFeedbackSnapshot as Ym, legacySupervisorRunDir as Yn, LoopCampaignDispatchOptions as Yo, createSandboxToolPartState as Yp, StoredGraph as Yr, strategyAuthorContract as Ys, VERIFY_TAIL_CHARS as Yt, InMemoryRunContextOptions as Yu, readRunState as Yv, harnessTranscriptArtifact as Yx, ResourceLimit as Yy, AgentEnvironmentProvider$1 as Z, RuntimeRunRow as ZS, JsonRpcMessage as Z_, recoverRetainedRun as Za, MaterializedExecutionIdentity as Zb, RunPersonifiedOptions as Zc, composeReentryTask as Zd, CliInPlaceSeam as Zf, ToolOutcomeEvent as Zg, harnessUsageIsEmpty as Zh, StructuralRolloutMessage as Zi, PursuitCostProvenance as Zl, DelegationHistoryEntry as Zm, readWorkerSteerAcknowledgement as Zn, LoopOptionsForDispatch as Zo, mapSandboxToolEvent as Zp, digestOfGraph as Zr, HarvestCorpusOptions as Zs, closingWorkerNote as Zt, RunContextLease as Zu, RunCancellation as Zv, BoundHarnessSession as Zx, Spend as Zy, RunAgentTaskOptions as _, RetainedInteractiveAdmission as _C, AgentRunSpec as _S, QuestionPolicy as __, CollectedAgentTurn as _a, RootStreamReceipt as _b, EqualKVerdict as _c, createSupervisorSpanRecorder as _d, ContinuationAppend as _f, ProfileKeyOf as _g, researcherProfile as _h, queueOf as _i, assertDeclaredCheck as _l, DelegateRunCtx as _m, parseWorkerToolTraceArtifact as _n, runPersonified as _o, SharedBoxCloseReceipt as _p, provisionSupervisor as _r, StdioMcpConnection as _s, SandboxInstance$1 as _t, GraphEdgeCapError as _u, AnalyzeOnSettleRoute as _v, WorkerTraceUnavailableReason as _x, TraceContext as _y, AgentKnowledgeProvider as a, BackendTransportError as aC, readBoundHarnessSessions as aS, RouteGate as a_, defaultStructuralRolloutPolicy as aa, Settled as ab, ObserveInput as ac, createPromptRegistry as ad, CoordinationMcpHandle as af, CodeModeToolset as ag, UiAuditLensFilter as ah, lookupGraph as ai, LeaderboardBenchTask as al, ToolSpec as am, GitWorkspaceOptions as an, ResolveSandboxClientOptions as ao, DEFAULT_SANDBOX_STEERING_MAX_TURNS as ap, RemoteSupervisorCancelResult as ar, TerminalDecision as as, AgentTurnResult$2 as at, PursuitRunTotals as au, EventBus as av, ExecutorAccounting as ax, SpawnJournal as ay, RuntimeSession as b, RetainedInteractiveStartedAdmission as bC, ExecCtx as bS, questionEscalationTargets as b_, streamAgentTurn as ba, ReenteredWorkers as bb, FanoutWinnerSelector as bc, readRootStreamReceipt as bd, ContinuationPanelInput as bf, pairwiseSignificance as bg, DelegationPersistenceError as bh, DesignerToolsEnv as bi, declaredCheckDigest as bl, UiAuditorDelegate as bm, createRootHandle as bn, renderCorpusToInstructions as bo, SharedBoxStats as bp, bestProfileFor as br, materializeLocalMcp as bs, makeFinding$1 as bt, GraphTopology as bu, DefinedAnalystRecord as bv, TraceSource as bx, OtelAttribute as by, AgentTaskContext as c, NotFoundError as cC, ProviderWorkspaceAttemptProvenance as cS, ChildQuestionInbox as c_, officialChecksFromMeta as ca, SpawnRejection as cb, observe as cc, dumbContinuationPassPrompt as cd, CoordinationTransportOptions as cf, runCodeMode as cg, UiFindingScreenshot as ch, recordStoredGraphRun as ci, LeaderboardIterationInfo as cl, ToolLoopCompaction as cm, WorkspaceCommit as cn, profileOptimizerModelCall as co, SteerableSandboxSession as cp, RemoteSupervisorSteerResult as cr, InProcessOnPrompt as cs, CheckpointRequest as ct, FileObserverJournal as cu, WatchTraceOptions as cv, ExecutorResult as cx, RecursiveReservationPolicy as cy, AgentTaskStatus as d, NativeContextContinuationHandle as dC, ProviderWorkspaceCaptureResult as dS, QuestionDecision as d_, selectBestIndex as da, TreeView as db, CombinatorShape as dc, naiveContinuationPrompt as dd, CoordinationRejectReason as df, Interval as dg, KnowledgeItem as dh, GraphTriggerBinding as di, LeaderboardScore as dl, ToolLoopToolCall as dm, jjWorkspace as dn, PrivateCasOffloadReport as do, Inbox as dp, connectRemoteSupervisor as dr, inProcessSandboxClient as ds, ExecRequest as dt, ObserverRecordKind as du, AnalystAssignmentRecord as dv, HeldForContinuation as dx, RootSegmentEntry as dy, contentAddress as eC, HarnessTranscriptMetadata as eS, GateDecision as e_, VisibleCheck as ea, Handle as eb, HarvestReport as ec, withRunContext as ed, FinalizerSettled as ef, decodeHarnessUsage as eg, DelegationStatus as eh, graphFromStored as ei, ShapeRegistry as el, extractLlmCallEvent as em, spendFromUsageEvents as en, ClaimRetainedInteractiveControlOptions as eo, CliWorktreeSeam as ep, supervisorRunDir as er, loopCampaignDispatch as es, AgentEnvironmentSummary as et, PursuitNodeProjection as eu, McpToolDescriptor as ev, ProfileMaterializationReceipt as ex, readRunCancellation as ey, BackendErrorDetail as f, NativeContextContinuationInput as fC, ProviderWorkspaceEntryMetadata as fS, QuestionEscalationOutcome as f_, structuralRollout as fa, FleetYield as fb, Corpus as fc, promptHandle as fd, CoordinationDeliveryEvidence as ff, Leaderboard as fg, KnowledgeUpdate as fh, DispatchReport as fi, LeaderboardSpec as fl, FeedbackEvent as fm, localShell as fn, PrivateCasOptions as fo, InboxLease as fp, connectRemoteSupervisorControl as fr, HttpMcpServerSpec as fs, ExecResult as ft, observerRecordDigest as fu, AnalystFindingEvent as fv, HeldRelease as fx, RootSignal as fy, OpenAIChatToolChoice as g, RecoverRetainedRunResult as gC, UsageEvent as gS, QuestionOption as g_, AgentTurnUsage as ga, RootProviderModelEvidence as gb, EqualKOnCostOptions as gc, SupervisorSpanRecorder as gd, CheckRead as gf, PairwiseVerdict as gg, ResearcherProfileOptions as gh, freeSlots as gi, DeclaredCheckStateCapture as gl, CoderReviewer as gm, WorkerToolTraceArtifact as gn, definePersona as go, DEFAULT_SHARED_BOX_WORKERS as gp, SupervisorCleanupReceipt as gr, McpSpawnFault as gs, SandboxEvent$1 as gt, GraphEdge as gu, AnalystRunContext as gv, WorkerTraceEvidence as gx, WorkerTraceResolver as gy, OpenAIChatTool as h, RecoverRetainedRunOptions as hC, TokenUsageProvenance as hS, QuestionLevel as h_, AgentTurnInput$1 as ha, ProviderModelExecutionEvidence as hb, EqualKArm as hc, SupervisorSpanOutcome as hd, PriorCoordination as hf, PairwiseOptions as hg, ResearchTask as hh, RollingDispatchOptions as hi, DeclaredCheckPlacement as hl, CoderReview as hm, analyzeTrace as hn, trajectoryReport as ho, DEFAULT_SHARED_BOX_RESOURCES as hp, ProvisionedSupervisor as hr, McpListedTool as hs, ResourceRequest as ht, EdgeTraversal as hu, AnalystRegistry$1 as hv, WorkerInteractiveUnavailableReason as hx, SupervisorOpts as hy, AgentExecutionBackend as i, AgentEvalErrorCode as iC, RetainedHarnessTranscriptDescriptor as iS, RouteFlowEvent as i_, defaultExtractCandidate as ia, RetainedExecutionState as ib, ObservationError as ic, analyzesFindingsReportPrompt as id, CoordinationControlAccess as if, CodeModeToolsOptions as ig, ResearchOutputShape as ih, loadGraph as ii, LeaderboardBenchScore as il, RouterRouting as im, withUntrackedArtifacts as in, startRetainedInteractiveRun as io, SandboxSeam as ip, RemoteSupervisorAgent as ir, TERMINAL_DECISIONS as is, AgentSessionStatus$1 as it, PursuitRunProjection as iu, BusStats as iv, Executor as ix, SpawnEvent as iy, DriverFailureClass as j, RetainedRunReplayPoint as jC, LoopSandboxPlacement as jS, MapOnSettleRoute as j_, OpenSandboxRunBeforeStartContext as ja, BudgetReadout as jb, ScopeWidenGate as jc, SupervisorAgentTestDeps as jd, ResolvedSpawnResourcePath as jf, plateauLength as jg, gateOnDeliverable as jh, chatTransportExecutor as ji, IsolatedCheckOutputOptions as jl, DelegationArgs as jm, assertSearchSpec as jn, assertTraceDerivedFindings as jo, ProviderLeafOut as jp, InPlaceCliExecutorOptions as jr, SurfaceScore as js, fsSurfaceReader as jt, RUN_FORK_CORRELATION_KEYS as ju, SqlAdapter as jv, ReconnectRetainedInteractiveRunOptions as jx, RuntimeStreamEventSummary as jy, DriverAttemptStop as k, RetainedRunHandle as kC, LoopPlanPayload as kS, WorkerResumeContext as k_, strategyTournament as ka, BudgetPool as kb, ScopeAnalyst as kc, ResolveSupervisorTools as kd, DriverRetryPolicy as kf, areaUnderCurve as kg, DeliverableSpec as kh, ChatTransportTool as ki, IsolatedCheckOutputEvidence as kl, RunDetachedTurnOptions as km, SearchSpecInputs as kn, CreateScopeAnalystOptions as ko, resolveAgentEnvironmentProvider as kp, InteractiveWorkerResult as kr, StrategyMessage as ks, WatchedSurface as kt, GraphRouteError as ku, SqlRunOwnershipError as kv, createActivityLog as kx, RuntimeStreamEventCollector as ky, AgentTaskRunResult as l, ValidationError as lC, ProviderWorkspaceCaptureProvenance as lS, EscalateQuestion as l_, resolveEntrySymbol as la, SubtreeResult as lb, renderReport as lc, formatPromptHandle as ld, serveCoordinationMcp as lf, AxisScoresOf as lg, UiFindingSeverity as lh, storedGraphDigests as li, LeaderboardRunContext as ll, ToolLoopCompactionOptions as lm, WorkspaceRun as ln, PrivateCasArtifactPort as lo, createSteerableSandboxSession as lp, RemoteSupervisorTree as lr, InProcessPromptCtx as ls, CreateAgentEnvironmentInput$1 as lt, ObserverJournal as lu, defaultToolDetectors as lv, ExecutorTeardownWarning as lx, RootHandle as ly, OpenAIChatResponseFormat as m, RecoverRetainedRunIntentOptions as mC, ExecutorToolCall as mS, QuestionEscalationTarget as m_, AgentTurnBackend as ma, ProviderModelAttemptEvidence as mb, CorpusRecord as mc, SupervisorSpanOptions as md, FileCoordinationLog as mf, LeaderboardRow as mg, ResearchSource as mh, DispatchUnit as mi, DeclaredCheck as ml, CoderDelegate as mm, TrajectoryAnalysis as mn, equalKOnCost as mo, PeerInboxMessage as mp, ProvisionSupervisorRequest as mr, MaterializeLocalMcpOptions as ms, PlacementInfo as mt, EdgeDeliveryOutcome as mu, AnalystLensOutput as mv, WorkerInteractiveSession as mx, Supervisor as my, AgentBackendContext as n, defaultRedactor as nC, HarnessTranscriptReadOptions as nS, JsonScalar as n_, compareCheckOutcomes as na, NodeSnapshot as nb, Observation as nc, PromptRegistry as nd, bestDelivered as nf, CodeModeTool as ng, FeedbackRating as nh, graphRunsFor as ni, providerAsSandboxClient as nl, RouterResponseReceipt as nm, UntrackedCopyStats as nn, reconnectRetainedInteractiveRun as no, RouterSeam as np, workerInboxFileFromEventDir as nr, superviseDispatch as ns, AgentSession as nt, PursuitNodeUsage as nu, BusEvent as nv, UnknownMaterializationReason as nx, InMemorySpawnJournal as ny, AgentRuntimeEvent as o, ConfigError as oC, resolveHarnessTranscriptCapture as oS, RouteMatch as o_, filterAuthoredAsserts as oa, SpawnOpts as ob, ObserveOptions as oc, delegatesWorkerBriefPrompt as od, CoordinationPublicAddress as of, RunCodeModeOptions as og, UiAuditorDelegationOutput as oh, pickBestGraph as oi, LeaderboardBenchmarkAdapter as ol, ToolLoopCallContext as om, Shell as on, resolveSandboxClient as oo, SandboxSteeringOptions as op, RemoteSupervisorControl as or, defaultSelectWinner as os, AnalystFinding$1 as ot, PursuitStatus as ou, PublishOptions as ov, ExecutorCancellation as ox, TraceRootReceipt as oy, KnowledgeReadinessDecision as p, ReconnectRetainedRunOptions as pC, ExecutorProgressEvent as pS, QuestionEscalationRecord as p_, visibleCheckScore as pa, NoWinnerError as pb, CorpusFilter as pc, SupervisorSpanAttributes as pd, CoordinationLog as pf, LeaderboardOptions as pg, ResearchOutput as ph, DispatchStopReason as pi, defineLeaderboard as pl, FeedbackStore as pm, runInWorkspace as pn, createPrivateCasArtifactPort as po, InboxMessage as pp, ProvisionSupervisorConnection as pr, LocalMcpMaterialization as ps, ForkRequest as pt, AgentGraph as pu, AnalystKind as pv, Runtime as px, SteerableRootHandle as py, WorkerSpawnContext as q, RuntimeRunCost as qS, createPeerMailbox as q_, PrivateCasNamespaceInventory as qa, ExecutionBindingReceipt as qb, Persona as qc, plateau as qd, createDelegateHandler as qf, EventAcknowledgement as qg, CodexRolloutTurn as qh, CheckSource as qi, superviseGraphPursuit as ql, DelegateUiAuditRoute as qm, WriteWorkerSteerOptions as qn, printBenchmarkReport as qo, SandboxOutputMarker as qp, GraphRunRecord as qr, defineStrategy as qs, EVIDENCE_MAX_CHARS as qt, subscriptionUsageLimitSignal as qu, FileSpawnJournal as qv, captureBoundHarnessTranscript as qx, BudgetOverspend as qy, AgentBackendInput as r, AgentEvalError$1 as rC, RetainedHarnessTranscriptCapture as rS, RouteFlow as r_, composeCheckSources as ra, NodeStatus as rb, ObservationAnalysis as rc, RegisteredPrompt as rd, CoordinationAuthentication as rf, CodeModeToolContext as rg, FeedbackRefersTo as rh, listGraphRuns as ri, DefinedLeaderboard as rl, RouterTransportConfig as rm, copyUntrackedIntoClone as rn, recoverRetainedInteractiveRun as ro, RouterToolsSeam as rp, writeWorkerSteer as rr, LocalSandboxClientOptions as rs, AgentSessionRef as rt, PursuitProjection as ru, BusRecord as rv, EnvironmentTeardownReceipt as rx, ResultBlobStore as ry, AgentRuntimeEventSink as s, JudgeError as sC, retainHarnessTranscript as sS, RouteWhen as s_, modelAuthoredChecks as sa, SpawnPrior as sb, defaultAnalystInstruction as sc, dumbContinuationFailPrompt as sd, CoordinationReadAccess as sf, createCodeModeTools as sg, UiFinding as sh, recordGraphRun as si, LeaderboardFlagSpec as sl, ToolLoopChat as sm, Workspace as sn, profileChatClient as so, SteerableSandboxArgs as sp, RemoteSupervisorReader as sr, inlineSandboxClient as ss, CheckpointRef as st, projectPursuit as su, createEventBus as sv, ExecutorCancellationRequest as sx, WorkspaceCheckpointMarker as sy, AgentAdapter as t, Redactor as tC, HarnessTranscriptReadLimits as tS, GateRequest as t_, canDisplace as ta, NodeId as tb, harvestCorpus as tc, PromptHandle as td, SupervisorFinalizer as tf, CodeModeStore as tg, DelegationStatusResult as th, graphRegistry as ti, ProviderAsSandboxClientOptions as tl, sumSandboxUsage as tm, CopyOptions as tn, claimRetainedInteractiveControl as to, ProviderSeam as tp, supervisorRunsRoot as tr, loopDispatch as ts, AgentProfile$2 as tt, PursuitNodeTiming as tu, McpTransport as tv, RootMaterialization as tx, InMemoryResultBlobStore as ty, AgentTaskSpec as u, NativeContextContinuationExecution as uC, ProviderWorkspaceCaptureReceipt as uS, Question as u_, sandboxCheckRunner as ua, SubtreeSummary as ub, AssertTraceDerivedFindings as uc, kernelPromptRegistry as ud, CoordinationHttpAudit as uf, GroupOf as ug, UiLens as uh, taskShapeDigest as ui, LeaderboardScenario as ul, ToolLoopMessageRecord as um, gitWorkspace as un, PrivateCasDurableStore as uo, AuthorityInboxMessage as up, RemoteWorkerEvents as ur, InProcessSandboxClientOptions as us, CreateSandboxOptions$1 as ut, ObserverRecord as uu, watchTrace as uv, HeldEnvironment as ux, RootSegment as uy, RunAgentTaskStreamOptions as v, RetainedInteractiveEnvironmentAdmission as vC, DefaultVerdict$2 as vS, QuestionRecord as v_, StreamAgentTurnOptions as va, SupervisedResult as vb, FanoutOptions as vc, RootStreamRecord as vd, ContinuationEntry as vf, ScoreOf as vg, DelegationTraceSpan as vh, rollingDispatch as vi, checkProgramDigest as vl, DetachedSessionDelegateOptions as vm, DEFAULT_MAX_DEPTH as vn, FileCorpus as vo, SharedBoxPlacement as vp, ProfileRegistryDir as vr, StdioMcpServerSpec as vs, WorkspaceRequest as vt, GraphNode as vu, AuthoredAnalystDefinition as vv, SessionMessageLike as vx, createPropagatingTraceEmitter as vy, RuntimeFailureCode as w, RetainedRunCancellation as wC, LoopIterationDispatchPayload as wS, ContinuityMode as w_, StrategyEvolutionConfig as wa, UnconfirmedTeardown as wb, PanelJudge as wc, CoordinationVerbs as wd, PanelFinding as wf, renderPairwiseMarkdown as wg, CoderOutput as wh, defaultDelegateBudget as wi, IsolatedCheckBoxEvidence as wl, FleetWorkspaceExecutorOptions as wm, SqlRunContextOptions as wn, panel as wo, sharedBoxRefusal as wp, profileRunsForName as wr, AgenticTask as ws, HarvestSurfaceDiffsOptions as wt, runGraph as wu, runLocalHarness as wv, DEFAULT_STALL_AFTER_MS as wx, OtelSpan as wy, RuntimeSessionStore as x, RetainedRunAdmission as xC, Iteration as xS, AuthorizeDownMessage as x_, EvolutionAuthor as xa, ResumedKeyState as xb, LoopUntilSpec as xc, supervisorAgent as xd, ContinuationPanelResult as xf, renderLeaderboardHtml as xg, DelegationStore as xh, GraphDesignerExtraTools as xi, declaredCheckJudge as xl, detachedSessionDelegate as xm, ValidateStoredGraphOptions as xn, fanout as xo, SharedWorkerIdentity as xp, loadProfile as xr, AgenticOptions as xs, VerifierEnvironmentOptions as xt, RunGraphOptions as xu, CodexExecutionEvidence as xv, createPushTraceSource as xx, OtelExportConfig as xy, RuntimeCanonicalStreamEvent as y, RetainedInteractiveIntentAdmission as yC, Driver as yS, QuestionUrgency as y_, collectAgentTurn as ya, Agent as yb, FanoutSynthesis as yc, readRootStream as yd, ContinuationPanel as yf, leaderboard as yg, composeLoopTraceEmitters as yh, DesignerRunGraphEnv as yi, declaredCheckDeliverable as yl, DetachedWinnerSelection as ym, createSupervisor as yn, InMemoryCorpus as yo, SharedBoxPlacementOptions as yp, ProfileRunRecord as yr, connectStdioMcp as ys, computeFindingId$1 as yt, GraphResult as yu, AuthoredAnalystLimits as yv, ToolStepInput as yx, readTraceContextFromEnv as yy, MakeWorkerAgent as z, MountRecorder as zS, PeerMailLimits as z_, SandboxLineageHandle as za, ReserveOptions as zb, WidenDecision as zc, NoProgressForOptions as zd, createMcpServer as zf, InPlaceHarnessResult as zg, deterministicCompletion as zh, defaultProfileRichnessThresholds as zi, SettledPursuitVersion as zl, SubmitInput as zm, TRACE_SUMMARY_SCHEMA as zn, sanitizeMcpToolSchema as zo, KeyProvider as zp, GraphFileSeat as zr, ShotSpec as zs, WorktreeCliExecutorOptions as zt, SuperviseTestOptions as zu, loadSpawnForest as zv, HarnessTranscriptArtifact as zx, WorkerSlots as zy };
-//# sourceMappingURL=types-w3Oo1uRJ.d.ts.map
+export { AgentEnvironmentStatus as $, SelectionReceipt as $S, PeerMailboxOptions as $_, recoverRetainedRun as $a, ExecutorRegistry as $b, RunPersonifiedOptions as $c, anyOf as $d, DelegateHandlerOptions as $f, AwaitWakeInput as $g, CodexRolloutStoreReader as $h, StructuralRolloutMessage as $i, PursuitCostProvenance as $l, DelegateUiAuditArgs as $m, readWorkerSteerRequests as $n, LoopOptionsForDispatch as $o, secretEnvOfMcpServer as $p, digestOfGraph as $r, HarvestCorpusOptions as $s, settledWorkerOut as $t, SeatStage as $u, cancelRun as $v, HarnessTranscriptFile as $x, SpendChannel as $y, DriverContinuationRecord as A, RetainedInteractiveStartedAdmission as AC, ExecCtx as AS, AuthorizedDownMessage as A_, runStrategyEvolution as Aa, SettledUsage as Ab, RenderCorpusToInstructionsOptions as Ac, supervisorAgentWithTestBrain as Ad, ContinuationPolicy as Af, renderLeaderboardMarkdown as Ag, FileDelegationStore as Ah, ChatTransportExecutorOptions as Ai, IsolatedCheckOutputDeclaration as Al, DelegationExecutor as Am, SearchSpecOwnedOption as An, widen as Ao, sharedBoxPlacement as Ap, InteractiveWorkerResult as Ar, RunAgenticOptions as As, boxSurfaceReader as At, GraphCheckPlacement as Au, LocalHarnessResult as Av, TraceSource as Ax, RuntimeStreamEventCollector as Ay, PeerAuditAccess as B, RetainedRunIntentAdmission as BC, LoopResult as BS, MapSpawnMarker as B_, SandboxLineage as Ba, BudgetReadout as Bb, Widen as Bc, SupervisorNodeContext as Bd, SpawnResourceBytes as Bf, renderAnytimeTable as Bg, mapExecutorResult as Bh, assessAuthoredProfile as Bi, PursuitVersions as Bl, DelegationRecord as Bm, TraceRootArtifact as Bn, createMcpEnvironment as Bo, ProviderPromptOptions as Bp, GraphFileSeat as Br, AuthoredStrategy as Bs, WorktreePatchArtifact as Bt, GraphTopology as Bu, materializeTreeView as Bv, readWorkerProgress as Bx, WorkerSlots as By, RuntimeFailureCause as C, ReconnectRetainedRunOptions as CC, ExecutorProgressEvent as CS, QuestionLevel as C_, EvolutionAuthor as Ca, ResumedWork as Cb, LoopUntilSpec as Cc, SupervisorSpanOutcome as Cd, PriorCoordination as Cf, PairwiseOptions as Cg, ResearchTask as Ch, GraphDesignerExtraTools as Ci, declaredCheckJudge as Cl, CoderReview as Cm, FencedSqlRunContext as Cn, fanout as Co, DEFAULT_SHARED_BOX_RESOURCES as Cp, pickBestProfile as Cr, AgenticOptions as Cs, BoxSurfaceReaderOptions as Ct, SuperviseOptions as Cu, AnalystRegistry$1 as Cv, Runtime as Cx, OtelExportStats as Cy, RetainedPendingCause as D, RetainedInteractiveAdmission as DC, AgentRunSpec as DS, QuestionUrgency as D_, StrategyTournament as Da, WorkerEventCursor as Db, PanelSpec as Dc, readRootStream as Dd, ContinuationPanel as Df, leaderboard as Dg, composeLoopTraceEmitters as Dh, delegate as Di, IsolatedCheckOptions as Dl, DetachedWinnerSelection as Dm, SEARCH_SPEC_CORRELATION_KEY as Dn, pipeline as Do, SharedBoxPlacementOptions as Dp, InteractiveWorkerEnvironment as Dr, AgenticTool as Ds, SurfaceReadOutcome as Dt, GraphCheckNode as Du, AuthoredAnalystLimits as Dv, WorkerTraceUnavailableReason as Dx, createOtelExporter as Dy, EvidencePendingEvent as E, RecoverRetainedRunResult as EC, UsageEvent as ES, QuestionRecord as E_, StrategyEvolutionConfig as Ea, WidenGate as Eb, PanelJudge as Ec, RootStreamRecord as Ed, ContinuationEntry as Ef, ScoreOf as Eg, DelegationTraceSpan as Eh, defaultDelegateBudget as Ei, IsolatedCheckBoxEvidence as El, DetachedSessionDelegateOptions as Em, CompiledSearchSpec as En, panel as Eo, SharedBoxPlacement as Ep, recordProfileRun as Er, AgenticTask as Es, SurfaceReadBox as Et, SuperviseRegistryTable as Eu, AuthoredAnalystDefinition as Ev, WorkerTraceEvidence as Ex, buildLoopOtelSpans as Ey, CoordinationTools as F, RetainedRunDispatchedAdmission as FC, LoopIterationEndedPayload as FS, DownMessageDeliveryOutcome as F_, OpenSandboxRunPromptOptions as Fa, SpawnForestNode as Fb, TrajectoryNode as Fc, ObserveSupervisorNodeEvent as Fd, DriverContractState as Ff, AnytimeTaskCurve as Fg, CheckVerdict as Fh, createChatSessionStore as Fi, JudgedPursuitVersion as Fl, createSiblingSandboxExecutor as Fm, settledToIteration as Fn, createScopeAnalyst as Fo, AgentEnvironmentProviderRegistry as Fp, ObservedSessionFacts as Fr, depthStrategy as Fs, failuresAnalyst as Ft, EdgeTraversal as Fu, CodexTokenUsage as Fv, ExecutorProgress as Fx, SanitizedKnowledgeRequirement as Fy, SpawnRefusalCause as G, StartRetainedRunInEnvironmentOptions as GC, LoopTraceEmitter as GS, PeerMailEnvelope as G_, acquireSandbox as Ga, ReservationShortfall as Gb, DefinePersona as Gc, SupervisorProfile as Gd, McpServer as Gf, RunAgentRoundsOptions as Gg, CompletionVerdict as Gh, CheckExecChannel as Gi, SuperviseGraphPursuitOptions as Gl, DelegationTaskQueue as Gm, WorkerSteerAcknowledgement as Gn, BenchmarkReport as Go, BridgeModelCredential as Gp, GraphCorpusGroup as Gr, StrategyResult as Gs, attachWorker as Gt, runGraphWithTestBrain as Gu, SpawnJournalReadRecord as Gv, RetainedInteractiveRunHandle as Gx, RunParkingRecord as Gy, SpawnPreflight as H, RetainedRunSnapshot as HC, LoopStartedPayload as HS, AUTHORITY_MARKERS as H_, createSandboxLineage as Ha, ReservationFloor as Hb, WidenLineage as Hc, SupervisorToolDescriptor as Hd, SpawnResourceReader as Hf, WaterfallReport as Hg, CompletionAnalyst as Hh, profileRichnessFinding as Hi, VersionJudge as Hl, DelegationResumeDriver as Hm, RunTraceSources as Hn, BenchmarkCell as Ho, UnavailablePausePolicy as Hp, LoadedGraphFile as Hr, Strategy as Hs, AttachWorkerOptions as Ht, RunGraphTestOptions as Hu, replaySpawnTree as Hv, RecoverRetainedInteractiveRunOptions as Hx, ParkedRun as Hy, CoordinationToolsOptions as I, RetainedRunEffect as IC, LoopIterationStartedPayload as IS, DownMessageEvent as I_, SandboxRun as Ia, SpawnForestTree as Ib, TrajectoryReport as Ic, ResolveDriveHarness as Id, DriverReentry as If, anytimeReport as Ig, CompletionCheckContext as Ih, AuthoredProfile as Ii, NextPursuitVersion as Il, DetachedTurn as Im, createScope as In, registryScopeAnalyst as Io, createAgentEnvironmentProviderRegistry as Ip, graphFromSessionFacts as Ir, refine as Is, AuthoredHarness as It, GraphEdge as Iu, CodexExecutionPolicy as Iv, ScopeProgressInput as Ix, createRuntimeEventCollector as Iy, AgentEnvironment$1 as J, MountManifestEntry as JS, PeerMailOutcome as J_, createS3PrivateCasStore as Ja, ReserveOptions as Jb, Outcome as Jc, PlateauOptions as Jd, EventSubscription as Jf, WorktreeCheckRunner as Jg, sentinelCompletion as Jh, CheckRunner as Ji, SupervisedPursuitResult as Jl, SubmitOutput as Jm, cancelWorker as Jn, Environment as Jo, ResolvedMcpServerLaunch as Jp, GraphRunQuery as Jr, authorStrategy as Js, NOTE_MAX_CHARS as Jt, PortableContinuationPolicy as Ju, FileSpawnJournal as Jv, HARNESS_TRANSCRIPT_SETTLE_TIMEOUT_MS as Jx, BudgetOverspend as Jy, SuperviseProfileEntry as K, StartRetainedRunOptions as KC, LoopTraceEvent as KS, PeerMailEvent as K_, S3PrivateCasStore as Ka, ReservationStage as Kb, DefinePersonaInput as Kc, AllWorkersStalledOptions as Kd, McpServerOptions as Kf, runAgentRounds as Kg, completionAuthorizes as Kh, CheckOutcome as Ki, SupervisePursuitError as Kl, DelegationTaskQueueOptions as Km, WorkerSteerRequest as Kn, BenchmarkStrategySummary as Ko, BridgeSeam as Kp, GraphCorpusSummary as Kr, adaptiveRefine as Ks, readWorkerInteractiveBinding as Kt, defaultEdgeTraversalCap as Ku, SpawnJournalReadResult as Kv, RetainedInteractiveStartMaterial as Kx, readRunParking as Ky, GraphSubtaskPreparation as L, RetainedRunEnvironmentAdmission as LC, LoopLineageOptions as LS, WorkerResumeContext as L_, SandboxRunAbortError as La, loadSpawnForest as Lb, TrajectoryReportOptions as Lc, ResolveSupervisorTools as Ld, DriverRetryPolicy as Lf, areaUnderCurve as Lg, DeliverableSpec as Lh, ProfileRichness as Li, NextPursuitVersionInput as Ll, RunDetachedTurnOptions as Lm, ScopeArgs as Ln, observationFromRegistry as Lo, resolveAgentEnvironmentProvider as Lp, graphFileSchema as Lr, runAgentic as Ls, WorktreeFanoutOptions as Lt, GraphEdgeCapError as Lu, SqlRunOwnershipError as Lv, TeamProgress as Lx, createRuntimeStreamEventCollector as Ly, DriverRepromptRefusal as M, RetainedRunAdmissionHook as MC, LoopDecisionPayload as MS, ContinuityMode as M_, Deliverable as Ma, SpawnForestEvent as Mb, ScopeAnalyzeInput as Mc, CoordinationVerbs as Md, PanelFinding as Mf, renderPairwiseMarkdown as Mg, CoderOutput as Mh, ChatWorkerSeamOptions as Mi, IsolatedCheckOutputFailure as Ml, FleetWorkspaceExecutorOptions as Mm, compileSearchSpec as Mn, RegistryAnalyzeProjection as Mo, sharedBoxRefusal as Mp, InPlaceCliExecutorOptions as Mr, StrategyShotResult as Ms, harvestSurfaceDiffs as Mt, GraphFromStoredOptions as Mu, runLocalHarness as Mv, ActivityLog as Mx, RuntimeStreamEventSummary as My, BlockedToolReport as N, RetainedRunCancelOptions as NC, LoopEndedPayload as NS, DownMessageAuthorizationInput as N_, OpenSandboxRunBeforeStartContext as Na, SpawnForestInDoubtNode as Nb, ScopeWidenGate as Nc, DriveHarness as Nd, VerdictSummary as Nf, AnytimeReport as Ng, CoderTask as Nh, chatTransportExecutor as Ni, IsolatedCheckOutputOptions as Nl, SiblingSandboxExecutorOptions as Nm, searchPresets as Nn, assertTraceDerivedFindings as No, sharedWorkerClientName as Np, createInPlaceCliExecutor as Nr, SurfaceScore as Ns, AnalystAuthoring as Nt, AgentGraph as Nu, LOCAL_HARNESSES as Nv, ActivityNote as Nx, RuntimeTelemetryOptions as Ny, DriverAttemptRecord as O, RetainedInteractiveEnvironmentAdmission as OC, DefaultVerdict$2 as OS, questionEscalationTargets as O_, TournamentCell as Oa, WorkerEventEntry as Ob, PanelVerdict as Oc, readRootStreamReceipt as Od, ContinuationPanelInput as Of, pairwiseSignificance as Og, DelegationPersistenceError as Oh, ChatCompletionsTransport as Oi, IsolatedCheckResult as Ol, UiAuditorDelegate as Om, SearchSpec as On, selectValidWinner as Oo, SharedBoxStats as Op, InteractiveWorkerKeyInput as Or, ArtifactHandle as Os, SurfaceReader as Ot, GraphCheckNodes as Ou, DefinedAnalystRecord as Ov, SessionMessageLike as Ox, loopEventToOtelSpan as Oy, CoordinationStats as P, RetainedRunCancellation as PC, LoopIterationDispatchPayload as PS, DownMessageDeliveryAttempt as P_, OpenSandboxRunOptions as Pa, SpawnForestMissingTree as Pb, SteerContext as Pc, DriveHarnessOwnerContext as Pd, admitContinuationPolicy as Pf, AnytimeStrategySummary as Pg, CheckUnavailableError as Ph, chatWorkerSeam as Pi, validateIsolatedCheckOutputs as Pl, createFleetWorkspaceExecutor as Pm, searchSpecDigest as Pn, buildSteerContext as Po, AgentEnvironmentProviderRef as Pp, GraphSessionObservationOptions as Pr, breadthStrategy as Ps, analystsFromRegistry as Pt, EdgeDeliveryOutcome as Pu, LocalHarness as Pv, DEFAULT_STALL_AFTER_MS as Px, SanitizedKnowledgeReadinessReport as Py, AgentEnvironmentQuery as Q, SandboxClient as QS, PeerMailbox as Q_, reconnectRetainedRun as Qa, ExecutorFactory as Qb, RunPersonified as Qc, allWorkersStalled as Qd, DelegateError as Qf, GitRunner as Qg, CodexRolloutSession as Qh, StructuralRolloutConfig as Qi, PursuitObserverDelivery as Ql, DelegateResearchConfig as Qm, readWorkerSteerAcknowledgement as Qn, LoopDispatchOptions as Qo, resolveSecretEnv as Qp, StoredGraphInput as Qr, strategyAuthorSystemPrompt as Qs, composeWorkerEvidence as Qt, SeatSelectionInput as Qu, RunCancellation as Qv, HarnessTranscriptEvidence as Qx, Spend as Qy, GraphSubtasks as R, RetainedRunEventOptions as RC, LoopPlanDescription as RS, MapItemFailurePolicy as R_, TurnResult as Ra, BudgetPool as Rb, Verify as Rc, SupervisorAgentDeps as Rd, ResolveSpawnResourcePathsResult as Rf, bestSoFar as Rg, ExecutorResultMapping as Rh, ProfileRichnessThresholds as Ri, PursuitVersionChain as Rl, runDetachedTurn as Rm, TRACE_ROOT_SCHEMA as Rn, McpEndpoint as Ro, ProviderExecutorOptions as Rp, graphRouteWhenSchema as Rr, sample as Rs, worktreeFanout as Rt, GraphNode as Ru, openSqlRunStore as Rv, WorkerProgress as Rx, sanitizeKnowledgeReadinessReport as Ry, RuntimeStreamEvent as S, NativeContextContinuationInput as SC, ProviderWorkspaceEntryMetadata as SS, QuestionEscalationTarget as S_, streamAgentTurn as Sa, ResumedKeyState as Sb, FanoutWinnerSelector as Sc, SupervisorSpanOptions as Sd, FileCoordinationLog as Sf, LeaderboardRow as Sg, ResearchSource as Sh, DesignerToolsEnv as Si, declaredCheckDigest as Sl, CoderDelegate as Sm, validateStoredGraph as Sn, renderCorpusToInstructions as So, PeerInboxMessage as Sp, loadProfile as Sr, materializeLocalMcp as Ss, createVerifierEnvironment as St, AuthorizedSpawnContext as Su, AnalystLensOutput as Sv, HeldRelease as Sx, OtelExportConfig as Sy, RuntimeFailureOwner as T, RecoverRetainedRunOptions as TC, TokenUsageProvenance as TS, QuestionPolicy as T_, EvolutionStrategy as Ta, UnconfirmedTeardown as Tb, Panel as Tc, createSupervisorSpanRecorder as Td, ContinuationAppend as Tf, ProfileKeyOf as Tg, researcherProfile as Th, DelegateOptions as Ti, IsolatedCheckBox as Tl, DelegateRunCtx as Tm, createFencedSqlRunContext as Tn, loopUntil as To, SharedBoxCloseReceipt as Tp, profileRunsForName as Tr, AgenticSurface as Ts, SurfaceDiff as Tt, SuperviseRegistry as Tu, AnalyzeOnSettleRoute as Tv, WorkerInteractiveUnavailableReason as Tx, OtelSpan as Ty, SpawnPreflightContext as U, RetainedRunStartMaterial as UC, LoopTeardownFailedPayload as US, DEFAULT_PEER_MAIL_LIMITS as U_, SandboxEvidenceReceipt as Ua, ReservationHolder as Ub, WidenSpec as Uc, SupervisorToolInvocationContext as Ud, environmentReader as Uf, WaterfallSpan as Ug, CompletionEvidence as Uh, supervisorInstructions as Ui, VersionVerdict as Ul, DelegationResumeTick as Um, runToolSpans as Un, BenchmarkConfig as Uo, ProviderPlacement as Up, graphWorkspace as Ur, StrategyArtifacts as Us, WorkerInteractiveBinding as Ut, TraversalContinuity as Uu, SpawnJournalCursor as Uv, RetainedInteractiveAdmissionHook as Ux, RunParkedError as Uy, SettledWorker as V, RetainedRunReplayPoint as VC, LoopSandboxPlacement as VS, MapTraversalEvent as V_, SandboxLineageHandle as Va, LeakedReservation as Vb, WidenDecision as Vc, SupervisorNodeContextSeed as Vd, SpawnResourceRead as Vf, WaterfallCollector as Vg, verdictFromJudgeScore as Vh, defaultProfileRichnessThresholds as Vi, SettledPursuitVersion as Vl, DelegationResumeContext as Vm, TraceSummary as Vn, sanitizeMcpToolSchema as Vo, providerAsExecutor as Vp, LoadGraphFileOptions as Vr, ShotSpec as Vs, createWorktreeCliExecutor as Vt, RunGraphOptions as Vu, FileResultBlobStore as Vv, ReconnectRetainedInteractiveRunOptions as Vx, createWorkerSlots as Vy, SpawnRefusal as W, RetainedRunTurnInput as WC, LoopTokenUsage as WS, PEER_MAIL_WIRE_KEY as W_, AcquireOptions as Wa, ReservationRejection as Wb, WinnerStrategy as Wc, ManagerWakePolicy as Wd, resolveSpawnResourcePaths as Wf, createWaterfallCollector as Wg, CompletionPolicy as Wh, RunCancellationReason as Wi, assertPursuitVersions as Wl, DelegationRunContext as Wm, WorkerCancellation as Wn, BenchmarkLift as Wo, BridgeHarnessStore as Wp, loadGraphFile as Wr, StrategyCtx as Ws, WorkerInteractiveProviderSource as Wt, runGraph as Wu, SpawnJournalReadOptions as Wv, RetainedInteractiveEnvironmentInput as Wx, RunParkingPolicy as Wy, AgentEnvironmentEvent$1 as X, OutputAdapter as XS, PeerMailRefusal as X_, PrivateCasNamespaceObject as Xa, AgentSpec as Xb, PersonaContext as Xc, StopDecision as Xd, McpEventRecord as Xf, WorktreeHarnessResult as Xg, CodexForkBoundary as Xh, CheckSourceCtx as Xi, supervisePursuit as Xl, DelegateCodeConfig as Xm, legacySupervisorRunDir as Xn, runBenchmark as Xo, mcpSecretEnvMetadataKey as Xp, GraphSelection as Xr, sampleThenRefine as Xs, WorkerEvidenceInput as Xt, SeatSegment as Xu, readRunState as Xv, HarnessTranscriptBinding as Xx, ResourceLimit as Xy, AgentEnvironmentCapabilities$1 as Y, MountRecorder as YS, PeerMailReadout as Y_, PrivateCasNamespaceInventory as Ya, createBudgetPool as Yb, Persona as Yc, ProgressView as Yd, EventSubscriptionStore as Yf, WorktreeCommandResult as Yg, stopSentinel as Yh, CheckSource as Yi, superviseGraphPursuit as Yl, DelegateCodeArgs as Ym, fileEscalateQuestion as Yn, printBenchmarkReport as Yo, envKeyProvider as Yp, GraphRunRecord as Yr, defineStrategy as Ys, VERIFY_TAIL_CHARS as Yt, portableContinuationPolicySchema as Yu, RunState as Yv, HarnessTranscriptArtifact as Yx, BudgetViolation as Yy, AgentEnvironmentProvider$1 as Z, RunProvenance as ZS, PeerMailSendInput as Z_, PrivateCasNamespaceRetirement as Za, ExecutorContext as Zb, PersonaExecutors as Zc, StopRule as Zd, McpEventSource as Zf, WorktreeProfileMaterializationReceipt as Zg, CodexRolloutIdentity as Zh, RepairStop as Zi, RunReopen as Zl, DelegateResearchArgs as Zm, readWorkerCancellation as Zn, LoopCampaignDispatchOptions as Zo, resolveMcpServerLaunch as Zp, StoredGraph as Zr, strategyAuthorContract as Zs, closingWorkerNote as Zt, SeatSelection as Zu, RunCancelRequest as Zv, HarnessTranscriptCapture as Zx, ResourceSpend as Zy, RunAgentTaskOptions as _, JudgeError as _C, retainHarnessTranscript as _S, EscalateQuestion as __, AgentTurnInput$1 as _a, RootProviderModelEvidence as _b, EqualKArm as _c, formatPromptHandle as _d, serveCoordinationMcp as _f, AxisScoresOf as _g, UiFindingSeverity as _h, RollingDispatchOptions as _i, DeclaredCheckPlacement as _l, ToolLoopCompactionOptions as _m, parseWorkerToolTraceArtifact as _n, trajectoryReport as _o, createSteerableSandboxSession as _p, SupervisorCleanupReceipt as _r, McpListedTool as _s, SandboxInstance$1 as _t, supervise as _u, defaultToolDetectors as _v, ExecutorCancellationRequest as _x, WorkerTraceResolver as _y, AgentKnowledgeProvider as a, RuntimeRunOptions as aC, harnessTranscriptArtifact as aS, ToolOutcomeEvent as a_, composeCheckSources as aa, RetainedExecutionState as ab, ObservationAnalysis as ac, RunContextLease as ad, composeReentryTask as af, harnessUsageIsEmpty as ag, DelegationHistoryEntry as ah, listGraphRuns as ai, DefinedLeaderboard as al, mapSandboxToolEvent as am, GitWorkspaceOptions as an, recoverRetainedInteractiveRun as ao, CliInPlaceSeam as ap, RemoteSupervisorAgent as ar, LocalSandboxClientOptions as as, AgentTurnResult$2 as at, PursuitProjection as au, JsonRpcMessage as av, ExecutorNodeContext as ax, SpawnEvent as ay, RuntimeSession as b, NativeContextContinuationExecution as bC, ProviderWorkspaceCaptureReceipt as bS, QuestionEscalationOutcome as b_, StreamAgentTurnOptions as ba, Agent as bb, FanoutOptions as bc, promptHandle as bd, CoordinationDeliveryEvidence as bf, Leaderboard as bg, KnowledgeUpdate as bh, rollingDispatch as bi, checkProgramDigest as bl, FeedbackEvent as bm, createRootHandle as bn, FileCorpus as bo, InboxLease as bp, ProfileRunRecord as br, StdioMcpServerSpec as bs, makeFinding$1 as bt, workerFromBackend as bu, AnalystFindingEvent as bv, HeldEnvironment as bx, readTraceContextFromEnv as by, AgentTaskContext as c, RuntimeRunStatus as cC, HARNESS_TRANSCRIPT_READ_LIMITS as cS, GateDecision as c_, filterAuthoredAsserts as ca, SpawnPrior as cb, ObserveOptions as cc, withRunContext as cd, FinalizerSettled as cf, decodeHarnessUsage as cg, DelegationStatus as ch, pickBestGraph as ci, LeaderboardBenchmarkAdapter as cl, extractLlmCallEvent as cm, WorkspaceCommit as cn, resolveSandboxClient as co, CliWorktreeSeam as cp, RemoteSupervisorReader as cr, defaultSelectWinner as cs, CheckpointRequest as ct, PursuitStatus as cu, McpToolDescriptor as cv, MaterializedResources as cx, WorkspaceCheckpointMarker as cy, AgentTaskStatus as d, Redactor as dC, HarnessTranscriptReadLimits as dS, RouteFlow as d_, resolveEntrySymbol as da, SubtreeSummary as db, renderReport as dc, RegisteredPrompt as dd, CoordinationAuthentication as df, CodeModeToolContext as dg, FeedbackRefersTo as dh, storedGraphDigests as di, LeaderboardRunContext as dl, RouterTransportConfig as dm, jjWorkspace as dn, PrivateCasArtifactPort as do, RouterToolsSeam as dp, RemoteWorkerEvents as dr, InProcessPromptCtx as ds, ExecRequest as dt, ObserverJournal as du, BusRecord as dv, RootMaterialization as dx, RootSegment as dy, ValidationCtx as eC, HarnessTranscriptUnavailable as eS, CoordinationEvent as e_, StructuralRolloutPolicy as ea, SpendGap as eb, HarvestError as ec, SelectSeat as ed, noProgressFor as ef, CodexRolloutStoreRef as eg, DelegateUiAuditConfig as eh, graphCorpusSummary as ei, ShapeBudget as el, SandboxLeafOut as em, spendFromUsageEvents as en, startRetainedRun as eo, DelegateResult as ep, safeWorkerFile as er, SuperviseDispatchOptions as es, AgentEnvironmentSummary as et, PursuitNodeCost as eu, claimsAuthority as ev, SpawnModelSubstitution as ex, readRunCancelRequest as ey, BackendErrorDetail as f, defaultRedactor as fC, HarnessTranscriptReadOptions as fS, RouteFlowEvent as f_, sandboxCheckRunner as fa, TreeView as fb, AssertTraceDerivedFindings as fc, analyzesFindingsReportPrompt as fd, CoordinationControlAccess as ff, CodeModeToolsOptions as fg, ResearchOutputShape as fh, taskShapeDigest as fi, LeaderboardScenario as fl, RouterRouting as fm, localShell as fn, PrivateCasDurableStore as fo, SandboxSeam as fp, connectRemoteSupervisor as fr, InProcessSandboxClientOptions as fs, ExecResult as ft, ObserverRecord as fu, BusStats as fv, UnknownMaterializationReason as fx, RootSegmentEntry as fy, OpenAIChatToolChoice as g, ConfigError as gC, resolveHarnessTranscriptCapture as gS, ChildQuestionInbox as g_, AgentTurnBackend as ga, ProviderModelExecutionEvidence as gb, CorpusRecord as gc, dumbContinuationPassPrompt as gd, CoordinationTransportOptions as gf, runCodeMode as gg, UiFindingScreenshot as gh, DispatchUnit as gi, DeclaredCheck as gl, ToolLoopCompaction as gm, WorkerToolTraceArtifact as gn, equalKOnCost as go, SteerableSandboxSession as gp, ProvisionedSupervisor as gr, MaterializeLocalMcpOptions as gs, SandboxEvent$1 as gt, RUN_FORK_CORRELATION_KEYS as gu, WatchTraceOptions as gv, ExecutorCancellation as gx, SupervisorOpts as gy, OpenAIChatTool as h, BackendTransportError as hC, readBoundHarnessSessions as hS, RouteWhen as h_, visibleCheckScore as ha, ProviderModelAttemptEvidence as hb, CorpusFilter as hc, dumbContinuationFailPrompt as hd, CoordinationReadAccess as hf, createCodeModeTools as hg, UiFinding as hh, DispatchStopReason as hi, defineLeaderboard as hl, ToolLoopChat as hm, analyzeTrace as hn, createPrivateCasArtifactPort as ho, SteerableSandboxArgs as hp, ProvisionSupervisorRequest as hr, LocalMcpMaterialization as hs, ResourceRequest$1 as ht, PursuitFork as hu, createEventBus as hv, ExecutorAccounting as hx, Supervisor as hy, AgentExecutionBackend as i, RuntimeRunHandle as iC, captureHarnessTranscript as iS, ManagerWake as i_, compareCheckOutcomes as ia, NodeStatus as ib, Observation as ic, RunContext as id, UNPROVEN_CONTINUITY as if, createCodexRolloutStoreReader as ig, DelegationHistoryArgs as ih, graphRunsFor as ii, providerAsSandboxClient as il, mapSandboxEvent as im, withUntrackedArtifacts as in, reconnectRetainedInteractiveRun as io, createExecutor as ip, writeWorkerSteer as ir, superviseDispatch as is, AgentSessionStatus$1 as it, PursuitNodeUsage as iu, peerMailVerbNames as iv, ExecutorMaterialization as ix, ResultBlobStore as iy, DriverFailureClass as j, RetainedRunAdmission as jC, Iteration as jS, ContinuationInstruction as j_, strategyTournament as ja, SpawnForest as jb, ScopeAnalyst as jc, CoordinationToolFace as jd, ContinuationProfile as jf, renderLeaderboardSvg as jg, FileDelegationStoreOptions as jh, ChatTransportTool as ji, IsolatedCheckOutputEvidence as jl, FleetHandle as jm, assertSearchSpec as jn, CreateScopeAnalystOptions as jo, ROUTER_CLIENT_HEADER as jp, workerFromInteractiveProvider as jr, StrategyMessage as js, fsSurfaceReader as jt, GraphCommandCheck as ju, RunLocalHarnessOptions as jv, createPushTraceSource as jx, RuntimeStreamEventSink as jy, DriverAttemptStop as k, RetainedInteractiveIntentAdmission as kC, Driver as kS, AuthorizeDownMessage as k_, TournamentRow as ka, WorkerEventPage as kb, PipelineStage as kc, supervisorAgent as kd, ContinuationPanelResult as kf, renderLeaderboardHtml as kg, DelegationStore as kh, ChatSessionStore as ki, runIsolatedCheck as kl, detachedSessionDelegate as km, SearchSpecInputs as kn, verify as ko, SharedWorkerIdentity as kp, InteractiveWorkerOptions as kr, CorpusReadbackOptions as ks, WatchedSurface as kt, GraphCheckOutput as ku, CodexExecutionEvidence as kv, ToolStepInput as kx, RuntimeEventCollector as ky, AgentTaskRunResult as l, startRuntimeRun as lC, HarnessFileBinding as lS, GateRequest as l_, modelAuthoredChecks as la, SpawnRejection as lb, defaultAnalystInstruction as lc, PromptHandle as ld, SupervisorFinalizer as lf, CodeModeStore as lg, DelegationStatusResult as lh, recordGraphRun as li, LeaderboardFlagSpec as ll, sumSandboxUsage as lm, WorkspaceRun as ln, profileChatClient as lo, ProviderSeam as lp, RemoteSupervisorSteerResult as lr, inlineSandboxClient as ls, CreateAgentEnvironmentInput$1 as lt, projectPursuit as lu, McpTransport as lv, NodeExecutionIdentity as lx, RecursiveReservationPolicy as ly, OpenAIChatResponseFormat as m, AgentEvalErrorCode as mC, RetainedHarnessTranscriptDescriptor as mS, RouteMatch as m_, structuralRollout as ma, NoWinnerError as mb, Corpus as mc, delegatesWorkerBriefPrompt as md, CoordinationPublicAddress as mf, RunCodeModeOptions as mg, UiAuditorDelegationOutput as mh, DispatchReport as mi, LeaderboardSpec as ml, ToolLoopCallContext as mm, TrajectoryAnalysis as mn, PrivateCasOptions as mo, SandboxSteeringOptions as mp, ProvisionSupervisorConnection as mr, HttpMcpServerSpec as ms, PlacementInfo as mt, observerRecordDigest as mu, PublishOptions as mv, Executor as mx, SteerableRootHandle as my, AgentBackendContext as n, RuntimeRunCompleteInput as nC, ReadableEnvironment as nS, LeadMessage as n_, VisibleCheck as na, NodeId as nb, HarvestReport as nc, InMemoryRunContext as nd, ReentryContinuity as nf, CodexStoreDelta as ng, DelegationError as nh, graphFromStored as ni, ShapeRegistry as nl, SandboxToolPartState as nm, UntrackedCopyStats as nn, ClaimRetainedInteractiveControlOptions as no, createExecutorRegistry as np, supervisorRunsRoot as nr, loopCampaignDispatch as ns, AgentSession as nt, PursuitNodeProjection as nu, isPeerMailEnvelope as nv, ExecutionBindingReceipt as nx, InMemoryResultBlobStore as ny, AgentRuntimeEvent as o, RuntimeRunPersistenceAdapter as oC, persistHarnessTranscript as oS, WorkerWatchOptions as o_, defaultExtractCandidate as oa, Settled as ob, ObservationError as oc, createFileRunContext as od, DeliveredOutput as of, readCodexRolloutSession as og, DelegationProgress as oh, loadGraph as oi, LeaderboardBenchScore as ol, SandboxServedBackend as om, Shell as on, startRetainedInteractiveRun as oo, CliSeam as op, RemoteSupervisorCancelResult as or, TERMINAL_DECISIONS as os, AnalystFinding$1 as ot, PursuitRunProjection as ou, JsonRpcResponse as ov, MaterializedExecutionIdentity as ox, SpawnJournal as oy, KnowledgeReadinessDecision as p, AgentEvalError$1 as pC, RetainedHarnessTranscriptCapture as pS, RouteGate as p_, selectBestIndex as pa, FleetYield as pb, CombinatorShape as pc, createPromptRegistry as pd, CoordinationMcpHandle as pf, CodeModeToolset as pg, UiAuditLensFilter as ph, GraphTriggerBinding as pi, LeaderboardScore as pl, ToolSpec as pm, runInWorkspace as pn, PrivateCasOffloadReport as po, DEFAULT_SANDBOX_STEERING_MAX_TURNS as pp, connectRemoteSupervisorControl as pr, inProcessSandboxClient as ps, ForkRequest as pt, ObserverRecordKind as pu, EventBus as pv, EnvironmentTeardownReceipt as px, RootSignal as py, WorkerSpawnContext as q, LoopWinner as qS, PeerMailLimits as q_, S3PrivateCasStoreOptions as qa, ReservationTicket as qb, LoopShape as qc, NoProgressForOptions as qd, createMcpServer as qf, InPlaceHarnessResult as qg, deterministicCompletion as qh, CheckRunContext as qi, SupervisePursuitOptions as ql, SubmitInput as qm, WriteWorkerSteerOptions as qn, BenchmarkTaskRow as qo, KeyProvider as qp, GraphRegistryDir as qr, assertStrategyContract as qs, EVIDENCE_MAX_CHARS as qt, GraphRouteError as qu, readSpawnJournal as qv, StartRetainedInteractiveRunOptions as qx, Budget as qy, AgentBackendInput as r, RuntimeRunCost as rC, captureBoundHarnessTranscript as rS, ManagerReentryState as r_, canDisplace as ra, NodeSnapshot as rb, harvestCorpus as rc, InMemoryRunContextOptions as rd, ReentryTaskInput as rf, addHarnessUsage as rg, DelegationFeedbackSnapshot as rh, graphRegistry as ri, ProviderAsSandboxClientOptions as rl, createSandboxToolPartState as rm, copyUntrackedIntoClone as rn, claimRetainedInteractiveControl as ro, ExecutorConfig as rp, workerInboxFileFromEventDir as rr, loopDispatch as rs, AgentSessionRef as rt, PursuitNodeTiming as ru, peerMailTools as rv, ExecutorExecutionBinding as rx, InMemorySpawnJournal as ry, AgentRuntimeEventSink as s, RuntimeRunRow as sC, BoundHarnessSession as sS, DecideGate as s_, defaultStructuralRolloutPolicy as sa, SpawnOpts as sb, ObserveInput as sc, createInMemoryRunContext as sd, FinalizeContext as sf, HarnessUsage as sg, DelegationResultPayload as sh, lookupGraph as si, LeaderboardBenchTask as sl, SandboxUsageLedger as sm, Workspace as sn, ResolveSandboxClientOptions as so, CliWorktreeBridgeSeam as sp, RemoteSupervisorControl as sr, TerminalDecision as ss, CheckpointRef as st, PursuitRunTotals as su, McpToolAnnotations as sv, MaterializedModelIdentity as sx, TraceRootReceipt as sy, AgentAdapter as t, Validator as tC, HarnessTranscriptUnavailableReason as tS, EventAcknowledgement as t_, StructuralRolloutResult as ta, Handle as tb, HarvestFailure as tc, subscriptionUsageLimitSignal as td, plateau as tf, CodexRolloutTurn as tg, DelegateUiAuditRoute as th, graphDigest as ti, ShapeContext as tl, SandboxOutputMarker as tm, CopyOptions as tn, startRetainedRunInEnvironment as to, createDelegateHandler as tp, supervisorRunDir as tr, SuperviseOptionsForDispatch as ts, AgentProfile$2 as tt, PursuitNodePlatform as tu, createPeerMailbox as tv, AgentExecutionRef as tx, readRunCancellation as ty, AgentTaskSpec as u, contentAddress as uC, HarnessTranscriptMetadata as uS, JsonScalar as u_, officialChecksFromMeta as ua, SubtreeResult as ub, observe as uc, PromptRegistry as ud, bestDelivered as uf, CodeModeTool as ug, FeedbackRating as uh, recordStoredGraphRun as ui, LeaderboardIterationInfo as ul, RouterResponseReceipt as um, gitWorkspace as un, profileOptimizerModelCall as uo, RouterSeam as up, RemoteSupervisorTree as ur, InProcessOnPrompt as us, CreateSandboxOptions$1 as ut, FileObserverJournal as uu, BusEvent as uv, ProfileMaterializationReceipt as ux, RootHandle as uy, RunAgentTaskStreamOptions as v, NotFoundError as vC, ProviderWorkspaceAttemptProvenance as vS, Question as v_, AgentTurnUsage as va, RootStreamReceipt as vb, EqualKOnCostOptions as vc, kernelPromptRegistry as vd, CoordinationHttpAudit as vf, GroupOf as vg, UiLens as vh, freeSlots as vi, DeclaredCheckStateCapture as vl, ToolLoopMessageRecord as vm, DEFAULT_MAX_DEPTH as vn, definePersona as vo, AuthorityInboxMessage as vp, provisionSupervisor as vr, McpSpawnFault as vs, WorkspaceRequest as vt, superviseFleetCapabilities as vu, watchTrace as vv, ExecutorResult as vx, TraceContext as vy, RuntimeFailureCode as w, RecoverRetainedRunIntentOptions as wC, ExecutorToolCall as wS, QuestionOption as w_, EvolutionReport as wa, Scope as wb, LoopUntilState as wc, SupervisorSpanRecorder as wd, CheckRead as wf, PairwiseVerdict as wg, ResearcherProfileOptions as wh, graphDesignerExtraTools as wi, readDeclaredCheck as wl, CoderReviewer as wm, SqlRunContextOptions as wn, flatWidenGate as wo, DEFAULT_SHARED_BOX_WORKERS as wp, profileRegistry as wr, AgenticRunResult as ws, HarvestSurfaceDiffsOptions as wt, SuperviseTestOptions as wu, AnalystRunContext as wv, WorkerInteractiveSession as wx, OtelExporter as wy, RuntimeSessionStore as x, NativeContextContinuationHandle as xC, ProviderWorkspaceCaptureResult as xS, QuestionEscalationRecord as x_, collectAgentTurn as xa, ReenteredWorkers as xb, FanoutSynthesis as xc, SupervisorSpanAttributes as xd, CoordinationLog as xf, LeaderboardOptions as xg, ResearchOutput as xh, DesignerRunGraphEnv as xi, declaredCheckDeliverable as xl, FeedbackStore as xm, ValidateStoredGraphOptions as xn, InMemoryCorpus as xo, InboxMessage as xp, bestProfileFor as xr, connectStdioMcp as xs, VerifierEnvironmentOptions as xt, AuthorizedSpawn as xu, AnalystKind as xv, HeldForContinuation as xx, OtelAttribute as xy, RuntimeCanonicalStreamEvent as y, ValidationError as yC, ProviderWorkspaceCaptureProvenance as yS, QuestionDecision as y_, CollectedAgentTurn as ya, SupervisedResult as yb, EqualKVerdict as yc, naiveContinuationPrompt as yd, CoordinationRejectReason as yf, Interval as yg, KnowledgeItem as yh, queueOf as yi, assertDeclaredCheck as yl, ToolLoopToolCall as ym, createSupervisor as yn, runPersonified as yo, Inbox as yp, ProfileRegistryDir as yr, StdioMcpConnection as ys, computeFindingId$1 as yt, superviseWithTestBrain as yu, AnalystAssignmentRecord as yv, ExecutorTeardownWarning as yx, createPropagatingTraceEmitter as yy, MakeWorkerAgent as z, RetainedRunHandle as zC, LoopPlanPayload as zS, MapOnSettleRoute as z_, openSandboxRun as za, BudgetPoolRestore as zb, VerifySpec as zc, SupervisorAgentTestDeps as zd, ResolvedSpawnResourcePath as zf, plateauLength as zg, gateOnDeliverable as zh, asAuthoredProfile as zi, PursuitVersionStop as zl, DelegationArgs as zm, TRACE_SUMMARY_SCHEMA as zn, McpEnvironmentOptions as zo, ProviderLeafOut as zp, GraphFileResolutionError as zr, AuthorStrategyOptions as zs, WorktreeCliExecutorOptions as zt, GraphResult as zu, SqlAdapter as zv, createActivityLog as zx, DeadlineCheckIn as zy };
+//# sourceMappingURL=types-C_qbnw9N.d.ts.map