@tangle-network/agent-runtime 7.0.0 → 8.0.1

package/dist/{types-Jg274chm.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;
 } | {
@@ -3034,6 +3005,9 @@ interface RootStreamReceipt {
   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[];
 }
 /** An empty observation list is unknown served identity unless dispatch was proven not started. */
 interface ProviderModelAttemptEvidence {
@@ -3063,7 +3037,7 @@ interface NoWinnerError {
 }
 /** 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 remains root-tree scoped. */
+ * down includes released retained children. spendGaps and tree read the whole forest (#1189). */
 interface FleetYield {
   /** Spawned children; excludes root and synthetic owned-tree root copies. */
   readonly spawned: number;
@@ -3175,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
@@ -3463,72 +3437,36 @@ 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}`;
@@ -3553,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>;
@@ -4071,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?: {
@@ -8930,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;
@@ -9638,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
@@ -9881,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.
@@ -10440,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 {
@@ -11208,1152 +11102,1217 @@ 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>);
+}
+/** 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;
+} |
 /**
- * The name→value tables that make the three CODE-valued options expressible as run DATA, and the
- * profiles a director may spawn by name.
+ * 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.
  *
- * `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.
+ * 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.
  *
- * `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`.
+ * 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
-   *  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: {
-    readonly profile: AgentProfile;
-    readonly parent: AgentProfile;
-    /** Trusted identity of the manager authorizing this exact child. */
-    readonly parentIdentity: NodeExecutionIdentity;
-    /** Concrete manager node; never accepted from model-authored tool arguments. */
-    readonly parentNodeId: string;
-    /** Stable manager-scoped assignment, including deterministic unkeyed siblings. */
-    readonly assignmentId: string;
+  /** 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;
-    readonly budget: Budget;
-    readonly label: string;
-    readonly key?: string;
-    readonly depth: number;
-    /** Present (as the analyst id) only when the runtime's analyst-on-settle hook initiated this
-     *  spawn — authored by the runtime, never accepted from a driver's tool arguments. A node-pinning
-     *  authority reads it to admit the analyst node it would refuse as a driver-authored spawn. */
-    readonly analyst?: string;
-    /** Present only when a map route started this spawn — authored by the runtime, never accepted
-     *  from tool arguments. A node-pinning authority reads it to admit the map's item or join. */
-    readonly map?: MapSpawnMarker;
-    /** Present only when a flow's entry or routes edge started this spawn — authored by the
-     *  runtime, never accepted from tool arguments. A node-pinning authority reads it to admit the
-     *  node the edge names. */
-    readonly route?: RouteSpawnMarker;
-    /** The EFFECTIVE continuity of this spawn, resolved by the coordination layer. */
-    readonly continuity?: ContinuityMode;
-  }) => AuthorizedSpawn;
-  /** Product authority over every continuation sent to a live child. When spawn authorization is
-   * enabled, omitting this refuses steer/answer instructions instead of silently extending the
-   * authorized task. The exact worker identity and detached bytes are recorded before delivery. */
-  readonly authorizeMessage?: (input: DownMessageAuthorizationInput & {
-    readonly parent: AgentProfile;
-    readonly depth: number;
-  }) => AuthorizedDownMessage;
-  /** The supervisor's router substrate (`profile.harness` omitted or `cli-base`). The profile's
-   *  model wins. */
-  readonly router?: RouterTransportConfig;
-  /** When `driverBackend` is absent, whether an external-harness ROOT may default to running on
-   *  `backend` (where workers run). `true` (default) keeps the convenience every direct caller has.
-   *  Rooted `runGraph` calls set `false`, so an external root needs an explicit `driverBackend`.
-   *  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. */
-  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,
-   *  then model guidance, then the profile's own text into the root profile and into every
-   *  profile a manager spawns, before identity is fixed, so receipts bind the prompt that ran.
-   *  Omit to run profiles exactly as authored: Runtime selects no standing guidance by itself. */
-  readonly profileGuidance?: 'profile-kb';
-  /** Whether a spawned profile that declares no Runtime coordination tool receives its manager's
-   *  coordination grants (`spawn_worker`, `observe_agent`, and the rest, plus `submit_result` so it
-   *  can still deliver work it does itself), so every child can lead children of its own. Default
-   *  `true`. A child whose author wrote any coordination entry, true or false, keeps what was
-   *  written (a `false` entry is dropped once it has kept the child a leaf). A child this run
-   *  cannot drive as a manager (no driver for its harness, or no `router` for a harness-less one)
-   *  stays a leaf, and so does every child of a run with no completion check (`deliverable` or
-   *  `resolveDeliverable`), since a manager delivers its own work only through `submit_result`.
-   *  `false` runs every authored profile exactly as written. Applies to backend-derived workers;
-   *  a caller-owned `makeWorkerAgent` decides its own children. */
-  readonly inheritSpawnRights?: boolean;
-  /** The graph registry directory (`graph-registry`) whose stored graphs a manager's `run_graph`
-   *  may start by `graphDigest`. Omit and `run_graph` takes graphs as data only. */
-  readonly graphRegistry?: string;
-  /** The directive registry a graph subtask (a manager's `run_graph`, and a `maps` edge's `graph`
-   *  item) resolves its edge directives against. `runGraph` passes its own `registry`, so a nested
-   *  flow reads the directives of the graph that started it. Omit and subtasks resolve against the
-   *  seeded kernel registry. */
-  readonly promptRegistry?: PromptRegistry;
-  /** Run an external-harness supervisor explicitly. Required for a remote sandbox; optional as a
-   *  caller-owned override for a local bridge. */
-  readonly driveHarness?: DriveHarness;
-  /**
-   * How hard a transiently-failed EXTERNAL driver is re-entered before the run ends
-   * `driver-failed`. A harness process SIGKILLed at a bridge timeout, a stream cut mid-turn, or an
-   * upstream 5xx used to end a run of arbitrary length while its budget and deadline sat almost
-   * untouched (#741). A retry re-enters the driver over the SAME scope, coordination server, and
-   * live children; the bridge backend reattaches the harness session by its durable execution id.
-   *
-   * Runtime's own refusals (a validation guard, an exhausted budget, an abort, a client-side
-   * transport status) are never retried — they were decisions. Retries stop at the budget, the
-   * deadline, an abort, or a run of attempts that changed nothing at all.
-   *
-   * Omit = retry under the defaults. `{ enabled: false }` = the historical behavior where the first
-   * driver failure ends the run. Applies to the root manager and every recursive manager under it.
-   *
-   * `driverRetry.pauseRootStops: true` pauses recoverable ROOT stops: no progress, attempt ceilings,
-   * repeated failure, unresolved pending work and spent budget. Each journals one `paused` row
-   * (`replacesStop`, `streak`, `resumeAt`) and waits 5 minutes, doubling to 60. Terminal refusals,
-   * completion, cancellation and declared deadlines still end the run. A root steer ends any pause;
-   * a pool still spent pauses again. Nested managers keep their stops and settle `down` for their
-   * parent. Refused with `driverRetry.enabled: false`. Default off.
-   */
-  readonly driverRetry?: DriverRetryPolicy;
-  /** Per-attempt record for every external driver in the tree — what makes "failed after N
-   *  attempts, last cause X" visible instead of one backend's last words. */
-  readonly onDriverAttempt?: (record: DriverAttemptRecord) => void | Promise<void>;
-  /**
-   * How an EXTERNAL-harness manager with a completion check is sent back when its turn ends with
-   * the check unmet: `maxBarren`, an optional deadline, and the continuation note's profile and
-   * switches.
-   *
-   * A harness owns its own turn loop, so it decides when it is finished — and it can decide that
-   * while the run has produced nothing. Measured on discovery-lab (n = 1,422 settled
-   * runs): 376 of 376 winning runs ended on the driver's own completion, and the completion gate
-   * could only LABEL an undelivered result `valid:false`, never send the driver back for it. By
-   * 2026-09-24, 650 recorded inputs had chosen seven different re-prompt counts, and the note the
-   * director heard held no line of the check's verdict.
-   *
-   * A continuation is the retry path, not a second loop: same scope, same coordination server,
-   * same live children, and the same budget, deadline, and abort bounds. There is no count: the
-   * loop ends when the check passes, on cancellation, on the budget, or at this deadline when one
-   * is set; with none, no clock ends the run. After
-   * `maxBarren` turns in a row without progress, each further continuation waits a barren pause
-   * first, journaled `barren-pause`. A turn that ends, a blocked tool, and a lost
-   * stream are segment boundaries, never the end of the run. Runtime writes the note from the check's verdict (`src/runtime/supervise/continuation.ts`); the
-   * profile owns its words, and `append` may add a section but never replace one.
-   *
-   * Required with `deliverable` (or `resolveDeliverable`) for an external manager, and applied to
-   * every external manager with a completion check in the tree. Refused for a router-brained
-   * manager, which runs its turn loop in process.
-   */
-  readonly continuation?: ContinuationPolicy;
-  /**
-   * How long live children may keep running after the root driver returns or fails, before the join
-   * barrier cascades the abort into them. `null` waits until children settle or the caller cancels.
-   * An explicit run deadline always wins. Omit/`0` = immediate teardown.
-   */
-  readonly childSettleGraceMs?: number | null;
-  /**
-   * How long settlement keeps retrying a child teardown the executor has not confirmed, with
-   * exponential backoff, before naming the child in `teardownUnconfirmed` with the provider
-   * environment ids a sweeper deletes. `0` makes one attempt only. Default: 300000 (5 minutes).
-   * See `SupervisorOpts.teardownConfirmMs`.
-   */
-  readonly teardownConfirmMs?: number;
-  /**
-   * What root settlement does with provider environments that settled children still hold for a
-   * retained execution: `'release'` them with one `environment-teardown` receipt each and close
-   * each released child's cursor slot with a terminal record marked `retainedExecution:
-   * 'released'`, or `'keep'` them for a later call that resumes this run. Default: `'keep'` with
-   * `runDir` (re-running the same `runDir` and `runId` resumes), `'release'` without it (nothing
-   * can resume an in-memory run). See `SupervisorOpts.retainedAtSettlement`.
-   */
-  readonly retainedAtSettlement?: 'release' | 'keep';
-  /** Resolve one custom external-harness session per trusted manager identity. Use this instead of
-   * `driveHarness` when recursive managers must be independently steerable. */
-  readonly resolveDriveHarness?: ResolveDriveHarness;
-  /** Required with a custom `driveHarness` or `resolveDriveHarness`: declares which complete
-   * AgentProfile axes that path really applies. Built-in bridge driving supplies its own
-   * full-profile contract. */
-  readonly driveHarnessMaterialization?: ProfileMaterializationContract;
-  /** Resolve product-owned tools from the exact trusted manager context. The same descriptors and
-   * handlers are bound to router and external-harness managers; resolution happens once per node.
-   * Each handler receives that manager scope's live cancellation signal in its trusted invocation
-   * context, including recursive parent and root cascades, plus `context.verbs` — that manager's
-   * own coordination verbs, callable in code so a product tool can COMPOSE its children (fan out,
-   * chain, join, retry) in one tool call instead of one model turn per verb. Every verb crosses
-   * the same authorizeSpawn / security / allowedModels gate, pool reservation, worker-slot
-   * queue, journal, and bus the MCP verb crosses, at every depth and on both arms. */
-  readonly resolveSupervisorTools?: ResolveSupervisorTools;
-  /**
-   * Where an `ask_parent` question goes when it leaves a manager (see {@link EscalateQuestion}).
-   *
-   * Installed on EVERY manager of the run, at every depth, so a driver's escalation reaches the
-   * product's own inbox — a UI, an operator queue, a human. Omit and every manager reports
-   * `outcome: 'no-parent'` on `ask_parent`, which is the honest reading when nothing above it is
-   * listening: the runtime routes no question to a parent by itself.
-   */
-  readonly escalateQuestion?: EscalateQuestion;
-  /** Awaited product transaction hook for every coordination record. `eventId` is stable across a
-   * lost acknowledgement and durable restart; the record is not pull-visible until this commits. */
-  readonly onCoordinationEvent?: (context: SupervisorNodeContext, eventId: Sha256Digest, record: BusRecord<CoordinationEvent>) => void | Promise<void>;
-  /** WORK tools the supervisor may call DIRECTLY — so a recursive atom can ACT (do simple work
-   *  itself) OR SPAWN (delegate when it needs parallelism), not be a pure manager. Pair with
-   *  `executeExtraTool`. Router arm only (`profile.harness` omitted or `cli-base`). */
-  readonly extraTools?: ReadonlyArray<{
-    readonly name: string;
-    readonly description?: string;
-    readonly parameters: Record<string, unknown>;
   }>;
-  /** Runs an `extraTools` call; null/undefined falls through to the coordination dispatch. */
-  readonly executeExtraTool?: (name: string, args: Record<string, unknown>) => Promise<string | null | undefined>;
-  /** The root's default slice for a child whose manager names no `budget`. Defaults to a quarter
-   *  of the part of the pool children may reserve (the pool less any owner share). A nested
-   *  manager always divides its own slice that way; `spawn_worker`'s `budget` overrides per spawn. */
-  readonly perWorker?: Budget;
-  /** Opt-in owner share: every manager, the root included, keeps this fraction of its own slice
-   *  free of its children's reservations, so its own turns keep budget. Default slices shrink to fit
-   *  beside it. Default: off. */
-  readonly reservationPolicy?: RecursiveReservationPolicy;
-  /** What a child's own time box (a `spawn_worker` `budget.deadlineMs`) does. Default: a check-in;
-   *  the child is told to save its state and submit what it has, and is stopped only once it then
-   *  makes no progress for 30 min. `false` stops it at the time box. The run's own deadline always
-   *  stops every node. See `deadline.ts` `DeadlineCheckIn`. */
-  readonly deadlineCheckIn?: DeadlineCheckIn;
-  /** How long a keyed worker whose turn ended over its budget keeps its environment for a
-   *  `spawn_worker` of the same key with a larger budget to continue the same session (ms).
-   *  Default 600,000; `0` keeps none. Released earlier by `cancel_worker` or the run's end. */
-  readonly budgetStopHoldMs?: number;
-  /** Bound on concurrently WORKING agents across the whole recursive tree: a number, or one
-   *  `createWorkerSlots` allocator that several runs in this process share. A spawn past it keeps
-   *  its budget slice and waits in a queue (deepest first) instead of being refused, and a manager
-   *  lends its slot to its first running child, so nested waits cannot deadlock. The root holds no
-   *  slot. Omit/`<= 0` = no bound (the conserved pool stays the only bound). */
-  readonly workerSlots?: number | WorkerSlots;
-  /** Analyst lenses available to the driver. Required for `analyzeOnSettle`. Unset → status quo
-   *  (the driver receives settled worker outputs, no analyst findings). A `string` names an entry in
-   *  `registry.analysts`. */
-  readonly analysts?: AnalystRegistry$1 | string;
-  /** Analyst kind ids run AUTOMATICALLY when a worker settles `done` — each re-enters as a `finding`
-   *  the driver receives in its next wake and composes its next steer from. The self-improving UP-leg,
-   *  threaded to the driver at this level (propagate to sub-drivers via a recursive `makeWorkerAgent`).
-   *  Omit/empty = status quo (no analyst feed). Requires `analysts`. */
-  readonly analyzeOnSettle?: ReadonlyArray<string | AnalyzeOnSettleRoute>;
-  /** Maps the runtime expands when their source worker settles: fan-out over a list in the
-   *  source's result, then one join. An AgentGraph's `maps` edges set it; see `MapOnSettleRoute`.
-   *  Omit = none. */
-  readonly mapOnSettle?: ReadonlyArray<MapOnSettleRoute>;
-  /** 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;
-  /** 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.
+  /** 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()`).
    *
-   * 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. */
+   *  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;
-  /**
-   * 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 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;
   };
-  /** 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`.
-   *
-   * 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;
+/** `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;
 }
-/** 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;
+/**
+ * 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;
 }
-/** 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;
+/** 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[];
 }
 /**
- * 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.
+ * The name→value tables that make the three CODE-valued options expressible as run DATA, and the
+ * profiles a director may spawn by name.
  *
- * `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.
+ * `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.
  *
- * 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.
+ * `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`.
  */
-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;
+interface SuperviseRegistry {
+  readonly deliverables?: SuperviseRegistryTable<DeliverableSpec<unknown>>;
+  readonly finalizers?: SuperviseRegistryTable<SupervisorFinalizer>;
+  readonly analysts?: SuperviseRegistryTable<AnalystRegistry$1>;
+  readonly profiles?: SuperviseRegistryTable<SuperviseProfileEntry> & {
+    names(): readonly string[];
   };
-}>;
-/** 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;
+}
+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>;
   };
-}>;
-/**
- * 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;
+  /** 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: {
+    readonly profile: AgentProfile;
+    readonly parent: AgentProfile;
+    /** Trusted identity of the manager authorizing this exact child. */
+    readonly parentIdentity: NodeExecutionIdentity;
+    /** Concrete manager node; never accepted from model-authored tool arguments. */
+    readonly parentNodeId: string;
+    /** Stable manager-scoped assignment, including deterministic unkeyed siblings. */
+    readonly assignmentId: string;
+    readonly task: unknown;
+    readonly budget: Budget;
+    readonly label: string;
+    readonly key?: string;
+    readonly depth: number;
+    /** Present (as the analyst id) only when the runtime's analyst-on-settle hook initiated this
+     *  spawn — authored by the runtime, never accepted from a driver's tool arguments. A node-pinning
+     *  authority reads it to admit the analyst node it would refuse as a driver-authored spawn. */
+    readonly analyst?: string;
+    /** Present only when a map route started this spawn — authored by the runtime, never accepted
+     *  from tool arguments. A node-pinning authority reads it to admit the map's item or join. */
+    readonly map?: MapSpawnMarker;
+    /** Present only when a flow's entry or routes edge started this spawn — authored by the
+     *  runtime, never accepted from tool arguments. A node-pinning authority reads it to admit the
+     *  node the edge names. */
+    readonly route?: RouteSpawnMarker;
+    /** The EFFECTIVE continuity of this spawn, resolved by the coordination layer. */
+    readonly continuity?: ContinuityMode;
+  }) => AuthorizedSpawn;
+  /** Product authority over every continuation sent to a live child. When spawn authorization is
+   * enabled, omitting this refuses steer/answer instructions instead of silently extending the
+   * authorized task. The exact worker identity and detached bytes are recorded before delivery. */
+  readonly authorizeMessage?: (input: DownMessageAuthorizationInput & {
+    readonly parent: AgentProfile;
+    readonly depth: number;
+  }) => AuthorizedDownMessage;
+  /** The supervisor's router substrate (`profile.harness` omitted or `cli-base`). The profile's
+   *  model wins. */
+  readonly router?: RouterTransportConfig;
+  /** When `driverBackend` is absent, whether an external-harness ROOT may default to running on
+   *  `backend` (where workers run). `true` (default) keeps the convenience every direct caller has.
+   *  Rooted `runGraph` calls set `false`, so an external root needs an explicit `driverBackend`.
+   *  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: 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,
+   *  then model guidance, then the profile's own text into the root profile and into every
+   *  profile a manager spawns, before identity is fixed, so receipts bind the prompt that ran.
+   *  Omit to run profiles exactly as authored: Runtime selects no standing guidance by itself. */
+  readonly profileGuidance?: 'profile-kb';
+  /** Whether a spawned profile that declares no Runtime coordination tool receives its manager's
+   *  coordination grants (`spawn_worker`, `observe_agent`, and the rest, plus `submit_result` so it
+   *  can still deliver work it does itself), so every child can lead children of its own. Default
+   *  `true`. A child whose author wrote any coordination entry, true or false, keeps what was
+   *  written (a `false` entry is dropped once it has kept the child a leaf). A child this run
+   *  cannot drive as a manager (no driver for its harness, or no `router` for a harness-less one)
+   *  stays a leaf, and so does every child of a run with no completion check (`deliverable` or
+   *  `resolveDeliverable`), since a manager delivers its own work only through `submit_result`.
+   *  `false` runs every authored profile exactly as written. Applies to backend-derived workers;
+   *  a caller-owned `makeWorkerAgent` decides its own children. */
+  readonly inheritSpawnRights?: boolean;
+  /** The graph registry directory (`graph-registry`) whose stored graphs a manager's `run_graph`
+   *  may start by `graphDigest`. Omit and `run_graph` takes graphs as data only. */
+  readonly graphRegistry?: string;
+  /** The directive registry a graph subtask (a manager's `run_graph`, and a `maps` edge's `graph`
+   *  item) resolves its edge directives against. `runGraph` passes its own `registry`, so a nested
+   *  flow reads the directives of the graph that started it. Omit and subtasks resolve against the
+   *  seeded kernel registry. */
+  readonly promptRegistry?: PromptRegistry;
+  /** Run an external-harness supervisor explicitly. Required for a remote sandbox; optional as a
+   *  caller-owned override for a local bridge. */
+  readonly driveHarness?: DriveHarness;
+  /**
+   * How hard a transiently-failed EXTERNAL driver is re-entered before the run ends
+   * `driver-failed`. A harness process SIGKILLed at a bridge timeout, a stream cut mid-turn, or an
+   * upstream 5xx used to end a run of arbitrary length while its budget and deadline sat almost
+   * untouched (#741). A retry re-enters the driver over the SAME scope, coordination server, and
+   * live children; the bridge backend reattaches the harness session by its durable execution id.
+   *
+   * Runtime's own refusals (a validation guard, an exhausted budget, an abort, a client-side
+   * transport status) are never retried — they were decisions. Retries stop at the budget, the
+   * deadline, an abort, or a run of attempts that changed nothing at all.
+   *
+   * Omit = retry under the defaults. `{ enabled: false }` = the historical behavior where the first
+   * driver failure ends the run. Applies to the root manager and every recursive manager under it.
+   *
+   * `driverRetry.pauseRootStops: true` pauses recoverable ROOT stops: no progress, attempt ceilings,
+   * repeated failure, unresolved pending work and spent budget. Each journals one `paused` row
+   * (`replacesStop`, `streak`, `resumeAt`) and waits 5 minutes, doubling to 60. Terminal refusals,
+   * completion, cancellation and declared deadlines still end the run. A root steer ends any pause;
+   * a pool still spent pauses again. Nested managers keep their stops and settle `down` for their
+   * parent. Refused with `driverRetry.enabled: false`. Default off.
+   */
+  readonly driverRetry?: DriverRetryPolicy;
+  /** Per-attempt record for every external driver in the tree — what makes "failed after N
+   *  attempts, last cause X" visible instead of one backend's last words. */
+  readonly onDriverAttempt?: (record: DriverAttemptRecord) => void | Promise<void>;
+  /**
+   * How an EXTERNAL-harness manager with a completion check is sent back when its turn ends with
+   * the check unmet: `maxBarren`, an optional deadline, and the continuation note's profile and
+   * switches.
+   *
+   * A harness owns its own turn loop, so it decides when it is finished — and it can decide that
+   * while the run has produced nothing. Measured on discovery-lab (n = 1,422 settled
+   * runs): 376 of 376 winning runs ended on the driver's own completion, and the completion gate
+   * could only LABEL an undelivered result `valid:false`, never send the driver back for it. By
+   * 2026-09-24, 650 recorded inputs had chosen seven different re-prompt counts, and the note the
+   * director heard held no line of the check's verdict.
+   *
+   * A continuation is the retry path, not a second loop: same scope, same coordination server,
+   * same live children, and the same budget, deadline, and abort bounds. There is no count: the
+   * loop ends when the check passes, on cancellation, on the budget, or at this deadline when one
+   * is set; with none, no clock ends the run. After
+   * `maxBarren` turns in a row without progress, each further continuation waits a barren pause
+   * first, journaled `barren-pause`. A turn that ends, a blocked tool, and a lost
+   * stream are segment boundaries, never the end of the run. Runtime writes the note from the check's verdict (`src/runtime/supervise/continuation.ts`); the
+   * profile owns its words, and `append` may add a section but never replace one.
+   *
+   * Required with `deliverable` (or `resolveDeliverable`) for an external manager, and applied to
+   * every external manager with a completion check in the tree. Refused for a router-brained
+   * manager, which runs its turn loop in process.
+   */
+  readonly continuation?: ContinuationPolicy;
+  /**
+   * How long live children may keep running after the root driver returns or fails, before the join
+   * barrier cascades the abort into them. `null` waits until children settle or the caller cancels.
+   * An explicit run deadline always wins. Omit/`0` = immediate teardown.
+   */
+  readonly childSettleGraceMs?: number | null;
+  /**
+   * How long settlement keeps retrying a child teardown the executor has not confirmed, with
+   * exponential backoff, before naming the child in `teardownUnconfirmed` with the provider
+   * environment ids a sweeper deletes. `0` makes one attempt only. Default: 300000 (5 minutes).
+   * See `SupervisorOpts.teardownConfirmMs`.
+   */
+  readonly teardownConfirmMs?: number;
+  /**
+   * What root settlement does with provider environments that settled children still hold for a
+   * retained execution: `'release'` them with one `environment-teardown` receipt each and close
+   * each released child's cursor slot with a terminal record marked `retainedExecution:
+   * 'released'`, or `'keep'` them for a later call that resumes this run. Default: `'keep'` with
+   * `runDir` (re-running the same `runDir` and `runId` resumes), `'release'` without it (nothing
+   * can resume an in-memory run). See `SupervisorOpts.retainedAtSettlement`.
+   */
+  readonly retainedAtSettlement?: 'release' | 'keep';
+  /** Resolve one custom external-harness session per trusted manager identity. Use this instead of
+   * `driveHarness` when recursive managers must be independently steerable. */
+  readonly resolveDriveHarness?: ResolveDriveHarness;
+  /** Required with a custom `driveHarness` or `resolveDriveHarness`: declares which complete
+   * AgentProfile axes that path really applies. Built-in bridge driving supplies its own
+   * full-profile contract. */
+  readonly driveHarnessMaterialization?: ProfileMaterializationContract;
+  /** Resolve product-owned tools from the exact trusted manager context. The same descriptors and
+   * handlers are bound to router and external-harness managers; resolution happens once per node.
+   * Each handler receives that manager scope's live cancellation signal in its trusted invocation
+   * context, including recursive parent and root cascades, plus `context.verbs` — that manager's
+   * own coordination verbs, callable in code so a product tool can COMPOSE its children (fan out,
+   * chain, join, retry) in one tool call instead of one model turn per verb. Every verb crosses
+   * the same authorizeSpawn / security / allowedModels gate, pool reservation, worker-slot
+   * queue, journal, and bus the MCP verb crosses, at every depth and on both arms. */
+  readonly resolveSupervisorTools?: ResolveSupervisorTools;
+  /**
+   * Where an `ask_parent` question goes when it leaves a manager (see {@link EscalateQuestion}).
+   *
+   * Installed on EVERY manager of the run, at every depth, so a driver's escalation reaches the
+   * product's own inbox — a UI, an operator queue, a human. Omit and every manager reports
+   * `outcome: 'no-parent'` on `ask_parent`, which is the honest reading when nothing above it is
+   * listening: the runtime routes no question to a parent by itself.
+   */
+  readonly escalateQuestion?: EscalateQuestion;
+  /** Awaited product transaction hook for every coordination record. `eventId` is stable across a
+   * lost acknowledgement and durable restart; the record is not pull-visible until this commits. */
+  readonly onCoordinationEvent?: (context: SupervisorNodeContext, eventId: Sha256Digest, record: BusRecord<CoordinationEvent>) => void | Promise<void>;
+  /** WORK tools the supervisor may call DIRECTLY — so a recursive atom can ACT (do simple work
+   *  itself) OR SPAWN (delegate when it needs parallelism), not be a pure manager. Pair with
+   *  `executeExtraTool`. Router arm only (`profile.harness` omitted or `cli-base`). */
+  readonly extraTools?: ReadonlyArray<{
+    readonly name: string;
+    readonly description?: string;
+    readonly parameters: Record<string, unknown>;
+  }>;
+  /** Runs an `extraTools` call; null/undefined falls through to the coordination dispatch. */
+  readonly executeExtraTool?: (name: string, args: Record<string, unknown>) => Promise<string | null | undefined>;
+  /** The root's default slice for a child whose manager names no `budget`. Defaults to a quarter
+   *  of the part of the pool children may reserve (the pool less any owner share). A nested
+   *  manager always divides its own slice that way; `spawn_worker`'s `budget` overrides per spawn. */
+  readonly perWorker?: Budget;
+  /** Opt-in owner share: every manager, the root included, keeps this fraction of its own slice
+   *  free of its children's reservations, so its own turns keep budget. Default slices shrink to fit
+   *  beside it. Default: off. */
+  readonly reservationPolicy?: RecursiveReservationPolicy;
+  /** What a child's own time box (a `spawn_worker` `budget.deadlineMs`) does. Default: a check-in;
+   *  the child is told to save its state and submit what it has, and is stopped only once it then
+   *  makes no progress for 30 min. `false` stops it at the time box. The run's own deadline always
+   *  stops every node. See `deadline.ts` `DeadlineCheckIn`. */
+  readonly deadlineCheckIn?: DeadlineCheckIn;
+  /** How long a keyed worker whose turn ended over its budget keeps its environment for a
+   *  `spawn_worker` of the same key with a larger budget to continue the same session (ms).
+   *  Default 600,000; `0` keeps none. Released earlier by `cancel_worker` or the run's end. */
+  readonly budgetStopHoldMs?: number;
+  /** Bound on concurrently WORKING agents across the whole recursive tree: a number, or one
+   *  `createWorkerSlots` allocator that several runs in this process share. A spawn past it keeps
+   *  its budget slice and waits in a queue (deepest first) instead of being refused, and a manager
+   *  lends its slot to its first running child, so nested waits cannot deadlock. The root holds no
+   *  slot. Omit/`<= 0` = no bound (the conserved pool stays the only bound). */
+  readonly workerSlots?: number | WorkerSlots;
+  /** Analyst lenses available to the driver. Required for `analyzeOnSettle`. Unset → status quo
+   *  (the driver receives settled worker outputs, no analyst findings). A `string` names an entry in
+   *  `registry.analysts`. */
+  readonly analysts?: AnalystRegistry$1 | string;
+  /** Analyst kind ids run AUTOMATICALLY when a worker settles `done` — each re-enters as a `finding`
+   *  the driver receives in its next wake and composes its next steer from. The self-improving UP-leg,
+   *  threaded to the driver at this level (propagate to sub-drivers via a recursive `makeWorkerAgent`).
+   *  Omit/empty = status quo (no analyst feed). Requires `analysts`. */
+  readonly analyzeOnSettle?: ReadonlyArray<string | AnalyzeOnSettleRoute>;
+  /** Maps the runtime expands when their source worker settles: fan-out over a list in the
+   *  source's result, then one join. An AgentGraph's `maps` edges set it; see `MapOnSettleRoute`.
+   *  Omit = none. */
+  readonly mapOnSettle?: ReadonlyArray<MapOnSettleRoute>;
+  /** 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;
   /**
-   * 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
@@ -13003,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. */
@@ -15310,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 */
@@ -16379,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. */
@@ -16605,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]>;
@@ -16655,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;
@@ -17078,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;
@@ -18148,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 {
@@ -18161,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. */
@@ -18182,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. */
@@ -18378,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;
   /**
@@ -18490,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>;
@@ -18646,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;
@@ -18707,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;
@@ -18777,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';
 /**
@@ -19468,5 +19390,5 @@ interface KnowledgeReadinessDecision {
   blockingGapIds: string[];
   nonBlockingGapIds: string[];
 }
-export { AgentEnvironmentStatus as $, RuntimeRunStatus as $S, McpToolAnnotations as $_, startRetainedRunInEnvironment as $a, MaterializedModelIdentity 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, TraceRootReceipt as $v, HARNESS_TRANSCRIPT_READ_LIMITS as $x, SpawnOpts as $y, DriverContinuationRecord as A, RetainedRunHandle as AC, LoopPlanPayload as AS, MapItemFailurePolicy as A_, Deliverable as Aa, BudgetPool 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, createActivityLog as Ax, sanitizeKnowledgeReadinessReport as Ay, PeerAuditAccess as B, MountRecorder as BS, PeerMailOutcome as B_, createSandboxLineage as Ba, ReserveOptions 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, FileSpawnJournal as Bv, HarnessTranscriptArtifact as Bx, BudgetOverspend as By, RuntimeFailureCause as C, RetainedRunAdmissionHook as CC, LoopDecisionPayload as CS, ContinuationInstruction as C_, EvolutionStrategy as Ca, SpawnForest 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, ActivityLog as Cx, RuntimeStreamEventSink as Cy, RetainedPendingCause as D, RetainedRunEffect as DC, LoopIterationStartedPayload as DS, DownMessageDeliveryOutcome as D_, TournamentRow as Da, SpawnForestNode 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, ScopeProgressInput as Dx, SanitizedKnowledgeRequirement as Dy, EvidencePendingEvent as E, RetainedRunDispatchedAdmission as EC, LoopIterationEndedPayload as ES, DownMessageDeliveryAttempt as E_, TournamentCell as Ea, SpawnForestMissingTree 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, ExecutorProgress as Ex, SanitizedKnowledgeReadinessReport as Ey, CoordinationTools as F, RetainedRunTurnInput as FC, LoopTokenUsage as FS, DEFAULT_PEER_MAIL_LIMITS as F_, SandboxRunAbortError as Fa, ReservationHolder 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, SpawnJournalCursor as Fv, RetainedInteractiveEnvironmentInput as Fx, RunParkedError as Fy, SpawnRefusalCause as G, ValidationCtx as GS, PeerMailboxOptions as G_, S3PrivateCasStoreOptions as Ga, ExecutorRegistry 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, cancelRun as Gv, HarnessTranscriptUnavailable as Gx, SpendChannel as Gy, SpawnPreflight as H, RunProvenance as HS, PeerMailRefusal as H_, AcquireOptions as Ha, AgentSpec 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, readRunState as Hv, HarnessTranscriptCapture as Hx, ResourceLimit as Hy, CoordinationToolsOptions as I, StartRetainedRunInEnvironmentOptions as IC, LoopTraceEmitter as IS, PEER_MAIL_WIRE_KEY as I_, TurnResult as Ia, ReservationRejection 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, SpawnJournalReadOptions as Iv, RetainedInteractiveRunHandle as Ix, RunParkingPolicy as Iy, AgentEnvironment$1 as J, RuntimeRunCost as JS, isPeerMailEnvelope as J_, PrivateCasNamespaceObject as Ja, ExecutionBindingReceipt 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, InMemoryResultBlobStore as Jv, captureBoundHarnessTranscript as Jx, NodeId as Jy, SuperviseProfileEntry as K, Validator as KS, claimsAuthority as K_, createS3PrivateCasStore as Ka, SpawnModelSubstitution 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, readRunCancelRequest as Kv, HarnessTranscriptUnavailableReason as Kx, SpendGap as Ky, GraphSubtaskPreparation as L, StartRetainedRunOptions as LC, LoopTraceEvent as LS, PeerMailEnvelope as L_, openSandboxRun as La, ReservationShortfall 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, SpawnJournalReadRecord as Lv, RetainedInteractiveStartMaterial as Lx, RunParkingRecord as Ly, DriverRepromptRefusal as M, RetainedRunReplayPoint as MC, LoopSandboxPlacement as MS, MapSpawnMarker as M_, OpenSandboxRunOptions as Ma, BudgetReadout 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, ReconnectRetainedInteractiveRunOptions as Mx, WorkerSlots as My, BlockedToolReport as N, RetainedRunSnapshot as NC, LoopStartedPayload as NS, MapTraversalEvent as N_, OpenSandboxRunPromptOptions as Na, LeakedReservation 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, FileResultBlobStore as Nv, RecoverRetainedInteractiveRunOptions as Nx, createWorkerSlots as Ny, DriverAttemptRecord as O, RetainedRunEnvironmentAdmission as OC, LoopLineageOptions as OS, DownMessageEvent as O_, runStrategyEvolution as Oa, SpawnForestTree 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, TeamProgress as Ox, createRuntimeEventCollector as Oy, CoordinationStats as P, RetainedRunStartMaterial as PC, LoopTeardownFailedPayload as PS, AUTHORITY_MARKERS as P_, SandboxRun as Pa, ReservationFloor 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, replaySpawnTree as Pv, RetainedInteractiveAdmissionHook as Px, ParkedRun as Py, AgentEnvironmentQuery as Q, RuntimeRunRow as QS, JsonRpcResponse as Q_, startRetainedRun as Qa, MaterializedExecutionIdentity 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, SpawnJournal as Qv, BoundHarnessSession as Qx, Settled as Qy, GraphSubtasks as R, LoopWinner as RS, PeerMailEvent as R_, SandboxLineage as Ra, ReservationStage 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, SpawnJournalReadResult as Rv, StartRetainedInteractiveRunOptions as Rx, readRunParking as Ry, RuntimeStreamEvent as S, RetainedRunAdmission as SC, Iteration as SS, AuthorizedDownMessage as S_, EvolutionReport as Sa, SettledUsage 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, createPushTraceSource as Sx, RuntimeStreamEventCollector as Sy, RuntimeFailureOwner as T, RetainedRunCancellation as TC, LoopIterationDispatchPayload as TS, DownMessageAuthorizationInput as T_, StrategyTournament as Ta, SpawnForestInDoubtNode 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, DEFAULT_STALL_AFTER_MS as Tx, RuntimeTelemetryOptions as Ty, SpawnPreflightContext as U, SandboxClient as US, PeerMailSendInput as U_, acquireSandbox as Ua, ExecutorContext 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, RunCancelRequest as Uv, HarnessTranscriptEvidence as Ux, ResourceSpend as Uy, SettledWorker as V, OutputAdapter as VS, PeerMailReadout as V_, SandboxEvidenceReceipt as Va, createBudgetPool 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, RunState as Vv, HarnessTranscriptBinding as Vx, BudgetViolation as Vy, SpawnRefusal as W, SelectionReceipt as WS, PeerMailbox as W_, S3PrivateCasStore as Wa, ExecutorFactory 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, RunCancellation as Wv, HarnessTranscriptFile as Wx, Spend as Wy, AgentEnvironmentEvent$1 as X, RuntimeRunOptions as XS, peerMailVerbNames as X_, reconnectRetainedRun as Xa, ExecutorMaterialization 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, ResultBlobStore as Xv, harnessTranscriptArtifact as Xx, NodeStatus as Xy, AgentEnvironmentCapabilities$1 as Y, RuntimeRunHandle as YS, peerMailTools as Y_, PrivateCasNamespaceRetirement as Ya, ExecutorExecutionBinding 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, InMemorySpawnJournal as Yv, captureHarnessTranscript as Yx, NodeSnapshot as Yy, AgentEnvironmentProvider$1 as Z, RuntimeRunPersistenceAdapter as ZS, JsonRpcMessage as Z_, recoverRetainedRun as Za, ExecutorNodeContext 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, SpawnEvent as Zv, persistHarnessTranscript as Zx, RetainedExecutionState as Zy, RunAgentTaskOptions as _, RecoverRetainedRunResult as _C, UsageEvent as _S, QuestionPolicy as __, CollectedAgentTurn as _a, UnconfirmedTeardown 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, WorkerTraceEvidence as _x, OtelSpan as _y, AgentKnowledgeProvider as a, AgentEvalErrorCode as aC, RetainedHarnessTranscriptDescriptor as aS, RouteGate as a_, defaultStructuralRolloutPolicy as aa, FleetYield 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, Executor as ax, RootSignal as ay, RuntimeSession as b, RetainedInteractiveIntentAdmission as bC, Driver as bS, questionEscalationTargets as b_, streamAgentTurn as ba, WorkerEventEntry 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, ToolStepInput as bx, loopEventToOtelSpan as by, AgentTaskContext as c, JudgeError as cC, retainHarnessTranscript as cS, ChildQuestionInbox as c_, officialChecksFromMeta as ca, ProviderModelExecutionEvidence 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, ExecutorCancellationRequest as cx, SupervisorOpts as cy, AgentTaskStatus as d, NativeContextContinuationExecution as dC, ProviderWorkspaceCaptureReceipt as dS, QuestionDecision as d_, selectBestIndex as da, SupervisedResult 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, HeldEnvironment as dx, createPropagatingTraceEmitter as dy, startRuntimeRun as eC, HarnessFileBinding as eS, GateDecision as e_, VisibleCheck as ea, SpawnPrior 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, NodeExecutionIdentity as ex, WorkspaceCheckpointMarker as ey, BackendErrorDetail as f, NativeContextContinuationHandle as fC, ProviderWorkspaceCaptureResult as fS, QuestionEscalationOutcome as f_, structuralRollout as fa, Agent 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, HeldForContinuation as fx, readTraceContextFromEnv as fy, OpenAIChatToolChoice as g, RecoverRetainedRunOptions as gC, TokenUsageProvenance as gS, QuestionOption as g_, AgentTurnUsage as ga, Scope 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, WorkerInteractiveUnavailableReason as gx, OtelExporter as gy, OpenAIChatTool as h, RecoverRetainedRunIntentOptions as hC, ExecutorToolCall as hS, QuestionLevel as h_, AgentTurnInput$1 as ha, ResumedWork 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, WorkerInteractiveSession as hx, OtelExportStats as hy, AgentExecutionBackend as i, AgentEvalError$1 as iC, RetainedHarnessTranscriptCapture as iS, RouteFlowEvent as i_, defaultExtractCandidate as ia, TreeView 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, EnvironmentTeardownReceipt as ix, RootSegmentEntry as iy, DriverFailureClass as j, RetainedRunIntentAdmission as jC, LoopResult as jS, MapOnSettleRoute as j_, OpenSandboxRunBeforeStartContext as ja, BudgetPoolRestore 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, readWorkerProgress as jx, DeadlineCheckIn as jy, DriverAttemptStop as k, RetainedRunEventOptions as kC, LoopPlanDescription as kS, WorkerResumeContext as k_, strategyTournament as ka, loadSpawnForest 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, WorkerProgress as kx, createRuntimeStreamEventCollector as ky, AgentTaskRunResult as l, NotFoundError as lC, ProviderWorkspaceAttemptProvenance as lS, EscalateQuestion as l_, resolveEntrySymbol as la, RootProviderModelEvidence 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, ExecutorResult as lx, WorkerTraceResolver as ly, OpenAIChatResponseFormat as m, ReconnectRetainedRunOptions as mC, ExecutorProgressEvent as mS, QuestionEscalationTarget as m_, AgentTurnBackend as ma, ResumedKeyState 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, Runtime as mx, OtelExportConfig as my, AgentBackendContext as n, Redactor as nC, HarnessTranscriptReadLimits as nS, JsonScalar as n_, compareCheckOutcomes as na, SubtreeResult 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, RootMaterialization as nx, RootHandle as ny, AgentRuntimeEvent as o, BackendTransportError as oC, readBoundHarnessSessions as oS, RouteMatch as o_, filterAuthoredAsserts as oa, NoWinnerError 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, ExecutorAccounting as ox, SteerableRootHandle as oy, KnowledgeReadinessDecision as p, NativeContextContinuationInput as pC, ProviderWorkspaceEntryMetadata as pS, QuestionEscalationRecord as p_, visibleCheckScore as pa, ReenteredWorkers 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, HeldRelease as px, OtelAttribute as py, WorkerSpawnContext as q, RuntimeRunCompleteInput as qS, createPeerMailbox as q_, PrivateCasNamespaceInventory as qa, AgentExecutionRef 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, readRunCancellation as qv, ReadableEnvironment as qx, Handle as qy, AgentBackendInput as r, defaultRedactor as rC, HarnessTranscriptReadOptions as rS, RouteFlow as r_, composeCheckSources as ra, SubtreeSummary 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, UnknownMaterializationReason as rx, RootSegment as ry, AgentRuntimeEventSink as s, ConfigError as sC, resolveHarnessTranscriptCapture as sS, RouteWhen as s_, modelAuthoredChecks as sa, ProviderModelAttemptEvidence 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, ExecutorCancellation as sx, Supervisor as sy, AgentAdapter as t, contentAddress as tC, HarnessTranscriptMetadata as tS, GateRequest as t_, canDisplace as ta, SpawnRejection 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, ProfileMaterializationReceipt as tx, RecursiveReservationPolicy as ty, AgentTaskSpec as u, ValidationError as uC, ProviderWorkspaceCaptureProvenance as uS, Question as u_, sandboxCheckRunner as ua, RootStreamReceipt 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, ExecutorTeardownWarning as ux, TraceContext as uy, RunAgentTaskStreamOptions as v, RetainedInteractiveAdmission as vC, AgentRunSpec as vS, QuestionRecord as v_, StreamAgentTurnOptions as va, WidenGate 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, WorkerTraceUnavailableReason as vx, buildLoopOtelSpans as vy, RuntimeFailureCode as w, RetainedRunCancelOptions as wC, LoopEndedPayload as wS, ContinuityMode as w_, StrategyEvolutionConfig as wa, SpawnForestEvent 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, ActivityNote as wx, RuntimeStreamEventSummary as wy, RuntimeSessionStore as x, RetainedInteractiveStartedAdmission as xC, ExecCtx as xS, AuthorizeDownMessage as x_, EvolutionAuthor as xa, WorkerEventPage 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, TraceSource as xx, RuntimeEventCollector as xy, RuntimeCanonicalStreamEvent as y, RetainedInteractiveEnvironmentAdmission as yC, DefaultVerdict$2 as yS, QuestionUrgency as y_, collectAgentTurn as ya, WorkerEventCursor 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, SessionMessageLike as yx, createOtelExporter as yy, MakeWorkerAgent as z, MountManifestEntry as zS, PeerMailLimits as z_, SandboxLineageHandle as za, ReservationTicket 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, readSpawnJournal as zv, HARNESS_TRANSCRIPT_SETTLE_TIMEOUT_MS as zx, Budget as zy };
-//# sourceMappingURL=types-Jg274chm.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