@tangle-network/agent-runtime 0.324.0 → 0.325.0

package/dist/{types-ytkoP4VV.d.ts → types-5r334mcg.d.ts}

@@ -8002,6 +8002,8 @@ declare function serveCoordinationMcp(opts: CoordinationTransportOptions & {
   scope: Scope<unknown>;
   blobs: ResultBlobStore;
   makeWorkerAgent: MakeWorkerAgent;
+  /** Serve `run_graph` — see `CoordinationToolsOptions.graphs`. */
+  graphs?: GraphSubtasks;
   authorizeDownMessage?: AuthorizeDownMessage;
   perWorker: Budget;
   /** Independent completion check exposed to the driver as `submit_result`. The check runs
@@ -8529,6 +8531,8 @@ interface SupervisorAgentDeps {
   readonly blobs: ResultBlobStore;
   /** Resolve a spawned worker `profile` to a leaf agent — the recursion seam (same for both arms). */
   readonly makeWorkerAgent: MakeWorkerAgent;
+  /** Serve `run_graph` (both arms) — see `CoordinationToolsOptions.graphs`. */
+  readonly graphs?: GraphSubtasks;
   /** Product authorization for every down-leg continuation to a child. */
   readonly authorizeDownMessage?: AuthorizeDownMessage;
   /** Per-child budget reserved from the conserved pool on each spawn. */
@@ -8708,6 +8712,80 @@ declare function supervisorAgent(profile: SupervisorProfile, deps: SupervisorAge
 /** Scripted-brain construction for deterministic tests. Not exported from Runtime's main entry. */
 declare function supervisorAgentWithTestBrain(profile: SupervisorProfile, deps: SupervisorAgentTestDeps): Agent<unknown, unknown>;
 //#endregion
+//#region src/runtime/supervise/prompt-registry.d.ts
+/**
+ *
+ * The kernel prompt registry — versioned prompt text as DATA, addressed by `PromptHandle`.
+ *
+ * A role expressed as a builder FUNCTION is a role that can never improve: the only optimizable
+ * surface it leaves is whatever thin string a caller happens to inject, while the real doctrine
+ * sits hardcoded in TypeScript. This registry is the inverse: every standing instruction is a
+ * versioned entry (`<surface>` + `v<n>`), so a graph edge, a supervisor front door, or an
+ * optimizer names a handle and the TEXT is swappable, sweepable, and diffable without a code
+ * change. Graph edges (`runGraph`) carry handles, never inline prose.
+ *
+ * A profile or graph may opt into one of these versioned texts. Runtime does not select a standing
+ * supervisor policy when the profile omits one.
+ *
+ * @experimental
+ */
+/** A versioned reference into a prompt registry: `surface` names the role/edge the text serves,
+ *  `version` pins the exact text. The string form is `<surface>/v<n>` (e.g. `delegates/worker-brief/v1`). */
+interface PromptHandle {
+  readonly surface: string;
+  readonly version: number;
+}
+/** One registry entry: the handle plus the text it pins. */
+interface RegisteredPrompt {
+  readonly surface: string;
+  readonly version: number;
+  readonly text: string;
+  /** What the surface is FOR — shown by `list()`, never sent to a model. */
+  readonly description?: string;
+}
+/** Versioned prompt store. `resolve` fails loud on an unknown handle: a directive that silently
+ *  resolved to nothing is the unobservable-edge failure this whole design exists to end. */
+interface PromptRegistry {
+  resolve(handle: PromptHandle): RegisteredPrompt;
+  /** Register a new entry; a duplicate (surface, version) fails loud — versions are immutable. */
+  register(entry: RegisteredPrompt): void;
+  list(): ReadonlyArray<RegisteredPrompt>;
+}
+/**
+ * Parse `'<surface>/v<n>'` into a {@link PromptHandle}. The shorthand for authoring a graph edge:
+ * `directive: promptHandle('delegates/worker-brief/v1')`.
+ */
+declare function promptHandle(ref: string): PromptHandle;
+/** The string form of a handle: `<surface>/v<n>`. */
+declare function formatPromptHandle(handle: PromptHandle): string;
+/** Create a registry, optionally seeded. Entries are copied; the registry never aliases caller state. */
+declare function createPromptRegistry(seed?: ReadonlyArray<RegisteredPrompt>): PromptRegistry;
+/**
+ * Default DELEGATES-edge directive: the standing instruction a worker receives with every
+ * traversal of a delegates edge that names this surface.
+ */
+declare const delegatesWorkerBriefPrompt: RegisteredPrompt;
+/**
+ * Default ANALYZES-edge directive: what the RECEIVING node should do with an analyst's findings.
+ * Wrapped around the findings payload on every traversal of an analyzes edge naming this surface.
+ */
+declare const analyzesFindingsReportPrompt: RegisteredPrompt;
+/**
+ * Default NAIVE steering continuation — the no-signal control re-expressed as data: the same
+ * fixed continuation every round, reading nothing from any verdict.
+ */
+declare const naiveContinuationPrompt: RegisteredPrompt;
+/**
+ * Default DUMB steering continuations — the pass/fail-only control re-expressed as data: two
+ * fixed texts keyed on the verdict's boolean and nothing else.
+ */
+declare const dumbContinuationFailPrompt: RegisteredPrompt;
+/** The pass branch of the dumb steering control — see {@link dumbContinuationFailPrompt}. */
+declare const dumbContinuationPassPrompt: RegisteredPrompt;
+/** The kernel's seeded registry: every surface the runtime's own builders derive from. A caller
+ *  may register additional surfaces/versions on the returned registry. */
+declare function kernelPromptRegistry(): PromptRegistry;
+//#endregion
 //#region src/runtime/supervise/worker-trace.d.ts
 /**
  * Seam key the `Scope` seeds a {@link TraceContext} under on each child's `ExecutorContext.seams`.
@@ -9109,10 +9187,12 @@ interface SuperviseRegistry {
     names(): readonly string[];
   };
 }
-/** Capabilities a data-only consumer may require before building an opted-in run. */
+/** 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;
 }>;
 interface SuperviseOptions {
   /** Whole-run persistence and ownership. SQL contexts are acquired before replay and compute. */
@@ -9268,6 +9348,9 @@ interface SuperviseOptions {
    *  `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;
   /** Run an external-harness supervisor explicitly. Required for a remote sandbox; optional as a
    *  caller-owned override for a local bridge. */
   readonly driveHarness?: DriveHarness;
@@ -9769,96 +9852,295 @@ declare function superviseWithTestBrain(profile: SupervisorProfile, task: unknow
   };
 }>;
 //#endregion
-//#region src/durable/observer-journal.d.ts
-type ObserverRecordKind = 'event' | 'decision';
-/**
- * One immutable record in the observer plane. `sequence` is journal order, not
- * execution order; causal/runtime order remains available on the underlying event.
- * `previousDigest` + `digest` make deletion, reordering, or mutation detectable.
- */
-interface ObserverRecord {
-  readonly schemaVersion: 1;
-  readonly pursuitId: string;
-  readonly sequence: number;
-  readonly kind: ObserverRecordKind;
-  readonly observedAt: number;
-  readonly previousDigest?: string;
-  readonly event?: RuntimeHookEvent;
-  readonly decision?: RuntimeDecisionPoint;
-  readonly digest: string;
+//#region src/runtime/supervise/graph-overlay.d.ts
+/** Default per-edge traversal cap — the cyclic-graph backstop when an edge names none. */
+declare const defaultEdgeTraversalCap = 32;
+//#endregion
+//#region src/runtime/supervise/graph.d.ts
+/** 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;
 }
-interface ObserverJournal {
-  appendEvent(event: RuntimeHookEvent): Promise<ObserverRecord>;
-  appendDecision(point: RuntimeDecisionPoint): Promise<ObserverRecord>;
-  read(): Promise<readonly ObserverRecord[]>;
-  hooks(): RuntimeHooks;
+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;
+};
+interface AgentGraph {
+  readonly nodes: ReadonlyArray<GraphNode>;
+  readonly edges: ReadonlyArray<GraphEdge>;
+  /** Termination is mandatory, not optional: the independent completion oracle. */
+  readonly deliverable: DeliverableSpec<unknown>;
+  /** One conserved pool across the whole graph — cycles without conservation never terminate. */
+  readonly budget: Budget;
 }
-/**
- * Durable, append-only third-person history for one concrete Runtime execution.
- * It consumes Runtime's existing hook stream and does not participate in execution
- * decisions. A broken observer therefore cannot change what an agent is allowed to do.
- *
- * The write discipline deliberately matches `FileSpawnJournal`: serialized appends,
- * torn-tail recovery, short-write handling, and fsync before acknowledgement. One
- * execution owns one journal file; higher-level pursuit aggregation joins isolated
- * journals by `pursuitId` instead of making independent processes share a write head.
- */
-declare class FileObserverJournal implements ObserverJournal {
-  readonly path: string;
-  readonly pursuitId: string;
-  private tail;
-  private initialized;
-  private sequence;
-  private previousDigest;
-  private appendFailure;
-  constructor(path: string, pursuitId: string);
-  hooks(): RuntimeHooks;
-  appendEvent(event: RuntimeHookEvent): Promise<ObserverRecord>;
-  appendDecision(point: RuntimeDecisionPoint): Promise<ObserverRecord>;
-  read(): Promise<readonly ObserverRecord[]>;
-  private enqueue;
-  private initialize;
-  private readExistingUnsafe;
-  private assertComplete;
+type EdgeDeliveryOutcome = 'delivered' | 'stripped' | 'empty' | 'unpropagated';
+/** 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>` or `analyzes:<analyst>:<over…>-><to>`. */
+  readonly edge: string;
+  readonly kind: 'delegates' | 'analyzes';
+  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. */
+  readonly workerId?: string;
+}
+/** 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>);
 }
-/** Verify identity, monotonic sequence, payload shape, and the complete digest chain. */
-declare function verifyObserverRecords(records: readonly ObserverRecord[], pursuitId?: string): readonly ObserverRecord[];
-/** Compute the canonical SHA-256 digest for an unsigned observer record. */
-declare function observerRecordDigest(record: Omit<ObserverRecord, 'digest'>): string;
-//#endregion
-//#region src/durable/observer-projection.d.ts
-/**
- * One settled projection status, shared by runs and nodes. `down` is the journal's own word for a
- * failure (a settlement is journaled as `kind: 'down'`, cancellation included), so a consumer can
- * join run rows to node rows on `status` and read one failure population instead of two.
- */
-type PursuitStatus = 'running' | 'done' | 'down';
 /**
- * Where a node's dollar figure came from. `reported` = a provider billed all of it; `estimated` =
- * a model catalog priced all of it; `partial` = a provider billed part and a catalog priced the
- * rest; `unknown` = nothing priced it, so `usd` is a floor and never the cost.
+ * 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".
  */
-type PursuitCostProvenance = 'reported' | 'estimated' | 'partial' | 'unknown';
-/**
- * One node's token usage by class. Cache and reasoning classes are absent when the provider did
- * not report them — absence is not zero. `tokensKnown` is `false` when work happened whose token
- * count no provider reported, which makes `input`/`output` a floor.
+declare const GRAPH_FORWARDED_SUPERVISE_OPTIONS: readonly ["backend", "profileGuidance", "escalateQuestion", "rootHandle", "signal", "execution", "resolveDeliverable", "coordination", "peerMail", "peerAudit", "traceTools", "driverBackend", "profileSecurity", "authorizeSpawn", "router", "driveHarness", "selectSeat", "driverRetry", "onDriverAttempt", "workerRetry", "onWorkerRetry", "continuation", "childSettleGraceMs", "teardownConfirmMs", "retainedAtSettlement", "resolveDriveHarness", "driveHarnessMaterialization", "resolveSupervisorTools", "extraTools", "executeExtraTool", "recoverExecutor", "perWorker", "reservationPolicy", "deadlineCheckIn", "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`.
  */
-interface PursuitNodeUsage {
-  readonly input: number;
-  readonly output: number;
-  readonly cacheRead?: number;
-  readonly cacheWrite?: number;
-  readonly reasoning?: number;
-  readonly tokensKnown: boolean;
-}
+type GraphInheritedSuperviseOption = Exclude<(typeof GRAPH_FORWARDED_SUPERVISE_OPTIONS)[number], 'backend' | 'driverBackend'>;
 /**
- * One node's PLATFORM consumption — box wall time, the resource a subscription seat really pays.
+ * Options for one `runGraph` run.
  *
- * Kept apart from `PursuitNodeCost` because the two answer different questions and fail
- * independently: a seat run reports a truthful `$0` and real minutes, a caller-account run
- * reports real dollars and may report no minutes at all. Collapsing them into one "spend known"
- * figure hides which one is missing.
+ * 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;
+  /** 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;
+}
+/** `RunGraphOptions` with the brain REQUIRED — the shape the `/testing` entry's
+ *  `runGraphWithTestBrain` keeps accepting now that `brain` is a production option. */
+interface RunGraphTestOptions extends RunGraphOptions {
+  readonly brain: ToolLoopChat;
+}
+/**
+ * Execute an {@link AgentGraph}. 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>;
+//#endregion
+//#region src/durable/observer-journal.d.ts
+type ObserverRecordKind = 'event' | 'decision';
+/**
+ * One immutable record in the observer plane. `sequence` is journal order, not
+ * execution order; causal/runtime order remains available on the underlying event.
+ * `previousDigest` + `digest` make deletion, reordering, or mutation detectable.
+ */
+interface ObserverRecord {
+  readonly schemaVersion: 1;
+  readonly pursuitId: string;
+  readonly sequence: number;
+  readonly kind: ObserverRecordKind;
+  readonly observedAt: number;
+  readonly previousDigest?: string;
+  readonly event?: RuntimeHookEvent;
+  readonly decision?: RuntimeDecisionPoint;
+  readonly digest: string;
+}
+interface ObserverJournal {
+  appendEvent(event: RuntimeHookEvent): Promise<ObserverRecord>;
+  appendDecision(point: RuntimeDecisionPoint): Promise<ObserverRecord>;
+  read(): Promise<readonly ObserverRecord[]>;
+  hooks(): RuntimeHooks;
+}
+/**
+ * Durable, append-only third-person history for one concrete Runtime execution.
+ * It consumes Runtime's existing hook stream and does not participate in execution
+ * decisions. A broken observer therefore cannot change what an agent is allowed to do.
+ *
+ * The write discipline deliberately matches `FileSpawnJournal`: serialized appends,
+ * torn-tail recovery, short-write handling, and fsync before acknowledgement. One
+ * execution owns one journal file; higher-level pursuit aggregation joins isolated
+ * journals by `pursuitId` instead of making independent processes share a write head.
+ */
+declare class FileObserverJournal implements ObserverJournal {
+  readonly path: string;
+  readonly pursuitId: string;
+  private tail;
+  private initialized;
+  private sequence;
+  private previousDigest;
+  private appendFailure;
+  constructor(path: string, pursuitId: string);
+  hooks(): RuntimeHooks;
+  appendEvent(event: RuntimeHookEvent): Promise<ObserverRecord>;
+  appendDecision(point: RuntimeDecisionPoint): Promise<ObserverRecord>;
+  read(): Promise<readonly ObserverRecord[]>;
+  private enqueue;
+  private initialize;
+  private readExistingUnsafe;
+  private assertComplete;
+}
+/** Verify identity, monotonic sequence, payload shape, and the complete digest chain. */
+declare function verifyObserverRecords(records: readonly ObserverRecord[], pursuitId?: string): readonly ObserverRecord[];
+/** Compute the canonical SHA-256 digest for an unsigned observer record. */
+declare function observerRecordDigest(record: Omit<ObserverRecord, 'digest'>): string;
+//#endregion
+//#region src/durable/observer-projection.d.ts
+/**
+ * One settled projection status, shared by runs and nodes. `down` is the journal's own word for a
+ * failure (a settlement is journaled as `kind: 'down'`, cancellation included), so a consumer can
+ * join run rows to node rows on `status` and read one failure population instead of two.
+ */
+type PursuitStatus = 'running' | 'done' | 'down';
+/**
+ * Where a node's dollar figure came from. `reported` = a provider billed all of it; `estimated` =
+ * a model catalog priced all of it; `partial` = a provider billed part and a catalog priced the
+ * rest; `unknown` = nothing priced it, so `usd` is a floor and never the cost.
+ */
+type PursuitCostProvenance = 'reported' | 'estimated' | 'partial' | 'unknown';
+/**
+ * One node's token usage by class. Cache and reasoning classes are absent when the provider did
+ * not report them — absence is not zero. `tokensKnown` is `false` when work happened whose token
+ * count no provider reported, which makes `input`/`output` a floor.
+ */
+interface PursuitNodeUsage {
+  readonly input: number;
+  readonly output: number;
+  readonly cacheRead?: number;
+  readonly cacheWrite?: number;
+  readonly reasoning?: number;
+  readonly tokensKnown: boolean;
+}
+/**
+ * One node's PLATFORM consumption — box wall time, the resource a subscription seat really pays.
+ *
+ * Kept apart from `PursuitNodeCost` because the two answer different questions and fail
+ * independently: a seat run reports a truthful `$0` and real minutes, a caller-account run
+ * reports real dollars and may report no minutes at all. Collapsing them into one "spend known"
+ * figure hides which one is missing.
  *
  * Absent on a node that ran no box. `boxMinutes` absent WITH the block present says a box ran and
  * nothing measured it — a missing measurement is never a zero.
@@ -10201,6 +10483,32 @@ declare class SupervisePursuitError extends Error {
  * An abandoned `supervise.lock.guard` requires removal after confirming no lock mutation is active.
  */
 declare function supervisePursuit(profile: SupervisorProfile, task: unknown, opts: SupervisePursuitOptions): Promise<SupervisedPursuitResult<Awaited<ReturnType<typeof supervise>>>>;
+/** Options for {@link superviseGraphPursuit}: every `runGraph` option, plus the pursuit identity,
+ *  the run directory this execution owns, and optional observer delivery. */
+interface SuperviseGraphPursuitOptions extends RunGraphOptions {
+  /** Stable objective identity spanning concrete Runtime runs. */
+  readonly pursuitId: string;
+  /** The directory this execution owns: journal, blobs, observer journal, lock and terminal
+   *  records. Re-running the same `runDir` and `runId` resumes the graph. */
+  readonly runDir: string;
+  /** Always `'release'`, as for {@link supervisePursuit}: a settled graph is never re-entered. */
+  readonly retainedAtSettlement?: 'release';
+  /** As for {@link supervisePursuit}. */
+  readonly observerDelivery?: PursuitObserverDelivery;
+}
+/**
+ * One-call durable execution of an `AgentGraph`: the graph twin of {@link supervisePursuit}.
+ *
+ * It owns the run directory exactly as `supervisePursuit` does — `supervise.lock` for the life of
+ * the call, `observer.jsonl`, `result.json` once the graph settles, `failure.json` for the most
+ * recent throw, and refusal of a settled directory before any compute — and runs the graph through
+ * `runGraph`'s own path, so the root node is a `supervise()` root and a restarted process resumes
+ * the graph from its spawn journal. `result.json` holds the graph's supervised result, the same
+ * record every supervised run leaves; the edge ledger is the journal's `edge` events and the
+ * returned `result.ledger`. Version chains and forks are `supervisePursuit` features and are not
+ * offered here.
+ */
+declare function superviseGraphPursuit(graph: AgentGraph, opts: SuperviseGraphPursuitOptions): Promise<SupervisedPursuitResult<GraphResult>>;
 //#endregion
 //#region src/durable/pursuit-versions.d.ts
 /**
@@ -13845,6 +14153,8 @@ interface DriverAgentOptions {
   readonly blobs: ResultBlobStore;
   /** Resolve a spawned `profile` to a worker LEAF or a driver child (the recursion seam). */
   readonly makeWorkerAgent: MakeWorkerAgent;
+  /** Serve `run_graph` — see `CoordinationToolsOptions.graphs`. */
+  readonly graphs?: GraphSubtasks;
   readonly authorizeDownMessage?: AuthorizeDownMessage;
   /** Per-child budget reserved from the conserved pool on each spawn. */
   readonly perWorker: Budget;
@@ -13912,436 +14222,165 @@ interface DriverAgentOptions {
    *  `executeExtraTool`. Unset → coordination-only (the prior behavior). */
   readonly extraTools?: ReadonlyArray<{
     readonly name: string;
-    readonly description?: string;
-    readonly parameters: Record<string, unknown>;
-  }>;
-  /** Runs an `extraTools` call. Returns a string result, or null/undefined to signal "not handled"
-   *  so the call falls through to the coordination dispatch. Required iff `extraTools` is set. */
-  readonly executeExtraTool?: (name: string, args: Record<string, unknown>) => Promise<string | null | undefined>;
-  /** Max driver turns before the loop force-finalizes on the best settled child. Default: no
-   *  turn-count cap. The loop is bounded by the conserved budget pool (every driver turn is metered
-   *  into it), an absolute deadline, the driver's own stop, and abort, all checked before each
-   *  turn. Without a deadline, a manager stops once it has overdrawn its pool by the pool's size
-   *  again, and a brain that reports no usage keeps a 16-turn bound unless a dollar cap applies. A manager awaits one settlement per turn, so the old default of 16 ended any manager
-   *  with more than about 14 workers and tore its unfinished workers down: measured 2026-09-25 on
-   *  a 1 + 20 + 400 tree, 124 of 420 agents settled `down` at 16 and none at 0. */
-  readonly maxTurns?: number;
-  /** Injected clock for the in-loop absolute-deadline guard — keeps the deadline check
-   *  deterministic in tests. Defaults to `Date.now`. */
-  readonly now?: () => number;
-  /**
-   * PROGRESS-derived stop (mechanic D). Today a run ends on a ceiling — iterations, tokens,
-   * dollars, deadline, turn cap — which answers "may it continue?" and never "is it still getting
-   * anywhere?". A stop rule reads the run's own progress (best-so-far over settled work, time
-   * since the last settle, the live worker feed) and ends a run that has stopped learning BEFORE
-   * it exhausts a budget.
-   *
-   * Composes with, and can never override, the hard guards: `poolStarved` / `deadlinePassed` /
-   * abort / the driver's own stop are evaluated first, so a rule can only ADD a stop.
-   *
-   * THRESHOLDS are the caller's judgment, not this module's — build the rule with
-   * `plateau({window, minDelta})` / `noProgressFor({...})` / `allWorkersStalled({...})` from
-   * `supervise/stop-rules`. Omit ⇒ ceilings only (unchanged behavior).
-   */
-  readonly stopRule?: StopRule;
-  /** Called once with the rule's reason when a `stopRule` ends the run — so a caller can record
-   *  WHY a run stopped early instead of inferring it from an unexhausted budget. */
-  readonly onProgressStop?: (reason: string, request?: RunCancelRequest) => void;
-  /** Give the driver brain a chapter-lifecycle on its OWN context window. The LLM-brain front doors
-   *  lose to a dumb-Ralph respawn because the brain re-bills its whole coordination transcript every
-   *  turn — the same context overflow a single steered agent suffers, one level up. With this set,
-   *  once the brain's running conversation exceeds `thresholdTokens` it distills the accumulated
-   *  history to a compact progress note and continues fresh: the supervisor analog of respawning
-   *  against external tracking state, except the live `Scope` roster IS the durable state. Default
-   *  off (no behavior change). `distill` defaults to a self-summary authored by the brain combined
-   *  with the factual settled-worker roster; override to supply your own. */
-  readonly compaction?: ToolLoopCompactionOptions;
-  /** Pass-through subscriber for every coordination bus event: settled/question/finding,
-   *  pre-delivery instruction receipts, and steer/answer delivery outcomes. A durable caller uses
-   *  this to append the coordination log. Omit = no observer. */
-  readonly onEvent?: (event: CoordinationEvent, record: BusRecord<CoordinationEvent>) => void | Promise<void>;
-  /** Re-publish resume-time settlements through the awaited observer before the first brain turn. */
-  readonly replaySettlements?: boolean;
-  /** Questions, findings, and authorized continuation receipts loaded from a prior process.
-   *  Questions seed the ledger (`list_questions`, blocking-stop policy); all three feed the resume
-   *  brief. Continuation receipts are evidence only and are never auto-delivered. Omit = fresh. */
-  readonly priorCoordination?: PriorCoordination;
-  /** How the settled-worker ledger becomes the run's output. Default `bestDelivered` — the single
-   *  highest-scoring DELIVERED child (the exact keep-best every existing caller had). Runs under
-   *  the delivered-only invariant (`runFinalizer`): whatever the finalizer, an undelivered or
-   *  invalid child's output stays unreachable. */
-  readonly finalizer?: SupervisorFinalizer;
-  /** The recorder of this agent's conversation. A wrapper that builds a new driver for each `act`
-   *  passes one recorder to all of them, so the agent keeps one transcript across attempts.
-   *  @internal Runtime's own wiring between `supervisorAgent` and its router arm. */
-  transcript?: RouterTranscript;
-  /** Optional shared manager inbox used by a wrapper that must accept messages before async node
-   * setup finishes. Ordinary callers omit it and the driver owns a fresh inbox. */
-  readonly inbox?: Inbox;
-  /**
-   * The durable run directory (`SuperviseOptions.runDir` / the `run-layout` event dir) this driver
-   * ACKNOWLEDGES worker-scoped cancel requests from. Each turn the driver reads the layout's
-   * cancellation inbox once, applies any request naming one of ITS OWN workers through that
-   * worker's existing per-child abort (cascading to the worker's subtree and no sibling), and
-   * writes the durable {@link WorkerCancellation} acknowledgement: `cancel_requested` when the
-   * abort is issued, `cancelled` only when the worker reaches a terminal `down` on the settle
-   * path, `not_live` when the worker is already gone — a missing worker never reads as success.
-   * Which requests this driver OWNS is set by {@link controlScope}. Omit = no acknowledger
-   * (in-memory runs keep in-process control via handles).
-   */
-  readonly controlDir?: string;
-  /** Durable steer directory when it differs from the run-control directory. */
-  readonly steerDir?: string;
-  /**
-   * Which cancel requests this driver's acknowledger owns when `controlDir` is set.
-   *
-   * `'run'` (the default, and the tree root's role): exact node ids of its OWN direct children,
-   * plus every label/profile-name reference. `'subtree'` (a nested manager): exact direct-child
-   * node ids ONLY — never labels or profile names, which can match workers under more than one
-   * manager. Ownership makes each operation appliable by exactly ONE manager, so two acknowledgers
-   * sharing one `controlDir` can never abort two workers for one operation or race on the
-   * acknowledgement file. At the end of `act`, the owner writes an expiry record for each owned
-   * request still open: `not_live` for one never applied, `unknown` for an abort whose settle the
-   * run ended too soon to observe — so a reader can tell run-over from in-progress.
-   */
-  /** Called with this driver's coordination tool descriptors once they exist and before the brain
-   *  loop starts — the seam a node tool uses to call the same verbs in code
-   *  (`SupervisorToolInvocationContext.verbs`). */
-  readonly onCoordinationTools?: (tools: ReadonlyArray<McpToolDescriptor$1>, coordination: Pick<CoordinationTools, 'awaitSettlement'>) => void;
-  readonly controlScope?: 'run' | 'subtree';
-  /**
-   * Abort the WHOLE run — the seam a run-scoped cancel request (`cancelRun`) is applied through.
-   * Wired by `supervise()` to the run's ONE cascade controller (the attached root control), so a
-   * run cancel takes the same path a caller's `RootHandle.abort` takes; there is no second
-   * controller and no poller. Read only by the `'run'`-scoped manager with a `controlDir`; omit
-   * and a run-scoped request stays unanswered.
-   */
-  readonly abortRun?: (reason: string, request?: RunCancelRequest) => void;
-}
-/**
- * Build the intelligent recursive driver. Its `act` is the LLM tool-loop; spawn it as a
- * `driverChild` (`driver-executor.ts`) to run it inside a nested scope, recursively.
- */
-declare function driverAgent(opts: DriverAgentOptions): Agent<unknown, unknown>;
-/** Keep-best finalize under the completion-oracle: return the highest-scoring DELIVERED child's
- *  output (settled `done` AND `valid` — its deliverable check passed). Returns undefined when no
- *  child delivered — an honest "the driver produced nothing", never a high-scoring result that
- *  ran without passing its check (Foreman's 0/18 lesson). `valid` is the single delivery signal,
- *  matching `defaultSelectWinner`'s valid-first rule; the oracle just doesn't fall back to an
- *  unchecked best-effort. The same argmax as the `bestDelivered` finalizer (`pickBestDelivered`);
- *  this direct form serves callers that hold a bare ledger + blob store. */
-declare function finalizeBestDelivered(settled: ReadonlyArray<{
-  status: string;
-  score?: number;
-  valid?: boolean;
-  outRef?: string;
-}>, blobs: ResultBlobStore): Promise<unknown>;
-//#endregion
-//#region src/runtime/supervise/delegate.d.ts
-/** The conserved pool a `delegate()` call applies when the caller does not pass its own `budget`.
- *  A modest token ceiling + a small iteration ceiling — generous enough for a few-worker decompose,
- *  bounded enough that an unsupervised intent cannot run away. Callers override via `opts.budget`. */
-declare const defaultDelegateBudget: Budget;
-/** Inputs to {@link delegate}. The intent is the first positional arg; everything here is optional
- *  with explicit execution identity, so the common call names one exact supervisor profile. */
-interface DelegateOptions<Out = unknown> {
-  /** The completion oracle (settled ⟺ delivered) the authored workers settle against. Strongly
-   *  recommended — without it the supervisor trusts a worker's self-report. For a code intent,
-   *  `patchDelivered()` is the canonical example; for a free-form answer, a content check. */
-  readonly deliverable?: DeliverableSpec<Out>;
-  /** WHERE the authored workers run — the worker-execution backend (`router-tools` / `sandbox` /
-   *  `cli-worktree` / …). The supervisor authors the worker PROFILE; this is the substrate it runs
-   *  on. Provide this OR `makeWorkerAgent`-style wiring through `supervise()` is unavailable. */
-  readonly backend?: ExecutorConfig;
-  /** The conserved compute pool for the whole delegation. Defaults to {@link defaultDelegateBudget}. */
-  readonly budget?: Budget;
-  /** Exact executable authoring supervisor. Model, prompt, harness, and provider live here. */
-  readonly supervisorProfile: SupervisorProfile;
-  /** Router endpoint/auth for a `cli-base` supervisor; contains no behavioral settings. */
-  readonly router: RouterTransportConfig;
-  /** Restrict the run to this subset of models (forwarded to `supervise()`). */
-  readonly allowedModels?: readonly string[];
-  readonly runId?: string;
-}
-/**
- * Delegate an INTENT to a default authoring supervisor and return its `SupervisedResult` unchanged.
- *
- * The supervisor authors + spawns whatever worker the intent needs over the conserved-budget pool;
- * `result.spentTotal` reports what the whole delegation actually cost. A `winner` result carries the
- * authored worker's delivered output; a `no-winner` result names why (never a fabricated success).
- */
-declare function delegate<Out = unknown>(intent: string, opts: DelegateOptions<Out>): Promise<SupervisedResult<Out>>;
-//#endregion
-//#region src/runtime/supervise/prompt-registry.d.ts
-/**
- *
- * The kernel prompt registry — versioned prompt text as DATA, addressed by `PromptHandle`.
- *
- * A role expressed as a builder FUNCTION is a role that can never improve: the only optimizable
- * surface it leaves is whatever thin string a caller happens to inject, while the real doctrine
- * sits hardcoded in TypeScript. This registry is the inverse: every standing instruction is a
- * versioned entry (`<surface>` + `v<n>`), so a graph edge, a supervisor front door, or an
- * optimizer names a handle and the TEXT is swappable, sweepable, and diffable without a code
- * change. Graph edges (`runGraph`) carry handles, never inline prose.
- *
- * A profile or graph may opt into one of these versioned texts. Runtime does not select a standing
- * supervisor policy when the profile omits one.
- *
- * @experimental
- */
-/** A versioned reference into a prompt registry: `surface` names the role/edge the text serves,
- *  `version` pins the exact text. The string form is `<surface>/v<n>` (e.g. `delegates/worker-brief/v1`). */
-interface PromptHandle {
-  readonly surface: string;
-  readonly version: number;
-}
-/** One registry entry: the handle plus the text it pins. */
-interface RegisteredPrompt {
-  readonly surface: string;
-  readonly version: number;
-  readonly text: string;
-  /** What the surface is FOR — shown by `list()`, never sent to a model. */
-  readonly description?: string;
-}
-/** Versioned prompt store. `resolve` fails loud on an unknown handle: a directive that silently
- *  resolved to nothing is the unobservable-edge failure this whole design exists to end. */
-interface PromptRegistry {
-  resolve(handle: PromptHandle): RegisteredPrompt;
-  /** Register a new entry; a duplicate (surface, version) fails loud — versions are immutable. */
-  register(entry: RegisteredPrompt): void;
-  list(): ReadonlyArray<RegisteredPrompt>;
-}
-/**
- * Parse `'<surface>/v<n>'` into a {@link PromptHandle}. The shorthand for authoring a graph edge:
- * `directive: promptHandle('delegates/worker-brief/v1')`.
- */
-declare function promptHandle(ref: string): PromptHandle;
-/** The string form of a handle: `<surface>/v<n>`. */
-declare function formatPromptHandle(handle: PromptHandle): string;
-/** Create a registry, optionally seeded. Entries are copied; the registry never aliases caller state. */
-declare function createPromptRegistry(seed?: ReadonlyArray<RegisteredPrompt>): PromptRegistry;
-/**
- * Default DELEGATES-edge directive: the standing instruction a worker receives with every
- * traversal of a delegates edge that names this surface.
- */
-declare const delegatesWorkerBriefPrompt: RegisteredPrompt;
-/**
- * Default ANALYZES-edge directive: what the RECEIVING node should do with an analyst's findings.
- * Wrapped around the findings payload on every traversal of an analyzes edge naming this surface.
- */
-declare const analyzesFindingsReportPrompt: RegisteredPrompt;
-/**
- * Default NAIVE steering continuation — the no-signal control re-expressed as data: the same
- * fixed continuation every round, reading nothing from any verdict.
- */
-declare const naiveContinuationPrompt: RegisteredPrompt;
-/**
- * Default DUMB steering continuations — the pass/fail-only control re-expressed as data: two
- * fixed texts keyed on the verdict's boolean and nothing else.
- */
-declare const dumbContinuationFailPrompt: RegisteredPrompt;
-/** The pass branch of the dumb steering control — see {@link dumbContinuationFailPrompt}. */
-declare const dumbContinuationPassPrompt: RegisteredPrompt;
-/** The kernel's seeded registry: every surface the runtime's own builders derive from. A caller
- *  may register additional surfaces/versions on the returned registry. */
-declare function kernelPromptRegistry(): PromptRegistry;
-//#endregion
-//#region src/runtime/supervise/graph.d.ts
-/** 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;
-};
-interface AgentGraph {
-  readonly nodes: ReadonlyArray<GraphNode>;
-  readonly edges: ReadonlyArray<GraphEdge>;
-  /** Termination is mandatory, not optional: the independent completion oracle. */
-  readonly deliverable: DeliverableSpec<unknown>;
-  /** One conserved pool across the whole graph — cycles without conservation never terminate. */
-  readonly budget: Budget;
-}
-type EdgeDeliveryOutcome = 'delivered' | 'stripped' | 'empty' | 'unpropagated';
-/** 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>` or `analyzes:<analyst>:<over…>-><to>`. */
-  readonly edge: string;
-  readonly kind: 'delegates' | 'analyzes';
-  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. */
-  readonly workerId?: string;
-}
-/** Default per-edge traversal cap — the cyclic-graph backstop when an edge names none. */
-declare const defaultEdgeTraversalCap = 32;
-/** 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>);
+    readonly description?: string;
+    readonly parameters: Record<string, unknown>;
+  }>;
+  /** Runs an `extraTools` call. Returns a string result, or null/undefined to signal "not handled"
+   *  so the call falls through to the coordination dispatch. Required iff `extraTools` is set. */
+  readonly executeExtraTool?: (name: string, args: Record<string, unknown>) => Promise<string | null | undefined>;
+  /** Max driver turns before the loop force-finalizes on the best settled child. Default: no
+   *  turn-count cap. The loop is bounded by the conserved budget pool (every driver turn is metered
+   *  into it), an absolute deadline, the driver's own stop, and abort, all checked before each
+   *  turn. Without a deadline, a manager stops once it has overdrawn its pool by the pool's size
+   *  again, and a brain that reports no usage keeps a 16-turn bound unless a dollar cap applies. A manager awaits one settlement per turn, so the old default of 16 ended any manager
+   *  with more than about 14 workers and tore its unfinished workers down: measured 2026-09-25 on
+   *  a 1 + 20 + 400 tree, 124 of 420 agents settled `down` at 16 and none at 0. */
+  readonly maxTurns?: number;
+  /** Injected clock for the in-loop absolute-deadline guard — keeps the deadline check
+   *  deterministic in tests. Defaults to `Date.now`. */
+  readonly now?: () => number;
+  /**
+   * PROGRESS-derived stop (mechanic D). Today a run ends on a ceiling — iterations, tokens,
+   * dollars, deadline, turn cap — which answers "may it continue?" and never "is it still getting
+   * anywhere?". A stop rule reads the run's own progress (best-so-far over settled work, time
+   * since the last settle, the live worker feed) and ends a run that has stopped learning BEFORE
+   * it exhausts a budget.
+   *
+   * Composes with, and can never override, the hard guards: `poolStarved` / `deadlinePassed` /
+   * abort / the driver's own stop are evaluated first, so a rule can only ADD a stop.
+   *
+   * THRESHOLDS are the caller's judgment, not this module's — build the rule with
+   * `plateau({window, minDelta})` / `noProgressFor({...})` / `allWorkersStalled({...})` from
+   * `supervise/stop-rules`. Omit ⇒ ceilings only (unchanged behavior).
+   */
+  readonly stopRule?: StopRule;
+  /** Called once with the rule's reason when a `stopRule` ends the run — so a caller can record
+   *  WHY a run stopped early instead of inferring it from an unexhausted budget. */
+  readonly onProgressStop?: (reason: string, request?: RunCancelRequest) => void;
+  /** Give the driver brain a chapter-lifecycle on its OWN context window. The LLM-brain front doors
+   *  lose to a dumb-Ralph respawn because the brain re-bills its whole coordination transcript every
+   *  turn — the same context overflow a single steered agent suffers, one level up. With this set,
+   *  once the brain's running conversation exceeds `thresholdTokens` it distills the accumulated
+   *  history to a compact progress note and continues fresh: the supervisor analog of respawning
+   *  against external tracking state, except the live `Scope` roster IS the durable state. Default
+   *  off (no behavior change). `distill` defaults to a self-summary authored by the brain combined
+   *  with the factual settled-worker roster; override to supply your own. */
+  readonly compaction?: ToolLoopCompactionOptions;
+  /** Pass-through subscriber for every coordination bus event: settled/question/finding,
+   *  pre-delivery instruction receipts, and steer/answer delivery outcomes. A durable caller uses
+   *  this to append the coordination log. Omit = no observer. */
+  readonly onEvent?: (event: CoordinationEvent, record: BusRecord<CoordinationEvent>) => void | Promise<void>;
+  /** Re-publish resume-time settlements through the awaited observer before the first brain turn. */
+  readonly replaySettlements?: boolean;
+  /** Questions, findings, and authorized continuation receipts loaded from a prior process.
+   *  Questions seed the ledger (`list_questions`, blocking-stop policy); all three feed the resume
+   *  brief. Continuation receipts are evidence only and are never auto-delivered. Omit = fresh. */
+  readonly priorCoordination?: PriorCoordination;
+  /** How the settled-worker ledger becomes the run's output. Default `bestDelivered` — the single
+   *  highest-scoring DELIVERED child (the exact keep-best every existing caller had). Runs under
+   *  the delivered-only invariant (`runFinalizer`): whatever the finalizer, an undelivered or
+   *  invalid child's output stays unreachable. */
+  readonly finalizer?: SupervisorFinalizer;
+  /** The recorder of this agent's conversation. A wrapper that builds a new driver for each `act`
+   *  passes one recorder to all of them, so the agent keeps one transcript across attempts.
+   *  @internal Runtime's own wiring between `supervisorAgent` and its router arm. */
+  transcript?: RouterTranscript;
+  /** Optional shared manager inbox used by a wrapper that must accept messages before async node
+   * setup finishes. Ordinary callers omit it and the driver owns a fresh inbox. */
+  readonly inbox?: Inbox;
+  /**
+   * The durable run directory (`SuperviseOptions.runDir` / the `run-layout` event dir) this driver
+   * ACKNOWLEDGES worker-scoped cancel requests from. Each turn the driver reads the layout's
+   * cancellation inbox once, applies any request naming one of ITS OWN workers through that
+   * worker's existing per-child abort (cascading to the worker's subtree and no sibling), and
+   * writes the durable {@link WorkerCancellation} acknowledgement: `cancel_requested` when the
+   * abort is issued, `cancelled` only when the worker reaches a terminal `down` on the settle
+   * path, `not_live` when the worker is already gone — a missing worker never reads as success.
+   * Which requests this driver OWNS is set by {@link controlScope}. Omit = no acknowledger
+   * (in-memory runs keep in-process control via handles).
+   */
+  readonly controlDir?: string;
+  /** Durable steer directory when it differs from the run-control directory. */
+  readonly steerDir?: string;
+  /**
+   * Which cancel requests this driver's acknowledger owns when `controlDir` is set.
+   *
+   * `'run'` (the default, and the tree root's role): exact node ids of its OWN direct children,
+   * plus every label/profile-name reference. `'subtree'` (a nested manager): exact direct-child
+   * node ids ONLY — never labels or profile names, which can match workers under more than one
+   * manager. Ownership makes each operation appliable by exactly ONE manager, so two acknowledgers
+   * sharing one `controlDir` can never abort two workers for one operation or race on the
+   * acknowledgement file. At the end of `act`, the owner writes an expiry record for each owned
+   * request still open: `not_live` for one never applied, `unknown` for an abort whose settle the
+   * run ended too soon to observe — so a reader can tell run-over from in-progress.
+   */
+  /** Called with this driver's coordination tool descriptors once they exist and before the brain
+   *  loop starts — the seam a node tool uses to call the same verbs in code
+   *  (`SupervisorToolInvocationContext.verbs`). */
+  readonly onCoordinationTools?: (tools: ReadonlyArray<McpToolDescriptor$1>, coordination: Pick<CoordinationTools, 'awaitSettlement'>) => void;
+  readonly controlScope?: 'run' | 'subtree';
+  /**
+   * Abort the WHOLE run — the seam a run-scoped cancel request (`cancelRun`) is applied through.
+   * Wired by `supervise()` to the run's ONE cascade controller (the attached root control), so a
+   * run cancel takes the same path a caller's `RootHandle.abort` takes; there is no second
+   * controller and no poller. Read only by the `'run'`-scoped manager with a `controlDir`; omit
+   * and a run-scoped request stays unanswered.
+   */
+  readonly abortRun?: (reason: string, request?: RunCancelRequest) => void;
 }
 /**
- * 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 ["backend", "profileGuidance", "escalateQuestion", "rootHandle", "signal", "execution", "resolveDeliverable", "coordination", "peerMail", "peerAudit", "traceTools", "driverBackend", "profileSecurity", "authorizeSpawn", "router", "driveHarness", "selectSeat", "driverRetry", "onDriverAttempt", "workerRetry", "onWorkerRetry", "continuation", "childSettleGraceMs", "teardownConfirmMs", "retainedAtSettlement", "resolveDriveHarness", "driveHarnessMaterialization", "resolveSupervisorTools", "extraTools", "executeExtraTool", "recoverExecutor", "perWorker", "reservationPolicy", "deadlineCheckIn", "workerSlots", "watchWorkers", "stallAfterMs", "wake", "runDir", "resume", "segment", "runContext", "steerDir", "stopRule", "onProgressStop", "maxDepth", "maxTurns", "compaction", "now", "allowedModels", "finalizer", "otel"];
-/** `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.
+ * Build the intelligent recursive driver. Its `act` is the LLM tool-loop; spawn it as a
+ * `driverChild` (`driver-executor.ts`) to run it inside a nested scope, recursively.
  */
-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;
-  /** 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;
+declare function driverAgent(opts: DriverAgentOptions): Agent<unknown, unknown>;
+/** Keep-best finalize under the completion-oracle: return the highest-scoring DELIVERED child's
+ *  output (settled `done` AND `valid` — its deliverable check passed). Returns undefined when no
+ *  child delivered — an honest "the driver produced nothing", never a high-scoring result that
+ *  ran without passing its check (Foreman's 0/18 lesson). `valid` is the single delivery signal,
+ *  matching `defaultSelectWinner`'s valid-first rule; the oracle just doesn't fall back to an
+ *  unchecked best-effort. The same argmax as the `bestDelivered` finalizer (`pickBestDelivered`);
+ *  this direct form serves callers that hold a bare ledger + blob store. */
+declare function finalizeBestDelivered(settled: ReadonlyArray<{
+  status: string;
+  score?: number;
+  valid?: boolean;
+  outRef?: string;
+}>, blobs: ResultBlobStore): Promise<unknown>;
+//#endregion
+//#region src/runtime/supervise/delegate.d.ts
+/** The conserved pool a `delegate()` call applies when the caller does not pass its own `budget`.
+ *  A modest token ceiling + a small iteration ceiling — generous enough for a few-worker decompose,
+ *  bounded enough that an unsupervised intent cannot run away. Callers override via `opts.budget`. */
+declare const defaultDelegateBudget: Budget;
+/** Inputs to {@link delegate}. The intent is the first positional arg; everything here is optional
+ *  with explicit execution identity, so the common call names one exact supervisor profile. */
+interface DelegateOptions<Out = unknown> {
+  /** The completion oracle (settled ⟺ delivered) the authored workers settle against. Strongly
+   *  recommended — without it the supervisor trusts a worker's self-report. For a code intent,
+   *  `patchDelivered()` is the canonical example; for a free-form answer, a content check. */
+  readonly deliverable?: DeliverableSpec<Out>;
+  /** WHERE the authored workers run — the worker-execution backend (`router-tools` / `sandbox` /
+   *  `cli-worktree` / …). The supervisor authors the worker PROFILE; this is the substrate it runs
+   *  on. Provide this OR `makeWorkerAgent`-style wiring through `supervise()` is unavailable. */
+  readonly backend?: ExecutorConfig;
+  /** The conserved compute pool for the whole delegation. Defaults to {@link defaultDelegateBudget}. */
+  readonly budget?: Budget;
+  /** Exact executable authoring supervisor. Model, prompt, harness, and provider live here. */
+  readonly supervisorProfile: SupervisorProfile;
+  /** Router endpoint/auth for a `cli-base` supervisor; contains no behavioral settings. */
+  readonly router: RouterTransportConfig;
+  /** Restrict the run to this subset of models (forwarded to `supervise()`). */
+  readonly allowedModels?: readonly 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'];
-}
-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;
-}
-/** `RunGraphOptions` with the brain REQUIRED — the shape the `/testing` entry's
- *  `runGraphWithTestBrain` keeps accepting now that `brain` is a production option. */
-interface RunGraphTestOptions extends RunGraphOptions {
-  readonly brain: ToolLoopChat;
 }
 /**
- * Execute an {@link AgentGraph}. 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.
+ * Delegate an INTENT to a default authoring supervisor and return its `SupervisedResult` unchanged.
+ *
+ * The supervisor authors + spawns whatever worker the intent needs over the conserved-budget pool;
+ * `result.spentTotal` reports what the whole delegation actually cost. A `winner` result carries the
+ * authored worker's delivered output; a `no-winner` result names why (never a fabricated success).
  */
-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 function delegate<Out = unknown>(intent: string, opts: DelegateOptions<Out>): Promise<SupervisedResult<Out>>;
 //#endregion
 //#region src/runtime/supervise/designer-tools.d.ts
 /** How the ENVIRONMENT executes a graph the designer asked to run. */
@@ -16309,6 +16348,29 @@ interface PeerAuditAccess {
   register(nodeId: string, tools: ReadonlyArray<McpToolDescriptor$1>): void;
   read(peerId: string, tool: 'observe_agent' | 'read_journal', args: Record<string, unknown>): Promise<unknown>;
 }
+/** A graph a manager asked `run_graph` to run, validated and composed by the run that owns the
+ *  worker path, or the reason it was refused. */
+type GraphSubtaskPreparation = {
+  readonly ok: true;
+  /** The exact profile the spawn runs: the root node's pinned profile with the graph brief. */
+  readonly profile: AgentProfile;
+  readonly root: string;
+  readonly nodes: ReadonlyArray<string>;
+} | {
+  readonly ok: false;
+  readonly reason: string;
+};
+/** How a run starts an agent graph as ONE subtask of a manager (`run_graph`). `supervise()`
+ *  supplies it when it owns the worker path: the graph's root node then runs as a nested manager
+ *  under the graph's node pinning, inside the caller's reservation. */
+interface GraphSubtasks {
+  /** Validate a graph a manager wrote, or load a stored one by digest, and compose the exact root
+   *  profile the spawn runs. Never throws: a refusal carries its reason. */
+  readonly prepare: (input: {
+    readonly graph?: unknown;
+    readonly graphDigest?: string;
+  }) => Promise<GraphSubtaskPreparation>;
+}
 interface CoordinationToolsOptions {
   readonly scope: Scope<unknown>;
   readonly peerAudit?: PeerAuditAccess;
@@ -16317,6 +16379,10 @@ interface CoordinationToolsOptions {
   readonly sourceEvidenceRefs?: ReadonlyArray<string>;
   readonly makeWorkerAgent: MakeWorkerAgent;
   readonly perWorker: Budget;
+  /** Serve `run_graph`, which starts an agent graph as one subtask under this manager's conserved
+   *  pool. Present only when the run's worker path pins graph nodes; absent, the verb is not
+   *  mounted and a profile that grants it is refused at construction. */
+  readonly graphs?: GraphSubtasks;
   /** Called once when this manager declares completion through `stop` or an accepted submission. */
   readonly onStop?: (reason: string | undefined) => void;
   /**
@@ -18774,6 +18840,9 @@ type SpawnEvent = {
   kind: 'edge';
   /** The destination node when known (a spawned worker's id), else `graph:<node>`. */
   id: NodeId;
+  /** The node that drives this edge's graph, when a manager started the graph with `run_graph`.
+   *  One run journal can then hold several graphs' ledgers; absent for the run's own graph. */
+  graph?: NodeId;
   edge: {
     kind: 'delegates' | 'analyzes' | 'data';
     from: string;
@@ -20159,5 +20228,5 @@ interface KnowledgeReadinessDecision {
   nonBlockingGapIds: string[];
 }
 //#endregion
-export { ExecutorResult as $, SpawnForestMissingTree as $C, toOtelAttributes as $S, StartRetainedRunInEnvironmentOptions as $T, ProviderWorkspaceCaptureResult as $_, GraphDesignerExtraTools as $a, workerInboxFile as $b, buildSteerContext as $c, IsolatedCheckBoxEvidence as $d, WorkerSpawnRetryPolicy as $f, SandboxLeafOut as $g, ActivityLog as $h, ProvisionSupervisorConnection as $i, AgenticSurface as $l, HarnessTranscriptMetadata as $m, Question as $n, CheckSourceCtx as $o, ProgressTracker as $p, WorkerInteractiveProviderSource as $r, recoverRetainedRun as $s, WorkerInteractiveSession as $t, PanelSpec as $u, runDetachedTurn as $v, LoopPlanDescription as $w, CodeModeResult as $x, createResearcherValidator as $y, TRACE_ROOT_SCHEMA as A, LOCAL_HARNESSES as AC, bestSoFar as AS, NativeContextContinuationInput as AT, ExecRequest as A_, graphDigest as Aa, WorkerSteerAcknowledgement as Ab, PrivateCasOptions as Ac, ShapeContext as Ad, PursuitStatus as Af, BridgeHarnessStore as Ag, CliWorktreeBridgeSeam as Ah, createRootHandle as Ai, SandboxEvidenceContext as Al, CoordinationHttpOptions as Am, AuthoredAnalystLimits as An, driverAgent as Ao, DriveHarness as Ap, SandboxInstance$1 as Ar, assertStrategyContract as As, Scope as At, ObserveOptions as Au, DetachedSessionDelegateOptions as Av, BudgetReconcileFault as Aw, verdictFromJudgeScore as Ax, DelegationResultPayload as Ay, EnvironmentTeardownReceipt as B, SqlRunStoreOptions as BC, OtelExportStats as BS, RetainedRunAdmissionHook as BT, createAgentEnvironmentProviderRegistry as B_, taskShapeDigest as Ba, readWorkerCancellation as Bb, InMemoryCorpus as Bc, LeaderboardScore as Bd, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as Bf, DEFAULT_SHARED_BOX_RESOURCES as Bg, createExecutorRegistry as Bh, assertSearchSpec as Bi, InProcessSandboxClientOptions as Bl, EventBus as Bm, CoordinationToolsOptions as Bn, AuthoredProfile as Bo, SupervisorProfile as Bp, SurfaceReader as Br, TurnResult as Bs, SteerableRootHandle as Bt, EqualKOnCost as Bu, SiblingSandboxExecutorOptions as Bv, createBudgetPool as Bw, CodexRolloutIdentity as Bx, UI_FINDING_SEVERITIES as By, RuntimeFailureCause as C, captureWorktreeDiff as CC, renderLeaderboardSvg as CS, RuntimeRunStatus as CT, AgentSession as C_, InPlaceCliExecutorOptions as Ca, CoderOutput as Cb, CollectedAgentTurn as Cc, Outcome as Cd, PursuitNodePlatform as Cf, PeerMailbox as Cg, DelegateError as Ch, analyzeTrace as Ci, superviseDispatch as Cl, CoordinationAuthentication as Cm, AnalystKind as Cn, kernelPromptRegistry as Co, readWorkerTraceContext as Cp, normalizeAnalyzeOnSettle as Cr, StrategyTournament as Cs, RootMaterialization as Ct, HarvestFailure as Cu, FeedbackStore as Cv, DEFAULT_CHECK_IN_IDLE_MS as Cw, admitContinuationPolicy as Cx, DelegationError as Cy, runtimeFailureCause as D, CodexExecutionPolicy as DC, AnytimeTaskCurve as DS, WorkerEventPage as DT, CheckpointRef as D_, GraphSelection as Da, RunCancellation as Db, PrivateCasArtifactPort as Dc, RunPersonified as Dd, PursuitProjection as Df, isPeerMailEnvelope as Dg, validateDelegateArgs as Dh, parseWorkerToolTraceArtifact as Di, defaultSelectWinner as Dl, CoordinationTransportOptions as Dm, AnalystToolGroupName as Dn, defaultDelegateBudget as Do, CoordinationBinding as Dp, AnalystFinding$1 as Dr, strategyTournament as Ds, RootSignal as Dt, ObservationAnalysis as Du, CoderReview as Dv, BudgetPool as Dw, expandQuestions as Dx, DelegationHistoryResult as Dy, RuntimeFailureOwner as E, CodexExecutionEvidence as EC, AnytimeStrategySummary as ES, WorkerEventEntry as ET, AgentTurnResult$2 as E_, GraphRunRecord as Ea, RunCancelRequest as Eb, streamAgentTurn as Ec, PersonaExecutors as Ed, PursuitNodeUsage as Ef, createPeerMailbox as Eg, createDelegateHandler as Eh, captureWorkerTraceEvidence as Ei, TerminalDecision as El, CoordinationReadAccess as Em, AnalystRunContext as En, DelegateOptions as Eo, workerTraceSeamKey as Ep, AgentProfile$2 as Er, runStrategyEvolution as Es, RootSegmentEntry as Et, Observation as Eu, CoderDelegate as Ev, createWorkerSlots as Ew, distillFindings as Ex, DelegationHistoryEntry as Ey, AgentExecutionRef as F, localHarnessExecutable as FC, WaterfallSpan as FS, RetainedInteractiveAdmission as FT, ProviderExecutorOptions as F_, loadGraph as Fa, legacySupervisorRunDir as Fb, createShapeRegistry as Fc, LeaderboardBenchmarkAdapter as Fd, ObserverRecordKind as Ff, envKeyProvider as Fg, RouterToolsSeam as Fh, CompiledSearchSpec as Fi, LocalSandboxClientOptions as Fl, FileCoordinationLog as Fm, ContinuationInstruction as Fn, ChatTransportTool as Fo, ResolvedSupervisorProfile as Fp, BoxSurfaceReaderOptions as Fr, OpenSandboxRunBeforeStartContext as Fs, SpawnPrior as Ft, CombinatorShape as Fu, detachedSessionDelegate as Fv, ReservationShortfall as Fw, completionAuthorizes as Fx, FeedbackRefersTo as Fy, ExecutorCancellationRequest as G, d1ToSqlAdapter as GC, buildLoopSpanNodes as GS, RetainedRunEnvironmentAdmission as GT, SandboxControlClient as G_, freeSlots as Ga, safeWorkerFile as Gb, panel as Gc, DeclaredCheckStateCapture as Gd, SuperviseTestOptions as Gf, SharedBoxPlacement as Gg, createSteerableSandboxSession as Gh, ScopeArgs as Gi, McpSpawnFault as Gl, HarnessTranscriptEvidence as Gm, DownMessageEvent as Gn, defaultProfileRichnessThresholds as Go, supervisorAgent as Gp, AnalystAuthoring as Gr, SessionCapableBox as Gs, SupervisorOpts as Gt, FanoutSynthesis as Gu, DetachedTurnResumeDriverOptions as Gv, ExecCtx as Gw, CodexStoreDelta as Gx, UiLens as Gy, Executor as H, D1DatabaseLike as HC, OtelSpan as HS, RetainedRunCancellation as HT, providerAsSandboxClient as H_, DispatchStopReason as Ha, readWorkerSteerRequests as Hb, fanout as Hc, defineLeaderboard as Hd, SuperviseOptions as Hf, ROUTER_CLIENT_HEADER as Hg, SandboxSteeringOptions as Hh, searchPresets as Hi, HttpMcpServerSpec as Hl, createEventBus as Hm, DownMessageAuthorizationInput as Hn, ProfileRichnessThresholds as Ho, SupervisorToolInvocationContext as Hp, boxSurfaceReader as Hr, BranchCapableBox as Hs, SubtreeSummary as Ht, EqualKVerdict as Hu, createSiblingSandboxExecutor as Hv, AgentRunSpec as Hw, CodexRolloutStoreReader as Hx, UiFinding as Hy, AgentSpec as I, parseCodexTokenUsage as IC, createWaterfallCollector as IS, RetainedInteractiveEnvironmentAdmission as IT, ProviderLeafOut as I_, lookupGraph as Ia, legacySupervisorRunsRoot as Ib, registerShape as Ic, LeaderboardFlagSpec as Id, observerRecordDigest as If, mcpSecretEnvMetadataKey as Ig, SandboxSeam as Ih, SEARCH_SPEC_CORRELATION_KEY as Ii, localSandboxClient as Il, PriorCoordination as Im, ContinuityMode as In, ChatWorkerSeamOptions as Io, SupervisorAgentDeps as Ip, HarvestSurfaceDiffsOptions as Ir, OpenSandboxRunOptions as Is, SpawnRejection as It, Corpus as Iu, settleDetachedCoderTurn as Iv, ReservationStage as Iw, deterministicCompletion as Ix, ResearchOutputShape as Iy, ExecutorFactory as J, InMemoryResultBlobStore as JC, createOtelExporter as JS, RetainedRunIntentAdmission as JT, ProviderCheckpointCaptureContext as J_, WatchTraceOptions as Ja, supervisorWorkersDir as Jb, verify as Jc, declaredCheckDeliverable as Jd, superviseWithTestBrain as Jf, SharedBoxStats as Jg, ToolStepInput as Jh, RemoteSupervisorAgent as Ji, StdioMcpServerSpec as Jl, HarnessTranscriptUnavailableReason as Jm, LeadMessage as Jn, CheckExecChannel as Jo, ManagerWakePolicy as Jp, AuthoredHarness as Jr, acquireSandbox as Js, TreeView as Jt, LoopUntil as Ju, RunDetachedTurnOptions as Jv, LoopEndedPayload as Jw, harnessUsageIsEmpty as Jx, MultiHarnessResearcherFanoutOptions as Jy, ExecutorContext as K, FileResultBlobStore as KC, buildRuntimeEventOtelSpans as KS, RetainedRunEventOptions as KT, createTangleSandboxExactProcessProvider as K_, queueOf as Ka, supervisorRunDir as Kb, pipeline as Kc, assertDeclaredCheck as Kd, supervise as Kf, SharedBoxPlacementOptions as Kg, SessionMessageLike as Kh, createScope as Ki, McpToolDescriptor as Kl, HarnessTranscriptFile as Km, EscalateQuestion as Kn, profileRichnessFinding as Ko, supervisorAgentWithTestBrain as Kp, analystsFromRegistry as Kr, createSandboxLineage as Ks, TokenUsageProvenance as Kt, FanoutWinnerSelector as Ku, DriveTurnCapableBox as Kv, Iteration as Kw, addHarnessUsage as Kx, KnowledgeItem as Ky, Budget as L, runLocalHarness as LC, LoopSpanNode as LS, RetainedInteractiveIntentAdmission as LT, ProviderPromptOptions as L_, pickBestGraph as La, readRunCancelRequest as Lb, definePersona as Lc, LeaderboardIterationInfo as Ld, verifyObserverRecords as Lf, resolveMcpServerLaunch as Lg, cliInPlaceExecutor as Lh, SearchSpec as Li, inlineSandboxClient as Ll, BusEvent as Lm, CoordinationEvent as Ln, chatTransportExecutor as Lo, SupervisorAgentTestDeps as Lp, SurfaceDiff as Lr, OpenSandboxRunPromptOptions as Ls, Spend as Lt, CorpusFilter as Lu, DelegationExecutor as Lv, ReservationTicket as Lw, sentinelCompletion as Lx, UiAuditLensFilter as Ly, TraceRootArtifact as M, LocalHarnessResult as MC, renderAnytimeTable as MS, RecoverRetainedRunIntentOptions as MT, ForkRequest as M_, graphRegistry as Ma, WriteWorkerSteerOptions as Mb, equalKOnCost as Mc, DefinedLeaderboard as Md, FileObserverJournal as Mf, BridgeSeam as Mg, ExecutorConfig as Mh, FencedSqlRunContext as Mi, SandboxEvidenceRetentionError as Ml, CoordinationDeliveryEvidence as Mm, AuthorizedDownMessage as Mn, ChatCompletionsTransport as Mo, ObserveSupervisorNodeEvent as Mp, makeFinding$1 as Mr, strategyAuthorContract as Ms, SpawnEvent as Mt, observe as Mu, SettleDetachedCoderTurnOptions as Mv, ReservationFloor as Mw, CompletionEvidence as Mx, DelegationStatusArgs as My, TraceSummary as N, RunLocalHarnessOptions as NC, WaterfallCollector as NS, RecoverRetainedRunOptions as NT, PlacementInfo as N_, graphRunsFor as Na, cancelRun as Nb, trajectoryReport as Nc, LeaderboardBenchScore as Nd, ObserverJournal as Nf, KeyProvider as Ng, ProviderSeam as Nh, SqlRunContextOptions as Ni, SandboxEvidenceRetentionPort as Nl, CoordinationLog as Nm, AwaitWakeInput as Nn, ChatSessionStore as No, ResolveDriveHarness as Np, VerifierEnvironmentOptions as Nr, strategyAuthorSystemPrompt as Ns, SpawnJournal as Nt, renderReport as Nu, UiAuditorDelegate as Nv, ReservationHolder as Nw, CompletionPolicy as Nx, DelegationStatusResult as Ny, settlementFailureCause as O, CodexTokenUsage as OC, anytimeReport as OS, NativeContextContinuationExecution as OT, CheckpointRequest as O_, StoredGraph as Oa, WorkerCancelRequest as Ob, PrivateCasDurableStore as Oc, RunPersonifiedOptions as Od, PursuitRunProjection as Of, peerMailTools as Og, CliInPlaceSeam as Oh, workerTraceAnalysisStore as Oi, isTerminalDecision as Ol, serveCoordinationMcp as Om, AnalyzeOnSettleRoute as On, delegate as Oo, CoordinationToolFace as Op, CreateSandboxOptions$1 as Or, AuthorStrategyOptions as Os, RootStreamReceipt as Ot, ObservationError as Ou, CoderReviewer as Ov, BudgetPoolRestore as Ow, failedItems as Ox, DelegationProfile as Oy, Agent as P, harnessSupportsReasoningEffort as PC, WaterfallReport as PS, RecoverRetainedRunResult as PT, ProviderAsSandboxClientOptions as P_, listGraphRuns as Pa, cancelWorker as Pb, builtinShapes as Pc, LeaderboardBenchTask as Pd, ObserverRecord as Pf, ResolvedMcpServerLaunch as Pg, RouterSeam as Ph, createFencedSqlRunContext as Pi, captureBeforeDestroy as Pl, CoordinationOwnerId as Pm, BlockedToolReport as Pn, ChatTransportExecutorOptions as Po, ResolveSupervisorTools as Pp, createVerifierEnvironment as Pr, Deliverable as Ps, SpawnOpts as Pt, AssertTraceDerivedFindings as Pu, coderTaskFromArgs as Pv, ReservationRejection as Pw, CompletionVerdict as Px, FeedbackRating as Py, ExecutorRegistry as Q, SpawnForestInDoubtNode as QC, padTraceId as QS, RetainedRunTurnInput as QT, ProviderWorkspaceCaptureReceipt as Q_, DesignerToolsEnv as Qa, workerControlLogFile as Qb, assertTraceDerivedFindings as Qc, IsolatedCheckBox as Qd, WorkerSpawnRetryHooks as Qf, sharedWorkerClientName as Qg, sandboxSessionTraceSource as Qh, connectRemoteSupervisor as Qi, AgenticRunResult as Ql, persistHarnessTranscript as Qm, PeerAuditAccess as Qn, CheckSource as Qo, ProgressSample as Qp, WorkerInteractiveBinding as Qr, reconnectRetainedRun as Qs, WidenGate as Qt, PanelJudge as Qu, parseDetachedSessionRef as Qv, LoopLineageOptions as Qw, CodeModeOptions as Qx, ResearcherProfileOptions as Qy, BudgetOverspend as R, SqlRunLease as RC, OtelAttribute as RS, RetainedInteractiveStartedAdmission as RT, ResourceRequest as R_, recordGraphRun as Ra, readRunCancellation as Rb, runPersonified as Rc, LeaderboardRunContext as Rd, AuthorizedSpawn as Rf, resolveSecretEnv as Rg, cliWorktreeExecutor as Rh, SearchSpecInputs as Ri, InProcessOnPrompt as Rl, BusRecord as Rm, CoordinationStats as Rn, chatWorkerSeam as Ro, SupervisorNodeContext as Rp, SurfaceReadBox as Rr, SandboxRun as Rs, SpendChannel as Rt, CorpusRecord as Ru, FleetHandle as Rv, ReservationWaitRefused as Rw, stopSentinel as Rx, UiAuditorDelegationOutput as Ry, RuntimeStreamEvent as S, WorktreeHandle as SC, renderLeaderboardMarkdown as SS, RuntimeRunRow as ST, AgentProfileRef as S_, WorkerInteractiveAdmission as Sa, InMemoryDelegationStore as Sb, AgentTurnUsage as Sc, LoopShape as Sd, PursuitNodePlacement as Sf, PeerMailSendInput as Sg, DelegateArgs as Sh, TrajectoryAnalysis as Si, loopDispatch as Sl, runFinalizer as Sm, AnalystFindingEvent as Sn, formatPromptHandle as So, WorkerTraceSeamCarrier as Sp, downMessageRefusalReasons as Sr, StrategyEvolutionConfig as Ss, RootHandle as St, HarvestError as Su, FeedbackEvent as Sv, DEADLINE_CHECK_IN_MESSAGE as Sw, VerdictSummary as Sx, DelegateUiAuditRoute as Sy, RuntimeFailureContext as T, removeWorktree as TC, AnytimeReport as TS, WorkerEventCursor as TT, AgentSessionStatus$1 as T_, GraphRegistryDir as Ta, coderTaskToPrompt as Tb, collectAgentTurn as Tc, PersonaContext as Td, PursuitNodeTiming as Tf, claimsAuthority as Tg, DelegateResult as Th, WorkerToolTraceArtifact as Ti, TERMINAL_DECISIONS as Tl, CoordinationPublicAddress as Tm, AnalystRegistry$1 as Tn, promptHandle as To, workerTraceHeaders as Tp, questionEscalationTargets as Tr, TournamentRow as Ts, RootSegment as Tt, harvestCorpus as Tu, eventToSnapshot as Tv, WorkerSlots as Tw, checkVerdictOf as Tx, DelegationHistoryArgs as Ty, ExecutorAccounting as U, D1StmtLike as UC, RuntimeEventOtelOptions as US, RetainedRunDispatchedAdmission as UT, resolveAgentEnvironmentProvider as U_, DispatchUnit as Ua, runCancelRequestFile as Ub, flatWidenGate as Uc, DeclaredCheck as Ud, SuperviseRegistry as Uf, SharedBoxCloseReceipt as Ug, SteerableSandboxArgs as Uh, searchSpecDigest as Ui, LocalMcpMaterialization as Ul, HarnessTranscriptArtifact as Um, DownMessageDeliveryAttempt as Un, asAuthoredProfile as Uo, assertCoordinationBinding as Up, fsSurfaceReader as Ur, SandboxLineage as Us, SupervisedResult as Ut, Fanout as Uu, DetachedSessionRefParts as Uv, DefaultVerdict$1 as Uw, CodexRolloutStoreRef as Ux, UiFindingScreenshot as Uy, ExecutionBindingReceipt as V, openSqlRunStore as VC, OtelExporter as VS, RetainedRunCancelOptions as VT, providerAsExecutor as V_, DispatchReport as Va, readWorkerSteerAcknowledgement as Vb, renderCorpusToInstructions as Vc, LeaderboardSpec as Vd, DeliverableResolutionInput as Vf, DEFAULT_SHARED_BOX_WORKERS as Vg, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Vh, compileSearchSpec as Vi, inProcessSandboxClient as Vl, PublishOptions as Vm, DefinedAnalystRecord as Vn, ProfileRichness as Vo, SupervisorToolDescriptor as Vp, WatchedSurface as Vr, openSandboxRun as Vs, SubtreeResult as Vt, EqualKOnCostOptions as Vu, createFleetWorkspaceExecutor as Vv, spendFromUsageEvents as Vw, CodexRolloutSession as Vx, UI_LENSES as Vy, ExecutorCancellation as W, SqlAdapter as WC, buildLoopOtelSpans as WS, RetainedRunEffect as WT, CreateTangleSandboxExactProcessProviderOptions as W_, RollingDispatchOptions as Wa, runCancellationFile as Wb, loopUntil as Wc, DeclaredCheckPlacement as Wd, SuperviseRegistryTable as Wf, SharedBoxHandle as Wg, SteerableSandboxSession as Wh, SUBTREE_RESULT_LIMIT as Wi, MaterializeLocalMcpOptions as Wl, HarnessTranscriptCapture as Wm, DownMessageDeliveryOutcome as Wn, assessAuthoredProfile as Wo, resolveSupervisorProfile as Wp, harvestSurfaceDiffs as Wr, SandboxLineageHandle as Ws, Supervisor as Wt, FanoutOptions as Wu, DetachedTurn as Wv, Driver as Ww, CodexRolloutTurn as Wx, UiFindingSeverity as Wy, ExecutorNodeContext as X, SpawnForest as XC, loopEventToOtelSpan as XS, RetainedRunSnapshot as XT, ProviderWorkspaceAttemptProvenance as X_, watchTrace as Xa, workerCancellationFile as Xb, CreateScopeAnalystOptions as Xc, declaredCheckJudge as Xd, ResolvedWorkerSpawnRetry as Xf, sharedBoxPlacement as Xg, createPushTraceSource as Xh, RemoteSupervisorTree as Xi, materializeLocalMcp as Xl, captureHarnessTranscript as Xm, ManagerReentryState as Xn, CheckRunContext as Xo, NoProgressForOptions as Xp, worktreeFanout as Xr, S3PrivateCasStoreOptions as Xs, UnknownMaterializationReason as Xt, LoopUntilState as Xu, detachedTurnEvents as Xv, LoopIterationEndedPayload as Xw, HarnessUsage as Xx, ResearchSource as Xy, ExecutorMaterialization as Y, InMemorySpawnJournal as YC, generateSpanId as YS, RetainedRunReplayPoint as YT, ProviderNativeCapturePhase as Y_, defaultToolDetectors as Ya, workerCancelRequestsFile as Yb, widen as Yc, declaredCheckDigest as Yd, workerFromBackend as Yf, SharedWorkerIdentity as Yg, TraceSource as Yh, RemoteSupervisorReader as Yi, connectStdioMcp as Yl, ReadableEnvironment as Ym, MakeWorkerAgent as Yn, CheckOutcome as Yo, AllWorkersStalledOptions as Yp, WorktreeFanoutOptions as Yr, S3PrivateCasStore as Ys, UnconfirmedTeardown as Yt, LoopUntilSpec as Yu, createDetachedTurnResumeDriver as Yv, LoopIterationDispatchPayload as Yw, readCodexRolloutSession as Yx, ResearchOutput as Yy, ExecutorProgressEvent as Z, SpawnForestEvent as ZC, padSpanId as ZS, RetainedRunStartMaterial as ZT, ProviderWorkspaceCaptureProvenance as Z_, DesignerRunGraphEnv as Za, workerCancellationsDir as Zb, RegistryAnalyzeProjection as Zc, readDeclaredCheck as Zd, WorkerSpawnRetryAttempt as Zf, sharedBoxRefusal as Zg, decodeToolPart as Zh, RemoteWorkerEvents as Zi, AgenticOptions as Zl, harnessTranscriptArtifact as Zm, ManagerWake as Zn, CheckRunner as Zo, PlateauOptions as Zp, AttachWorkerOptions as Zr, createS3PrivateCasStore as Zs, UsageEvent as Zt, Panel as Zu, formatDetachedSessionRef as Zv, LoopIterationStartedPayload as Zw, decodeHarnessUsage as Zx, ResearchTask as Zy, RunAgentTaskOptions as _, CreateWorktreeOptions as _C, ProfileKeyOf as _S, RuntimeRunCompleteInput as _T, AgentEnvironmentProviderRef as __, InteractiveWorkerEnvironment as _a, DelegationPersistenceError as _b, profileOptimizerModelCall as _c, WidenLineage as _d, PursuitFork as _f, PeerMailEvent as _g, createInProcessTransport as _h, WorkspaceRun as _i, LoopDispatchOptions as _l, FinalizerSettled as _m, summarizeDriverAttempts as _n, analyzesFindingsReportPrompt as _o, SupervisorSpanOptions as _p, WorkerSpawnContext as _r, structuralRollout as _s, ResourceSpend as _t, refine as _u, JsonRpcMessage as _v, RetainedInteractiveBindingError as _w, ContinuationPanelInput as _x, DelegateResearchConfig as _y, AgentKnowledgeProvider as a, SanitizedKnowledgeReadinessReport as aC, RunCodeModeOptions as aS, LoopTokenUsage as aT, createSandboxToolPartState as a_, ProfileRunRecord as aa, readTraceContextFromEnv as ab, recoverRetainedInteractiveRun as ac, ScopeAnalyst as ad, NextPursuitVersionInput as af, WorkerProgress as ag, retainHarnessTranscript as ah, WorkerEvidenceInput as ai, createMcpEnvironment as al, allWorkersStalled as am, DriverAttemptStop as an, GraphEdgeCapError as ao, SeatSelection as ap, QuestionOption as ar, VisibleCheck as as, MaterializedExecutionIdentity as at, ShotSpec as au, ExecutorResultMapping as av, contentAddress as aw, workerSteersDir as ax, DelegationRunContext as ay, RuntimeSession as b, GitRunner as bC, pairwiseSignificance as bS, RuntimeRunOptions as bT, AgentEnvironmentStatus as b_, InteractiveWorkerResult as ba, FileDelegationStore as bb, AgentTurnBackend as bc, DefinePersona as bd, PursuitCostProvenance as bf, PeerMailReadout as bg, DELEGATE_INPUT_SCHEMA as bh, localShell as bi, SuperviseOptionsForDispatch as bl, collectDelivered as bm, AnalystAssignmentRecord as bn, dumbContinuationFailPrompt as bo, createSupervisorSpanRecorder as bp, canonicalFindingEvent as br, EvolutionReport as bs, ResumedWork as bt, sampleThenRefine as bu, McpToolDescriptor$1 as bv, RuntimeRunStateError as bw, ContinuationProfile as bx, DelegateUiAuditConfig as by, AgentTaskContext as c, createRuntimeStreamEventCollector as cC, runCodeMode as cS, LoopWinner as cT, mapSandboxEvent as c_, pickBestProfile as ca, DELEGATION_TRACE_MAX_BYTES as cb, RecoverRetainedInteractiveRunOptions as cc, SteerContext as cd, PursuitVersions as cf, AuthorityInboxMessage as cg, SPAWN_RESOURCE_PATH_MAX_BYTES as ch, settledWorkerOut as ci, BenchmarkConfig as cl, noProgressFor as cm, DriverContinuationRecord as cn, RunGraphOptions as co, SelectSeat as cp, QuestionUrgency as cr, composeCheckSources as cs, NodeExecutionIdentity as ct, StrategyCtx as cu, RouterResponseReceipt as cv, resolveRedactor as cw, CONTINUATION_FACTS as cx, SubmitInput as cy, AgentTaskStatus as d, sanitizeRuntimeStreamEvent as dC, Interval as dS, OutputAdapter as dT, sandboxProgressEvents as d_, recordProfileRun as da, DelegationTraceCollector as db, RetainedInteractiveRunHandle as dc, TrajectoryReportFn as dd, VersionVerdict as df, PeerInboxMessage as dg, SpawnResourceReader as dh, copyUntrackedIntoClone as di, BenchmarkStrategySummary as dl, ReentryContinuity as dm, DriverLoopRecord as dn, defaultEdgeTraversalCap as do, RunContext as dp, SpawnPreflightContext as dr, filterAuthoredAsserts as ds, NodeStatus as dt, StrategyShotResult as du, ToolLoopCallContext as dv, BackendTransportError as dw, CheckVerdict as dx, DelegateCodeArgs as dy, RuntimeEventCollector as eC, StartRetainedRunOptions as eE, CodeModeStore as eS, LoopPlanPayload as eT, SandboxOutputMarker as e_, ProvisionSupervisorRequest as ea, multiHarnessResearcherFanout as eb, startRetainedRun as ec, PanelVerdict as ed, IsolatedCheckOptions as ef, ActivityNote as eg, HarnessTranscriptReadLimits as eh, attachWorker as ei, createScopeAnalyst as el, ProgressTrackerOptions as em, WorkerInteractiveUnavailableReason as en, graphDesignerExtraTools as eo, isPreSpawnExecutorFailure as ep, QuestionDecision as er, RepairStop as es, ExecutorTeardownWarning as et, AgenticTask as eu, ProviderWorkspaceEntryMetadata as ev, SpawnForestNode as ew, workerInboxFileFromEventDir as ex, DelegationArgs as ey, BackendErrorDetail as f, InPlaceHarnessResult as fC, Leaderboard as fS, RunProvenance as fT, sumSandboxUsage as f_, PatchDeliverableOptions as fa, DelegationTraceSpan as fb, RetainedInteractiveStartMaterial as fc, TrajectoryReportOptions as fd, assertPursuitVersions as ff, createInbox as fg, environmentReader as fh, withUntrackedArtifacts as fi, BenchmarkTaskRow as fl, ReentryTaskInput as fm, DriverProgressMark as fn, runGraph as fo, RunContextLease as fp, SpawnRefusal as fr, modelAuthoredChecks as fs, ProfileMaterializationReceipt as ft, SurfaceScore as fu, ToolLoopChat as fv, ConfigError as fw, ContinuationAppend as fx, DelegateCodeConfig as fy, OpenAIChatToolChoice as g, WorktreeProfileMaterializationReceipt as gC, PairwiseVerdict as gS, Validator as gT, AgentEnvironmentProvider$1 as g_, createWorktreeCliExecutor as ga, createDelegationTraceCollector as gb, profileChatClient as gc, WidenDecision as gd, supervisePursuit as gf, PeerMailEnvelope as gg, McpServerOptions as gh, WorkspaceCommit as gi, LoopCampaignDispatchOptions as gl, FinalizeContext as gm, classifyDriverFailure as gn, RegisteredPrompt as go, SupervisorSpanAttributes as gp, WorkerResumeContext as gr, selectBestIndex as gs, ResourceLimit as gt, depthStrategy as gu, ToolLoopToolCall as gv, RetainedInteractiveAdmissionError as gw, ContinuationPanel as gx, DelegateResearchArgs as gy, OpenAIChatTool as h, WorktreeHarnessResult as hC, PairwiseOptions as hS, ValidationCtx as hT, AgentEnvironmentEvent$1 as h_, WorktreePatchArtifact as ha, composeLoopTraceEmitters as hb, resolveSandboxClient as hc, Widen as hd, SupervisedPursuitResult as hf, PEER_MAIL_WIRE_KEY as hg, McpServer as hh, Workspace as hi, runBenchmark as hl, DeliveredOutput as hm, DriverRetryPolicy as hn, PromptRegistry as ho, withRunContext as hp, ToolOutcomeEvent as hr, sandboxCheckRunner as hs, RecursiveReservationPolicy as ht, defineStrategy as hu, ToolLoopMessageRecord as hv, PlannerError as hw, ContinuationNoteInput as hx, DelegateFeedbackResult as hy, AgentExecutionBackend as i, RuntimeTelemetryOptions as iC, CodeModeToolset as iS, LoopTeardownFailedPayload as iT, assertSandboxServedModel as i_, ProfileRegistryDir as ia, mergeTraceEnv as ib, reconnectRetainedInteractiveRun as ic, RenderCorpusToInstructionsOptions as id, NextPursuitVersion as if, TeamProgress as ig, resolveHarnessTranscriptCapture as ih, VERIFY_TAIL_CHARS as ii, McpEnvironmentOptions as il, allOf as im, DriverAttemptRecord as in, GraphEdge as io, SeatSegment as ip, QuestionLevel as ir, StructuralRolloutResult as is, HeldEnvironment as it, RunAgenticOptions as iu, DeliverableSpec as iv, replaySpawnTree as iw, workerSteerRequestsDir as ix, DelegationResumeTick as iy, TRACE_SUMMARY_SCHEMA as j, LocalHarness as jC, plateauLength as jS, ReconnectRetainedRunOptions as jT, ExecResult as j_, graphFromStored as ja, WorkerSteerRequest as jb, createPrivateCasArtifactPort as jc, ShapeRegistry as jd, projectPursuit as jf, BridgeModelCredential as jg, CliWorktreeSeam as jh, createSupervisor as ji, SandboxEvidenceReceipt as jl, CoordinationRejectReason as jm, AuthorizeDownMessage as jn, finalizeBestDelivered as jo, DriveHarnessOwnerContext as jp, computeFindingId$1 as jr, authorStrategy as js, Settled as jt, defaultAnalystInstruction as ju, DetachedWinnerSelection as jv, LeakedReservation as jw, CompletionAnalyst as jx, DelegationStatus as jy, RetainedPendingCause as k, DEFAULT_LOCAL_HARNESS as kC, areaUnderCurve as kS, NativeContextContinuationHandle as kT, CreateAgentEnvironmentInput$1 as k_, digestOfGraph as ka, WorkerCancellation as kb, PrivateCasOffloadReport as kc, ShapeBudget as kd, PursuitRunTotals as kf, peerMailVerbNames as kg, CliSeam as kh, DEFAULT_MAX_DEPTH as ki, runAgentRounds as kl, CoordinationHttpAudit as km, AuthoredAnalystDefinition as kn, DriverAgentOptions as ko, CoordinationVerbs as kp, SandboxEvent$1 as kr, AuthoredStrategy as ks, Runtime as kt, ObserveInput as ku, DelegateRunCtx as kv, BudgetReadout as kw, passedItems as kx, DelegationProgress as ky, AgentTaskRunResult as l, sanitizeAgentRuntimeEvent as lC, AxisScoresOf as lS, MountManifestEntry as lT, mapSandboxToolEvent as l_, profileRegistry as la, DELEGATION_TRACE_MAX_SPANS as lb, RetainedInteractiveAdmissionHook as lc, TrajectoryNode as ld, SettledPursuitVersion as lf, Inbox as lg, SpawnResourceBytes as lh, CopyOptions as li, BenchmarkLift as ll, plateau as lm, DriverContractState as ln, RunGraphTestOptions as lo, InMemoryRunContext as lp, SettledWorker as lr, defaultExtractCandidate as ls, NodeId as lt, StrategyMessage as lu, RouterTransportConfig as lv, AgentEvalError$1 as lw, CheckRead as lx, SubmitOutput as ly, OpenAIChatResponseFormat as m, WorktreeCommandResult as mC, LeaderboardRow as mS, SelectionReceipt as mT, AgentEnvironmentCapabilities$1 as m_, WorktreeCliExecutorOptions as ma, capDelegationTrace as mb, ResolveSandboxClientOptions as mc, VerifySpec as md, SupervisePursuitOptions as mf, DEFAULT_PEER_MAIL_LIMITS as mg, resolveSpawnResourcePaths as mh, Shell as mi, printBenchmarkReport as ml, composeReentryTask as mm, DriverRepromptRefusal as mn, PromptHandle as mo, createInMemoryRunContext as mp, SuperviseProfileEntry as mr, resolveEntrySymbol as ms, ProviderModelExecutionEvidence as mt, breadthStrategy as mu, ToolLoopCompactionOptions as mv, NotFoundError as mw, ContinuationEntry as mx, DelegateFeedbackArgs as my, AgentBackendContext as n, RuntimeStreamEventSink as nC, CodeModeToolContext as nS, LoopSandboxPlacement as nT, SandboxToolPartState as n_, SupervisorCleanupReceipt as na, TraceContext as nb, ClaimRetainedInteractiveControlOptions as nc, PipelineStage as nd, runIsolatedCheck as nf, ExecutorProgress as ng, RetainedHarnessTranscriptCapture as nh, EVIDENCE_MAX_CHARS as ni, observationFromRegistry as nl, StopDecision as nm, WorkerTraceUnavailableReason as nn, EdgeDeliveryOutcome as no, retryPreSpawnRefusals as np, QuestionEscalationRecord as nr, StructuralRolloutMessage as ns, FleetYield as nt, ArtifactHandle as nu, ProviderWorkspaceRetentionPort as nv, loadSpawnForest as nw, workerSteerAcknowledgementsDir as nx, DelegationResumeContext as ny, AgentRuntimeEvent as o, SanitizedKnowledgeRequirement as oC, createCodeModeTools as oS, LoopTraceEmitter as oT, createSandboxUsageLedger as o_, bestProfileFor as oa, traceContextToEnv as ob, startRetainedInteractiveRun as oc, ScopeAnalyzeInput as od, PursuitVersionChain as of, createActivityLog as og, ResolveSpawnResourcePathsResult as oh, closingWorkerNote as oi, sanitizeMcpToolSchema as ol, anyOf as om, DriverAttemptsExhaustedError as on, GraphNode as oo, SeatSelectionInput as op, QuestionPolicy as or, canDisplace as os, MaterializedModelIdentity as ot, Strategy as ou, gateOnDeliverable as ov, Redactor as ow, writeWorkerSteer as ox, DelegationTaskQueue as oy, KnowledgeReadinessDecision as p, WorktreeCheckRunner as pC, LeaderboardOptions as pS, SandboxClient as pT, AgentEnvironment$1 as p_, patchDelivered as pa, buildDelegationTraceSpans as pb, StartRetainedInteractiveRunOptions as pc, Verify as pd, SupervisePursuitError as pf, AUTHORITY_MARKERS as pg, hostDirectoryReader as ph, GitWorkspaceOptions as pi, Environment as pl, UNPROVEN_CONTINUITY as pm, DriverReentry as pn, runGraphWithTestBrain as po, createFileRunContext as pp, SpawnRefusalCause as pr, officialChecksFromMeta as ps, ProviderModelAttemptEvidence as pt, adaptiveRefine as pu, ToolLoopCompaction as pv, JudgeError as pw, ContinuationContext as px, DelegateCodeResult as py, ExecutorExecutionBinding as q, FileSpawnJournal as qC, createOpenInferenceFileExporter as qS, RetainedRunHandle as qT, UnavailablePausePolicy as q_, rollingDispatch as qa, supervisorRunsRoot as qb, selectValidWinner as qc, checkProgramDigest as qd, superviseFleetCapabilities as qf, SharedBoxProcess as qg, SessionTraceBox as qh, settledToIteration as qi, StdioMcpConnection as ql, HarnessTranscriptUnavailable as qm, EventAcknowledgement as qn, supervisorInstructions as qo, DEFAULT_DEADLINE_WARNING_MS as qp, failuresAnalyst as qr, AcquireOptions as qs, TraceRootReceipt as qt, FlatWidenGate as qu, DriveTurnTick as qv, LoopDecisionPayload as qw, createCodexRolloutStoreReader as qx, KnowledgeUpdate as qy, AgentBackendInput as r, RuntimeStreamEventSummary as rC, CodeModeToolsOptions as rS, LoopStartedPayload as rT, SandboxUsageLedger as r_, provisionSupervisor as ra, createPropagatingTraceEmitter as rb, claimRetainedInteractiveControl as rc, RenderCorpusToInstructions as rd, JudgedPursuitVersion as rf, ScopeProgressInput as rg, RetainedHarnessTranscriptDescriptor as rh, NOTE_MAX_CHARS as ri, McpEndpoint as rl, StopRule as rm, WorkspaceCheckpointMarker as rn, EdgeTraversal as ro, withWorkerSpawnRetry as rp, QuestionEscalationTarget as rr, StructuralRolloutPolicy as rs, Handle as rt, CorpusReadbackOptions as ru, ProviderPlacement as rv, materializeTreeView as rw, workerSteerRequestFile as rx, DelegationResumeDriver as ry, AgentRuntimeEventSink as s, createRuntimeEventCollector as sC, describeCodeModeTools as sS, LoopTraceEvent as sT, extractLlmCallEvent as s_, loadProfile as sa, CappedDelegationTrace as sb, ReconnectRetainedInteractiveRunOptions as sc, ScopeWidenGate as sd, PursuitVersionStop as sf, readWorkerProgress as sg, ResolvedSpawnResourcePath as sh, composeWorkerEvidence as si, BenchmarkCell as sl, createProgressTracker as sm, DriverBudgetReadout as sn, GraphResult as so, SeatStage as sp, QuestionRecord as sr, compareCheckOutcomes as ss, NoWinnerError as st, StrategyArtifacts as su, mapExecutorResult as sv, defaultRedactor as sw, AdmittedFinding as sx, DelegationTaskQueueOptions as sy, AgentAdapter as t, RuntimeStreamEventCollector as tC, CodeModeTool as tS, LoopResult as tT, SandboxServedBackend as t_, ProvisionedSupervisor as ta, researcherProfile as tb, startRetainedRunInEnvironment as tc, Pipeline as td, IsolatedCheckResult as tf, DEFAULT_STALL_AFTER_MS as tg, HarnessTranscriptReadOptions as th, readWorkerInteractiveBinding as ti, registryScopeAnalyst as tl, ProgressView as tm, WorkerTraceEvidence as tn, AgentGraph as to, resolveWorkerSpawnRetry as tp, QuestionEscalationOutcome as tr, StructuralRolloutConfig as ts, ExecutorToolCall as tt, AgenticTool as tu, ProviderWorkspaceRetentionContext as tv, SpawnForestTree as tw, workerSteerAcknowledgementFile as tx, DelegationRecord as ty, AgentTaskSpec as u, sanitizeKnowledgeReadinessReport as uC, GroupOf as uS, MountRecorder as uT, sandboxEventServedBackend as u_, profileRunsForName as ua, DelegationTraceCaps as ub, RetainedInteractiveEnvironmentInput as uc, TrajectoryReport as ud, VersionJudge as uf, InboxMessage as ug, SpawnResourceRead as uh, UntrackedCopyStats as ui, BenchmarkReport as ul, sampleFromSettled as um, DriverFailureClass as un, TraversalContinuity as uo, InMemoryRunContextOptions as up, SpawnPreflight as ur, defaultStructuralRolloutPolicy as us, NodeSnapshot as ut, StrategyResult as uu, ToolSpec as uv, AgentEvalErrorCode as uw, CheckUnavailableError as ux, hashIdempotencyInput as uy, RunAgentTaskStreamOptions as v, DiffOptions as vC, ScoreOf as vS, RuntimeRunCost as vT, AgentEnvironmentProviderRegistry as v_, InteractiveWorkerKeyInput as va, DelegationStateCorruptError as vb, assertModelAllowed as vc, WidenSpec as vd, RUN_FORK_CORRELATION_KEYS as vf, PeerMailLimits as vg, createMcpServer as vh, gitWorkspace as vi, LoopOptionsForDispatch as vl, SupervisorFinalizer as vm, upstreamUnavailableSignal as vn, createPromptRegistry as vo, SupervisorSpanOutcome as vp, WorkerWatchOptions as vr, visibleCheckScore as vs, ResultBlobStore as vt, runAgentic as vu, JsonRpcResponse as vv, RetainedRunAdmissionError as vw, ContinuationPanelResult as vx, DelegateResearchResult as vy, RuntimeFailureCode as w, createWorktree as wC, renderPairwiseMarkdown as wS, startRuntimeRun as wT, AgentSessionRef as w_, createInPlaceCliExecutor as wa, CoderTask as wb, StreamAgentTurnOptions as wc, Persona as wd, PursuitNodeProjection as wf, PeerMailboxOptions as wg, DelegateHandlerOptions as wh, WORKER_TOOL_TRACE_SCHEMA_VERSION as wi, RunAgentRoundsOptions as wl, CoordinationMcpHandle as wm, AnalystLensOutput as wn, naiveContinuationPrompt as wo, workerTraceEnv as wp, parseAuthoredAnalystDefinition as wr, TournamentCell as ws, RootProviderModelEvidence as wt, HarvestReport as wu, InMemoryFeedbackStore as wv, DeadlineCheckIn as ww, admitFinding as wx, DelegationFeedbackSnapshot as wy, RuntimeSessionStore as x, RemoveWorktreeOptions as xC, renderLeaderboardHtml as xS, RuntimeRunPersistenceAdapter as xT, AgentEnvironmentSummary as x_, workerFromInteractiveProvider as xa, FileDelegationStoreOptions as xb, AgentTurnInput$1 as xc, DefinePersonaInput as xd, PursuitNodeCost as xf, PeerMailRefusal as xg, DELEGATE_TOOL_NAME as xh, runInWorkspace as xi, loopCampaignDispatch as xl, pickBestDelivered as xm, AnalystDefinitionIssue as xn, dumbContinuationPassPrompt as xo, WorkerTraceResolver as xp, createCoordinationTools as xr, EvolutionStrategy as xs, RetainedExecutionState as xt, HarvestCorpusOptions as xu, McpTransport as xv, ValidationError as xw, PanelFinding as xx, DelegateUiAuditResult as xy, RuntimeCanonicalStreamEvent as y, DiffResult as yC, leaderboard as yS, RuntimeRunHandle as yT, AgentEnvironmentQuery as y_, InteractiveWorkerOptions as ya, DelegationStore as yb, assertProfileModelsAllowed as yc, WinnerStrategy as yd, PursuitObserverDelivery as yf, PeerMailOutcome as yg, DELEGATE_DESCRIPTION as yh, jjWorkspace as yi, SuperviseDispatchOptions as yl, bestDelivered as ym, ANALYST_DEFINITION_BOUNDS as yn, delegatesWorkerBriefPrompt as yo, SupervisorSpanRecorder as yp, analystToolGroupNames as yr, EvolutionAuthor as ys, ResumedKeyState as yt, sample as yu, McpToolAnnotations as yv, RetainedRunDispatchBindingError as yw, ContinuationPolicy as yx, DelegateUiAuditArgs as yy, BudgetViolation as z, SqlRunOwnershipError as zC, OtelExportConfig as zS, RetainedRunAdmission as zT, WorkspaceRequest as z_, storedGraphDigests as za, readWorkerCancelRequests as zb, FileCorpus as zc, LeaderboardScenario as zd, AuthorizedSpawnContext as zf, secretEnvOfMcpServer as zg, createExecutor as zh, SearchSpecOwnedOption as zi, InProcessPromptCtx as zl, BusStats as zm, CoordinationTools as zn, createChatSessionStore as zo, SupervisorNodeContextSeed as zp, SurfaceReadOutcome as zr, SandboxRunAbortError as zs, SpendGap as zt, EqualKArm as zu, FleetWorkspaceExecutorOptions as zv, ReserveOptions as zw, CodexForkBoundary as zx, delegationProfiles as zy };
-//# sourceMappingURL=types-ytkoP4VV.d.ts.map
+export { ExecutorResult as $, InMemorySpawnJournal as $C, generateSpanId as $S, RetainedRunReplayPoint as $T, ProviderNativeCapturePhase as $_, DesignerRunGraphEnv as $a, workerCancelRequestsFile as $b, loopDispatch as $c, PursuitCostProvenance as $d, SeatStage as $f, SharedWorkerIdentity as $g, TraceSource as $h, RemoteWorkerEvents as $i, HarvestError as $l, ReadableEnvironment as $m, ManagerWake as $n, StrategyEvolutionConfig as $o, AllWorkersStalledOptions as $p, AttachWorkerOptions as $r, AgentTurnUsage as $s, WorkerInteractiveSession as $t, LoopShape as $u, createDetachedTurnResumeDriver as $v, LoopIterationDispatchPayload as $w, readCodexRolloutSession as $x, ResearchOutput as $y, TRACE_ROOT_SCHEMA as A, CodexExecutionEvidence as AC, AnytimeStrategySummary as AS, WorkerEventEntry as AT, AgentTurnResult$2 as A_, StoredGraph as Aa, RunCancelRequest as Ab, buildSteerContext as Ac, IsolatedCheckBoxEvidence as Ad, AuthorizedSpawn as Af, createPeerMailbox as Ag, createDelegateHandler as Ah, workerTraceAnalysisStore as Ai, AgenticSurface as Al, CoordinationReadAccess as Am, AuthoredAnalystLimits as An, CheckSourceCtx as Ao, promptHandle as Ap, CreateSandboxOptions$1 as Ar, recoverRetainedRun as As, Scope as At, PanelSpec as Au, CoderDelegate as Av, createWorkerSlots as Aw, distillFindings as Ax, DelegationHistoryEntry as Ay, EnvironmentTeardownReceipt as B, parseCodexTokenUsage as BC, createWaterfallCollector as BS, RetainedInteractiveEnvironmentAdmission as BT, ProviderLeafOut as B_, recordGraphRun as Ba, legacySupervisorRunsRoot as Bb, BenchmarkLift as Bc, SettledPursuitVersion as Bd, superviseWithTestBrain as Bf, mcpSecretEnvMetadataKey as Bg, SandboxSeam as Bh, SearchSpecInputs as Bi, StrategyMessage as Bl, PriorCoordination as Bm, CoordinationToolsOptions as Bn, defaultExtractCandidate as Bo, SupervisorAgentDeps as Bp, SurfaceReadBox as Br, RetainedInteractiveAdmissionHook as Bs, SteerableRootHandle as Bt, TrajectoryNode as Bu, settleDetachedCoderTurn as Bv, ReservationStage as Bw, deterministicCompletion as Bx, ResearchOutputShape as By, RuntimeFailureCause as C, DiffResult as CC, leaderboard as CS, RuntimeRunHandle as CT, AgentEnvironmentQuery as C_, workerFromInteractiveProvider as Ca, DelegationStore as Cb, pipeline as Cc, assertDeclaredCheck as Cd, GraphResult as Cf, PeerMailOutcome as Cg, DELEGATE_DESCRIPTION as Ch, runInWorkspace as Ci, McpToolDescriptor as Cl, bestDelivered as Cm, AnalystKind as Cn, profileRichnessFinding as Co, createPromptRegistry as Cp, createCoordinationTools as Cr, createSandboxLineage as Cs, RootMaterialization as Ct, FanoutWinnerSelector as Cu, McpToolAnnotations as Cv, RetainedRunDispatchBindingError as Cw, ContinuationPolicy as Cx, DelegateUiAuditArgs as Cy, runtimeFailureCause as D, captureWorktreeDiff as DC, renderLeaderboardSvg as DS, RuntimeRunStatus as DT, AgentSession as D_, GraphRegistryDir as Da, CoderOutput as Db, CreateScopeAnalystOptions as Dc, declaredCheckJudge as Dd, runGraph as Df, PeerMailbox as Dg, DelegateError as Dh, WorkerToolTraceArtifact as Di, materializeLocalMcp as Dl, CoordinationAuthentication as Dm, AnalystToolGroupName as Dn, CheckRunContext as Do, formatPromptHandle as Dp, questionEscalationTargets as Dr, S3PrivateCasStoreOptions as Ds, RootSignal as Dt, LoopUntilState as Du, FeedbackStore as Dv, DEFAULT_CHECK_IN_IDLE_MS as Dw, admitContinuationPolicy as Dx, DelegationError as Dy, RuntimeFailureOwner as E, WorktreeHandle as EC, renderLeaderboardMarkdown as ES, RuntimeRunRow as ET, AgentProfileRef as E_, createInPlaceCliExecutor as Ea, InMemoryDelegationStore as Eb, widen as Ec, declaredCheckDigest as Ed, TraversalContinuity as Ef, PeerMailSendInput as Eg, DelegateArgs as Eh, WORKER_TOOL_TRACE_SCHEMA_VERSION as Ei, connectStdioMcp as El, runFinalizer as Em, AnalystRunContext as En, CheckOutcome as Eo, dumbContinuationPassPrompt as Ep, parseAuthoredAnalystDefinition as Er, S3PrivateCasStore as Es, RootSegmentEntry as Et, LoopUntilSpec as Eu, FeedbackEvent as Ev, DEADLINE_CHECK_IN_MESSAGE as Ew, VerdictSummary as Ex, DelegateUiAuditRoute as Ey, AgentExecutionRef as F, LocalHarness as FC, plateauLength as FS, ReconnectRetainedRunOptions as FT, ExecResult as F_, graphRunsFor as Fa, WorkerSteerRequest as Fb, McpEnvironmentOptions as Fc, NextPursuitVersion as Fd, SuperviseRegistry as Ff, BridgeModelCredential as Fg, CliWorktreeSeam as Fh, SqlRunContextOptions as Fi, RunAgenticOptions as Fl, CoordinationRejectReason as Fm, ContinuationInstruction as Fn, StructuralRolloutResult as Fo, DriveHarnessOwnerContext as Fp, VerifierEnvironmentOptions as Fr, reconnectRetainedInteractiveRun as Fs, SpawnPrior as Ft, RenderCorpusToInstructionsOptions as Fu, DetachedWinnerSelection as Fv, LeakedReservation as Fw, CompletionAnalyst as Fx, DelegationStatus as Fy, ExecutorCancellationRequest as G, openSqlRunStore as GC, OtelExporter as GS, RetainedRunCancelOptions as GT, providerAsExecutor as G_, DispatchUnit as Ga, readWorkerSteerAcknowledgement as Gb, printBenchmarkReport as Gc, SupervisePursuitError as Gd, WorkerSpawnRetryPolicy as Gf, DEFAULT_SHARED_BOX_WORKERS as Gg, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Gh, searchSpecDigest as Gi, breadthStrategy as Gl, PublishOptions as Gm, DownMessageEvent as Gn, resolveEntrySymbol as Go, SupervisorToolDescriptor as Gp, fsSurfaceReader as Gr, ResolveSandboxClientOptions as Gs, SupervisorOpts as Gt, VerifySpec as Gu, createFleetWorkspaceExecutor as Gv, spendFromUsageEvents as Gw, CodexRolloutSession as Gx, UI_LENSES as Gy, Executor as H, SqlRunLease as HC, OtelAttribute as HS, RetainedInteractiveStartedAdmission as HT, ResourceRequest as H_, taskShapeDigest as Ha, readRunCancellation as Hb, BenchmarkStrategySummary as Hc, VersionVerdict as Hd, ResolvedWorkerSpawnRetry as Hf, resolveSecretEnv as Hg, cliWorktreeExecutor as Hh, assertSearchSpec as Hi, StrategyShotResult as Hl, BusRecord as Hm, DownMessageAuthorizationInput as Hn, filterAuthoredAsserts as Ho, SupervisorNodeContext as Hp, SurfaceReader as Hr, RetainedInteractiveRunHandle as Hs, SubtreeSummary as Ht, TrajectoryReportFn as Hu, FleetHandle as Hv, ReservationWaitRefused as Hw, stopSentinel as Hx, UiAuditorDelegationOutput as Hy, AgentSpec as I, LocalHarnessResult as IC, renderAnytimeTable as IS, RecoverRetainedRunIntentOptions as IT, ForkRequest as I_, listGraphRuns as Ia, WriteWorkerSteerOptions as Ib, createMcpEnvironment as Ic, NextPursuitVersionInput as Id, SuperviseRegistryTable as If, BridgeSeam as Ig, ExecutorConfig as Ih, createFencedSqlRunContext as Ii, ShotSpec as Il, CoordinationDeliveryEvidence as Im, ContinuityMode as In, VisibleCheck as Io, ObserveSupervisorNodeEvent as Ip, createVerifierEnvironment as Ir, recoverRetainedInteractiveRun as Is, SpawnRejection as It, ScopeAnalyst as Iu, SettleDetachedCoderTurnOptions as Iv, ReservationFloor as Iw, CompletionEvidence as Ix, DelegationStatusArgs as Iy, ExecutorFactory as J, SqlAdapter as JC, buildLoopOtelSpans as JS, RetainedRunEffect as JT, CreateTangleSandboxExactProcessProviderOptions as J_, queueOf as Ja, runCancellationFile as Jb, LoopDispatchOptions as Jc, superviseGraphPursuit as Jd, retryPreSpawnRefusals as Jf, SharedBoxHandle as Jg, SteerableSandboxSession as Jh, createScope as Ji, refine as Jl, HarnessTranscriptCapture as Jm, GraphSubtaskPreparation as Jn, structuralRollout as Jo, resolveSupervisorProfile as Jp, analystsFromRegistry as Jr, profileOptimizerModelCall as Js, TreeView as Jt, WidenLineage as Ju, DetachedTurn as Jv, Driver as Jw, CodexRolloutTurn as Jx, UiFindingSeverity as Jy, ExecutorContext as K, D1DatabaseLike as KC, OtelSpan as KS, RetainedRunCancellation as KT, providerAsSandboxClient as K_, RollingDispatchOptions as Ka, readWorkerSteerRequests as Kb, runBenchmark as Kc, SupervisePursuitOptions as Kd, isPreSpawnExecutorFailure as Kf, ROUTER_CLIENT_HEADER as Kg, SandboxSteeringOptions as Kh, SUBTREE_RESULT_LIMIT as Ki, defineStrategy as Kl, createEventBus as Km, EscalateQuestion as Kn, sandboxCheckRunner as Ko, SupervisorToolInvocationContext as Kp, harvestSurfaceDiffs as Kr, resolveSandboxClient as Ks, TokenUsageProvenance as Kt, Widen as Ku, createSiblingSandboxExecutor as Kv, AgentRunSpec as Kw, CodexRolloutStoreReader as Kx, UiFinding as Ky, Budget as L, RunLocalHarnessOptions as LC, WaterfallCollector as LS, RecoverRetainedRunOptions as LT, PlacementInfo as L_, loadGraph as La, cancelRun as Lb, sanitizeMcpToolSchema as Lc, PursuitVersionChain as Ld, SuperviseTestOptions as Lf, KeyProvider as Lg, ProviderSeam as Lh, CompiledSearchSpec as Li, Strategy as Ll, CoordinationLog as Lm, CoordinationEvent as Ln, canDisplace as Lo, ResolveDriveHarness as Lp, BoxSurfaceReaderOptions as Lr, startRetainedInteractiveRun as Ls, Spend as Lt, ScopeAnalyzeInput as Lu, UiAuditorDelegate as Lv, ReservationHolder as Lw, CompletionPolicy as Lx, DelegationStatusResult as Ly, TraceRootArtifact as M, CodexTokenUsage as MC, anytimeReport as MS, NativeContextContinuationExecution as MT, CheckpointRequest as M_, graphDigest as Ma, WorkerCancelRequest as Mb, registryScopeAnalyst as Mc, IsolatedCheckResult as Md, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as Mf, peerMailTools as Mg, CliInPlaceSeam as Mh, createRootHandle as Mi, AgenticTool as Ml, serveCoordinationMcp as Mm, AuthorizedDownMessage as Mn, StructuralRolloutConfig as Mo, CoordinationToolFace as Mp, SandboxInstance$1 as Mr, startRetainedRunInEnvironment as Ms, SpawnEvent as Mt, Pipeline as Mu, CoderReviewer as Mv, BudgetPoolRestore as Mw, failedItems as Mx, DelegationProfile as My, TraceSummary as N, DEFAULT_LOCAL_HARNESS as NC, areaUnderCurve as NS, NativeContextContinuationHandle as NT, CreateAgentEnvironmentInput$1 as N_, graphFromStored as Na, WorkerCancellation as Nb, observationFromRegistry as Nc, runIsolatedCheck as Nd, DeliverableResolutionInput as Nf, peerMailVerbNames as Ng, CliSeam as Nh, createSupervisor as Ni, ArtifactHandle as Nl, CoordinationHttpAudit as Nm, AwaitWakeInput as Nn, StructuralRolloutMessage as No, CoordinationVerbs as Np, computeFindingId$1 as Nr, ClaimRetainedInteractiveControlOptions as Ns, SpawnJournal as Nt, PipelineStage as Nu, DelegateRunCtx as Nv, BudgetReadout as Nw, passedItems as Nx, DelegationProgress as Ny, settlementFailureCause as O, createWorktree as OC, renderPairwiseMarkdown as OS, startRuntimeRun as OT, AgentSessionRef as O_, GraphRunRecord as Oa, CoderTask as Ob, RegistryAnalyzeProjection as Oc, readDeclaredCheck as Od, runGraphWithTestBrain as Of, PeerMailboxOptions as Og, DelegateHandlerOptions as Oh, captureWorkerTraceEvidence as Oi, AgenticOptions as Ol, CoordinationMcpHandle as Om, AnalyzeOnSettleRoute as On, CheckRunner as Oo, kernelPromptRegistry as Op, AgentProfile$2 as Or, createS3PrivateCasStore as Os, RootStreamReceipt as Ot, Panel as Ou, InMemoryFeedbackStore as Ov, DeadlineCheckIn as Ow, admitFinding as Ox, DelegationFeedbackSnapshot as Oy, Agent as P, LOCAL_HARNESSES as PC, bestSoFar as PS, NativeContextContinuationInput as PT, ExecRequest as P_, graphRegistry as Pa, WorkerSteerAcknowledgement as Pb, McpEndpoint as Pc, JudgedPursuitVersion as Pd, SuperviseOptions as Pf, BridgeHarnessStore as Pg, CliWorktreeBridgeSeam as Ph, FencedSqlRunContext as Pi, CorpusReadbackOptions as Pl, CoordinationHttpOptions as Pm, BlockedToolReport as Pn, StructuralRolloutPolicy as Po, DriveHarness as Pp, makeFinding$1 as Pr, claimRetainedInteractiveControl as Ps, SpawnOpts as Pt, RenderCorpusToInstructions as Pu, DetachedSessionDelegateOptions as Pv, BudgetReconcileFault as Pw, verdictFromJudgeScore as Px, DelegationResultPayload as Py, ExecutorRegistry as Q, InMemoryResultBlobStore as QC, createOtelExporter as QS, RetainedRunIntentAdmission as QT, ProviderCheckpointCaptureContext as Q_, watchTrace as Qa, supervisorWorkersDir as Qb, loopCampaignDispatch as Qc, PursuitObserverDelivery as Qd, SeatSelectionInput as Qf, SharedBoxStats as Qg, ToolStepInput as Qh, RemoteSupervisorTree as Qi, HarvestCorpusOptions as Ql, HarnessTranscriptUnavailableReason as Qm, ManagerReentryState as Qn, EvolutionStrategy as Qo, ManagerWakePolicy as Qp, worktreeFanout as Qr, AgentTurnInput$1 as Qs, WidenGate as Qt, DefinePersonaInput as Qu, RunDetachedTurnOptions as Qv, LoopEndedPayload as Qw, harnessUsageIsEmpty as Qx, MultiHarnessResearcherFanoutOptions as Qy, BudgetOverspend as R, harnessSupportsReasoningEffort as RC, WaterfallReport as RS, RecoverRetainedRunResult as RT, ProviderAsSandboxClientOptions as R_, lookupGraph as Ra, cancelWorker as Rb, BenchmarkCell as Rc, PursuitVersionStop as Rd, supervise as Rf, ResolvedMcpServerLaunch as Rg, RouterSeam as Rh, SEARCH_SPEC_CORRELATION_KEY as Ri, StrategyArtifacts as Rl, CoordinationOwnerId as Rm, CoordinationStats as Rn, compareCheckOutcomes as Ro, ResolveSupervisorTools as Rp, HarvestSurfaceDiffsOptions as Rr, ReconnectRetainedInteractiveRunOptions as Rs, SpendChannel as Rt, ScopeWidenGate as Ru, coderTaskFromArgs as Rv, ReservationRejection as Rw, CompletionVerdict as Rx, FeedbackRating as Ry, RuntimeStreamEvent as S, DiffOptions as SC, ScoreOf as SS, RuntimeRunCost as ST, AgentEnvironmentProviderRegistry as S_, InteractiveWorkerResult as Sa, DelegationStateCorruptError as Sb, panel as Sc, DeclaredCheckStateCapture as Sd, GraphNode as Sf, PeerMailLimits as Sg, createMcpServer as Sh, localShell as Si, McpSpawnFault as Sl, SupervisorFinalizer as Sm, AnalystFindingEvent as Sn, defaultProfileRichnessThresholds as So, analyzesFindingsReportPrompt as Sp, canonicalFindingEvent as Sr, SessionCapableBox as Ss, RootHandle as St, FanoutSynthesis as Su, JsonRpcResponse as Sv, RetainedRunAdmissionError as Sw, ContinuationPanelResult as Sx, DelegateResearchResult as Sy, RuntimeFailureContext as T, RemoveWorktreeOptions as TC, renderLeaderboardHtml as TS, RuntimeRunPersistenceAdapter as TT, AgentEnvironmentSummary as T_, InPlaceCliExecutorOptions as Ta, FileDelegationStoreOptions as Tb, verify as Tc, declaredCheckDeliverable as Td, RunGraphTestOptions as Tf, PeerMailRefusal as Tg, DELEGATE_TOOL_NAME as Th, analyzeTrace as Ti, StdioMcpServerSpec as Tl, pickBestDelivered as Tm, AnalystRegistry$1 as Tn, CheckExecChannel as To, dumbContinuationFailPrompt as Tp, normalizeAnalyzeOnSettle as Tr, acquireSandbox as Ts, RootSegment as Tt, LoopUntil as Tu, McpTransport as Tv, ValidationError as Tw, PanelFinding as Tx, DelegateUiAuditResult as Ty, ExecutorAccounting as U, SqlRunOwnershipError as UC, OtelExportConfig as US, RetainedRunAdmission as UT, WorkspaceRequest as U_, DispatchReport as Ua, readWorkerCancelRequests as Ub, BenchmarkTaskRow as Uc, assertPursuitVersions as Ud, WorkerSpawnRetryAttempt as Uf, secretEnvOfMcpServer as Ug, createExecutor as Uh, compileSearchSpec as Ui, SurfaceScore as Ul, BusStats as Um, DownMessageDeliveryAttempt as Un, modelAuthoredChecks as Uo, SupervisorNodeContextSeed as Up, WatchedSurface as Ur, RetainedInteractiveStartMaterial as Us, SupervisedResult as Ut, TrajectoryReportOptions as Uu, FleetWorkspaceExecutorOptions as Uv, ReserveOptions as Uw, CodexForkBoundary as Ux, delegationProfiles as Uy, ExecutionBindingReceipt as V, runLocalHarness as VC, LoopSpanNode as VS, RetainedInteractiveIntentAdmission as VT, ProviderPromptOptions as V_, storedGraphDigests as Va, readRunCancelRequest as Vb, BenchmarkReport as Vc, VersionJudge as Vd, workerFromBackend as Vf, resolveMcpServerLaunch as Vg, cliInPlaceExecutor as Vh, SearchSpecOwnedOption as Vi, StrategyResult as Vl, BusEvent as Vm, DefinedAnalystRecord as Vn, defaultStructuralRolloutPolicy as Vo, SupervisorAgentTestDeps as Vp, SurfaceReadOutcome as Vr, RetainedInteractiveEnvironmentInput as Vs, SubtreeResult as Vt, TrajectoryReport as Vu, DelegationExecutor as Vv, ReservationTicket as Vw, sentinelCompletion as Vx, UiAuditLensFilter as Vy, ExecutorCancellation as W, SqlRunStoreOptions as WC, OtelExportStats as WS, RetainedRunAdmissionHook as WT, createAgentEnvironmentProviderRegistry as W_, DispatchStopReason as Wa, readWorkerCancellation as Wb, Environment as Wc, SuperviseGraphPursuitOptions as Wd, WorkerSpawnRetryHooks as Wf, DEFAULT_SHARED_BOX_RESOURCES as Wg, createExecutorRegistry as Wh, searchPresets as Wi, adaptiveRefine as Wl, EventBus as Wm, DownMessageDeliveryOutcome as Wn, officialChecksFromMeta as Wo, SupervisorProfile as Wp, boxSurfaceReader as Wr, StartRetainedInteractiveRunOptions as Ws, Supervisor as Wt, Verify as Wu, SiblingSandboxExecutorOptions as Wv, createBudgetPool as Ww, CodexRolloutIdentity as Wx, UI_FINDING_SEVERITIES as Wy, ExecutorNodeContext as X, FileResultBlobStore as XC, buildRuntimeEventOtelSpans as XS, RetainedRunEventOptions as XT, createTangleSandboxExactProcessProvider as X_, WatchTraceOptions as Xa, supervisorRunDir as Xb, SuperviseDispatchOptions as Xc, PursuitFork as Xd, SeatSegment as Xf, SharedBoxPlacementOptions as Xg, SessionMessageLike as Xh, RemoteSupervisorAgent as Xi, sample as Xl, HarnessTranscriptFile as Xm, LeadMessage as Xn, EvolutionAuthor as Xo, supervisorAgentWithTestBrain as Xp, AuthoredHarness as Xr, assertProfileModelsAllowed as Xs, UnknownMaterializationReason as Xt, WinnerStrategy as Xu, DriveTurnCapableBox as Xv, Iteration as Xw, addHarnessUsage as Xx, KnowledgeItem as Xy, ExecutorMaterialization as Y, d1ToSqlAdapter as YC, buildLoopSpanNodes as YS, RetainedRunEnvironmentAdmission as YT, SandboxControlClient as Y_, rollingDispatch as Ya, safeWorkerFile as Yb, LoopOptionsForDispatch as Yc, supervisePursuit as Yd, withWorkerSpawnRetry as Yf, SharedBoxPlacement as Yg, createSteerableSandboxSession as Yh, settledToIteration as Yi, runAgentic as Yl, HarnessTranscriptEvidence as Ym, GraphSubtasks as Yn, visibleCheckScore as Yo, supervisorAgent as Yp, failuresAnalyst as Yr, assertModelAllowed as Ys, UnconfirmedTeardown as Yt, WidenSpec as Yu, DetachedTurnResumeDriverOptions as Yv, ExecCtx as Yw, CodexStoreDelta as Yx, UiLens as Yy, ExecutorProgressEvent as Z, FileSpawnJournal as ZC, createOpenInferenceFileExporter as ZS, RetainedRunHandle as ZT, UnavailablePausePolicy as Z_, defaultToolDetectors as Za, supervisorRunsRoot as Zb, SuperviseOptionsForDispatch as Zc, RUN_FORK_CORRELATION_KEYS as Zd, SeatSelection as Zf, SharedBoxProcess as Zg, SessionTraceBox as Zh, RemoteSupervisorReader as Zi, sampleThenRefine as Zl, HarnessTranscriptUnavailable as Zm, MakeWorkerAgent as Zn, EvolutionReport as Zo, DEFAULT_DEADLINE_WARNING_MS as Zp, WorktreeFanoutOptions as Zr, AgentTurnBackend as Zs, UsageEvent as Zt, DefinePersona as Zu, DriveTurnTick as Zv, LoopDecisionPayload as Zw, createCodexRolloutStoreReader as Zx, KnowledgeUpdate as Zy, RunAgentTaskOptions as _, WorktreeCheckRunner as _C, LeaderboardOptions as _S, SandboxClient as _T, AgentEnvironment$1 as __, WorktreePatchArtifact as _a, buildDelegationTraceSpans as _b, InMemoryCorpus as _c, LeaderboardScore as _d, AgentGraph as _f, AUTHORITY_MARKERS as _g, hostDirectoryReader as _h, Workspace as _i, InProcessSandboxClientOptions as _l, UNPROVEN_CONTINUITY as _m, summarizeDriverAttempts as _n, AuthoredProfile as _o, workerTraceHeaders as _p, ToolOutcomeEvent as _r, TurnResult as _s, ResourceSpend as _t, EqualKOnCost as _u, ToolLoopCompaction as _v, JudgeError as _w, ContinuationContext as _x, DelegateCodeResult as _y, AgentKnowledgeProvider as a, RuntimeStreamEventCollector as aC, CodeModeTool as aS, LoopResult as aT, SandboxServedBackend as a_, provisionSupervisor as aa, researcherProfile as ab, PrivateCasDurableStore as ac, RunPersonifiedOptions as ad, PursuitNodeUsage as af, DEFAULT_STALL_AFTER_MS as ag, HarnessTranscriptReadOptions as ah, NOTE_MAX_CHARS as ai, isTerminalDecision as al, ProgressView as am, DriverAttemptStop as an, delegate as ao, createFileRunContext as ap, QuestionEscalationTarget as ar, AuthorStrategyOptions as as, MaterializedExecutionIdentity as at, ObservationError as au, ProviderWorkspaceRetentionContext as av, SpawnForestTree as aw, workerSteerAcknowledgementFile as ax, DelegationRecord as ay, RuntimeSession as b, WorktreeProfileMaterializationReceipt as bC, PairwiseVerdict as bS, Validator as bT, AgentEnvironmentProvider$1 as b_, InteractiveWorkerKeyInput as ba, createDelegationTraceCollector as bb, flatWidenGate as bc, DeclaredCheck as bd, GraphEdge as bf, PeerMailEnvelope as bg, McpServerOptions as bh, gitWorkspace as bi, LocalMcpMaterialization as bl, FinalizeContext as bm, AnalystAssignmentRecord as bn, asAuthoredProfile as bo, PromptRegistry as bp, WorkerWatchOptions as br, SandboxLineage as bs, ResumedWork as bt, Fanout as bu, ToolLoopToolCall as bv, RetainedInteractiveAdmissionError as bw, ContinuationPanel as bx, DelegateResearchArgs as by, AgentTaskContext as c, RuntimeTelemetryOptions as cC, CodeModeToolset as cS, LoopTeardownFailedPayload as cT, assertSandboxServedModel as c_, bestProfileFor as ca, mergeTraceEnv as cb, createPrivateCasArtifactPort as cc, ShapeRegistry as cd, PursuitRunTotals as cf, TeamProgress as cg, resolveHarnessTranscriptCapture as ch, closingWorkerNote as ci, SandboxEvidenceReceipt as cl, allOf as cm, DriverContinuationRecord as cn, finalizeBestDelivered as co, SupervisorSpanAttributes as cp, QuestionPolicy as cr, authorStrategy as cs, NodeExecutionIdentity as ct, defaultAnalystInstruction as cu, DeliverableSpec as cv, replaySpawnTree as cw, workerSteerRequestsDir as cx, DelegationResumeTick as cy, AgentTaskStatus as d, createRuntimeEventCollector as dC, describeCodeModeTools as dS, LoopTraceEvent as dT, extractLlmCallEvent as d_, profileRegistry as da, CappedDelegationTrace as db, builtinShapes as dc, LeaderboardBenchTask as dd, FileObserverJournal as df, readWorkerProgress as dg, ResolvedSpawnResourcePath as dh, CopyOptions as di, captureBeforeDestroy as dl, createProgressTracker as dm, DriverLoopRecord as dn, ChatTransportExecutorOptions as do, SupervisorSpanRecorder as dp, SettledWorker as dr, Deliverable as ds, NodeStatus as dt, AssertTraceDerivedFindings as du, mapExecutorResult as dv, defaultRedactor as dw, AdmittedFinding as dx, DelegationTaskQueueOptions as dy, loopEventToOtelSpan as eC, RetainedRunSnapshot as eE, HarnessUsage as eS, LoopIterationEndedPayload as eT, sharedBoxPlacement as e_, connectRemoteSupervisor as ea, ResearchSource as eb, CollectedAgentTurn as ec, Outcome as ed, PursuitNodeCost as ef, createPushTraceSource as eg, captureHarnessTranscript as eh, WorkerInteractiveBinding as ei, superviseDispatch as el, NoProgressForOptions as em, WorkerInteractiveUnavailableReason as en, DesignerToolsEnv as eo, SelectSeat as ep, PeerAuditAccess as er, StrategyTournament as es, ExecutorTeardownWarning as et, HarvestFailure as eu, ProviderWorkspaceAttemptProvenance as ev, SpawnForest as ew, workerCancellationFile as ex, detachedTurnEvents as ey, BackendErrorDetail as f, createRuntimeStreamEventCollector as fC, runCodeMode as fS, LoopWinner as fT, mapSandboxEvent as f_, profileRunsForName as fa, DELEGATION_TRACE_MAX_BYTES as fb, createShapeRegistry as fc, LeaderboardBenchmarkAdapter as fd, ObserverJournal as ff, AuthorityInboxMessage as fg, SPAWN_RESOURCE_PATH_MAX_BYTES as fh, UntrackedCopyStats as fi, LocalSandboxClientOptions as fl, noProgressFor as fm, DriverProgressMark as fn, ChatTransportTool as fo, createSupervisorSpanRecorder as fp, SpawnPreflight as fr, OpenSandboxRunBeforeStartContext as fs, ProfileMaterializationReceipt as ft, CombinatorShape as fu, RouterResponseReceipt as fv, resolveRedactor as fw, CONTINUATION_FACTS as fx, SubmitInput as fy, OpenAIChatToolChoice as g, InPlaceHarnessResult as gC, Leaderboard as gS, RunProvenance as gT, sumSandboxUsage as g_, WorktreeCliExecutorOptions as ga, DelegationTraceSpan as gb, FileCorpus as gc, LeaderboardScenario as gd, verifyObserverRecords as gf, createInbox as gg, environmentReader as gh, Shell as gi, InProcessPromptCtx as gl, ReentryTaskInput as gm, classifyDriverFailure as gn, createChatSessionStore as go, workerTraceEnv as gp, SuperviseProfileEntry as gr, SandboxRunAbortError as gs, ResourceLimit as gt, EqualKArm as gu, ToolLoopChat as gv, ConfigError as gw, ContinuationAppend as gx, DelegateCodeConfig as gy, OpenAIChatTool as h, sanitizeRuntimeStreamEvent as hC, Interval as hS, OutputAdapter as hT, sandboxProgressEvents as h_, patchDelivered as ha, DelegationTraceCollector as hb, runPersonified as hc, LeaderboardRunContext as hd, observerRecordDigest as hf, PeerInboxMessage as hg, SpawnResourceReader as hh, GitWorkspaceOptions as hi, InProcessOnPrompt as hl, ReentryContinuity as hm, DriverRetryPolicy as hn, chatWorkerSeam as ho, readWorkerTraceContext as hp, SpawnRefusalCause as hr, SandboxRun as hs, RecursiveReservationPolicy as ht, CorpusRecord as hu, ToolLoopCallContext as hv, BackendTransportError as hw, CheckVerdict as hx, DelegateCodeArgs as hy, AgentExecutionBackend as i, RuntimeEventCollector as iC, StartRetainedRunOptions as iE, CodeModeStore as iS, LoopPlanPayload as iT, SandboxOutputMarker as i_, SupervisorCleanupReceipt as ia, multiHarnessResearcherFanout as ib, PrivateCasArtifactPort as ic, RunPersonified as id, PursuitNodeTiming as if, ActivityNote as ig, HarnessTranscriptReadLimits as ih, EVIDENCE_MAX_CHARS as ii, defaultSelectWinner as il, ProgressTrackerOptions as im, DriverAttemptRecord as in, defaultDelegateBudget as io, RunContextLease as ip, QuestionEscalationRecord as ir, strategyTournament as is, HeldEnvironment as it, ObservationAnalysis as iu, ProviderWorkspaceEntryMetadata as iv, SpawnForestNode as iw, workerInboxFileFromEventDir as ix, DelegationArgs as iy, TRACE_SUMMARY_SCHEMA as j, CodexExecutionPolicy as jC, AnytimeTaskCurve as jS, WorkerEventPage as jT, CheckpointRef as j_, digestOfGraph as ja, RunCancellation as jb, createScopeAnalyst as jc, IsolatedCheckOptions as jd, AuthorizedSpawnContext as jf, isPeerMailEnvelope as jg, validateDelegateArgs as jh, DEFAULT_MAX_DEPTH as ji, AgenticTask as jl, CoordinationTransportOptions as jm, AuthorizeDownMessage as jn, RepairStop as jo, CoordinationBinding as jp, SandboxEvent$1 as jr, startRetainedRun as js, Settled as jt, PanelVerdict as ju, CoderReview as jv, BudgetPool as jw, expandQuestions as jx, DelegationHistoryResult as jy, RetainedPendingCause as k, removeWorktree as kC, AnytimeReport as kS, WorkerEventCursor as kT, AgentSessionStatus$1 as k_, GraphSelection as ka, coderTaskToPrompt as kb, assertTraceDerivedFindings as kc, IsolatedCheckBox as kd, defaultEdgeTraversalCap as kf, claimsAuthority as kg, DelegateResult as kh, parseWorkerToolTraceArtifact as ki, AgenticRunResult as kl, CoordinationPublicAddress as km, AuthoredAnalystDefinition as kn, CheckSource as ko, naiveContinuationPrompt as kp, AnalystFinding$1 as kr, reconnectRetainedRun as ks, Runtime as kt, PanelJudge as ku, eventToSnapshot as kv, WorkerSlots as kw, checkVerdictOf as kx, DelegationHistoryArgs as ky, AgentTaskRunResult as l, SanitizedKnowledgeReadinessReport as lC, RunCodeModeOptions as lS, LoopTokenUsage as lT, createSandboxToolPartState as l_, loadProfile as la, readTraceContextFromEnv as lb, equalKOnCost as lc, DefinedLeaderboard as ld, PursuitStatus as lf, WorkerProgress as lg, retainHarnessTranscript as lh, composeWorkerEvidence as li, SandboxEvidenceRetentionError as ll, allWorkersStalled as lm, DriverContractState as ln, ChatCompletionsTransport as lo, SupervisorSpanOptions as lp, QuestionRecord as lr, strategyAuthorContract as ls, NodeId as lt, observe as lu, ExecutorResultMapping as lv, contentAddress as lw, workerSteersDir as lx, DelegationRunContext as ly, OpenAIChatResponseFormat as m, sanitizeKnowledgeReadinessReport as mC, GroupOf as mS, MountRecorder as mT, sandboxEventServedBackend as m_, PatchDeliverableOptions as ma, DelegationTraceCaps as mb, definePersona as mc, LeaderboardIterationInfo as md, ObserverRecordKind as mf, InboxMessage as mg, SpawnResourceRead as mh, withUntrackedArtifacts as mi, inlineSandboxClient as ml, sampleFromSettled as mm, DriverRepromptRefusal as mn, chatTransportExecutor as mo, WorkerTraceSeamCarrier as mp, SpawnRefusal as mr, OpenSandboxRunPromptOptions as ms, ProviderModelExecutionEvidence as mt, CorpusFilter as mu, ToolSpec as mv, AgentEvalErrorCode as mw, CheckUnavailableError as mx, hashIdempotencyInput as my, AgentBackendContext as n, padTraceId as nC, RetainedRunTurnInput as nE, CodeModeOptions as nS, LoopLineageOptions as nT, sharedWorkerClientName as n_, ProvisionSupervisorRequest as na, ResearcherProfileOptions as nb, collectAgentTurn as nc, PersonaContext as nd, PursuitNodePlatform as nf, sandboxSessionTraceSource as ng, persistHarnessTranscript as nh, attachWorker as ni, TERMINAL_DECISIONS as nl, ProgressSample as nm, WorkerTraceUnavailableReason as nn, graphDesignerExtraTools as no, InMemoryRunContextOptions as np, QuestionDecision as nr, TournamentRow as ns, FleetYield as nt, harvestCorpus as nu, ProviderWorkspaceCaptureReceipt as nv, SpawnForestInDoubtNode as nw, workerControlLogFile as nx, parseDetachedSessionRef as ny, AgentRuntimeEvent as o, RuntimeStreamEventSink as oC, CodeModeToolContext as oS, LoopSandboxPlacement as oT, SandboxToolPartState as o_, ProfileRegistryDir as oa, TraceContext as ob, PrivateCasOffloadReport as oc, ShapeBudget as od, PursuitProjection as of, ExecutorProgress as og, RetainedHarnessTranscriptCapture as oh, VERIFY_TAIL_CHARS as oi, runAgentRounds as ol, StopDecision as om, DriverAttemptsExhaustedError as on, DriverAgentOptions as oo, createInMemoryRunContext as op, QuestionLevel as or, AuthoredStrategy as os, MaterializedModelIdentity as ot, ObserveInput as ou, ProviderWorkspaceRetentionPort as ov, loadSpawnForest as ow, workerSteerAcknowledgementsDir as ox, DelegationResumeContext as oy, KnowledgeReadinessDecision as p, sanitizeAgentRuntimeEvent as pC, AxisScoresOf as pS, MountManifestEntry as pT, mapSandboxToolEvent as p_, recordProfileRun as pa, DELEGATION_TRACE_MAX_SPANS as pb, registerShape as pc, LeaderboardFlagSpec as pd, ObserverRecord as pf, Inbox as pg, SpawnResourceBytes as ph, copyUntrackedIntoClone as pi, localSandboxClient as pl, plateau as pm, DriverReentry as pn, ChatWorkerSeamOptions as po, WorkerTraceResolver as pp, SpawnPreflightContext as pr, OpenSandboxRunOptions as ps, ProviderModelAttemptEvidence as pt, Corpus as pu, RouterTransportConfig as pv, AgentEvalError$1 as pw, CheckRead as px, SubmitOutput as py, ExecutorExecutionBinding as q, D1StmtLike as qC, RuntimeEventOtelOptions as qS, RetainedRunDispatchedAdmission as qT, resolveAgentEnvironmentProvider as q_, freeSlots as qa, runCancelRequestFile as qb, LoopCampaignDispatchOptions as qc, SupervisedPursuitResult as qd, resolveWorkerSpawnRetry as qf, SharedBoxCloseReceipt as qg, SteerableSandboxArgs as qh, ScopeArgs as qi, depthStrategy as ql, HarnessTranscriptArtifact as qm, EventAcknowledgement as qn, selectBestIndex as qo, assertCoordinationBinding as qp, AnalystAuthoring as qr, profileChatClient as qs, TraceRootReceipt as qt, WidenDecision as qu, DetachedSessionRefParts as qv, DefaultVerdict$1 as qw, CodexRolloutStoreRef as qx, UiFindingScreenshot as qy, AgentBackendInput as r, toOtelAttributes as rC, StartRetainedRunInEnvironmentOptions as rE, CodeModeResult as rS, LoopPlanDescription as rT, SandboxLeafOut as r_, ProvisionedSupervisor as ra, createResearcherValidator as rb, streamAgentTurn as rc, PersonaExecutors as rd, PursuitNodeProjection as rf, ActivityLog as rg, HarnessTranscriptMetadata as rh, readWorkerInteractiveBinding as ri, TerminalDecision as rl, ProgressTracker as rm, WorkspaceCheckpointMarker as rn, DelegateOptions as ro, RunContext as rp, QuestionEscalationOutcome as rr, runStrategyEvolution as rs, Handle as rt, Observation as ru, ProviderWorkspaceCaptureResult as rv, SpawnForestMissingTree as rw, workerInboxFile as rx, runDetachedTurn as ry, AgentRuntimeEventSink as s, RuntimeStreamEventSummary as sC, CodeModeToolsOptions as sS, LoopStartedPayload as sT, SandboxUsageLedger as s_, ProfileRunRecord as sa, createPropagatingTraceEmitter as sb, PrivateCasOptions as sc, ShapeContext as sd, PursuitRunProjection as sf, ScopeProgressInput as sg, RetainedHarnessTranscriptDescriptor as sh, WorkerEvidenceInput as si, SandboxEvidenceContext as sl, StopRule as sm, DriverBudgetReadout as sn, driverAgent as so, withRunContext as sp, QuestionOption as sr, assertStrategyContract as ss, NoWinnerError as st, ObserveOptions as su, ProviderPlacement as sv, materializeTreeView as sw, workerSteerRequestFile as sx, DelegationResumeDriver as sy, AgentAdapter as t, padSpanId as tC, RetainedRunStartMaterial as tE, decodeHarnessUsage as tS, LoopIterationStartedPayload as tT, sharedBoxRefusal as t_, ProvisionSupervisorConnection as ta, ResearchTask as tb, StreamAgentTurnOptions as tc, Persona as td, PursuitNodePlacement as tf, decodeToolPart as tg, harnessTranscriptArtifact as th, WorkerInteractiveProviderSource as ti, RunAgentRoundsOptions as tl, PlateauOptions as tm, WorkerTraceEvidence as tn, GraphDesignerExtraTools as to, InMemoryRunContext as tp, Question as tr, TournamentCell as ts, ExecutorToolCall as tt, HarvestReport as tu, ProviderWorkspaceCaptureProvenance as tv, SpawnForestEvent as tw, workerCancellationsDir as tx, formatDetachedSessionRef as ty, AgentTaskSpec as u, SanitizedKnowledgeRequirement as uC, createCodeModeTools as uS, LoopTraceEmitter as uT, createSandboxUsageLedger as u_, pickBestProfile as ua, traceContextToEnv as ub, trajectoryReport as uc, LeaderboardBenchScore as ud, projectPursuit as uf, createActivityLog as ug, ResolveSpawnResourcePathsResult as uh, settledWorkerOut as ui, SandboxEvidenceRetentionPort as ul, anyOf as um, DriverFailureClass as un, ChatSessionStore as uo, SupervisorSpanOutcome as up, QuestionUrgency as ur, strategyAuthorSystemPrompt as us, NodeSnapshot as ut, renderReport as uu, gateOnDeliverable as uv, Redactor as uw, writeWorkerSteer as ux, DelegationTaskQueue as uy, RunAgentTaskStreamOptions as v, WorktreeCommandResult as vC, LeaderboardRow as vS, SelectionReceipt as vT, AgentEnvironmentCapabilities$1 as v_, createWorktreeCliExecutor as va, capDelegationTrace as vb, renderCorpusToInstructions as vc, LeaderboardSpec as vd, EdgeDeliveryOutcome as vf, DEFAULT_PEER_MAIL_LIMITS as vg, resolveSpawnResourcePaths as vh, WorkspaceCommit as vi, inProcessSandboxClient as vl, composeReentryTask as vm, upstreamUnavailableSignal as vn, ProfileRichness as vo, workerTraceSeamKey as vp, WorkerResumeContext as vr, openSandboxRun as vs, ResultBlobStore as vt, EqualKOnCostOptions as vu, ToolLoopCompactionOptions as vv, NotFoundError as vw, ContinuationEntry as vx, DelegateFeedbackArgs as vy, RuntimeFailureCode as w, GitRunner as wC, pairwiseSignificance as wS, RuntimeRunOptions as wT, AgentEnvironmentStatus as w_, WorkerInteractiveAdmission as wa, FileDelegationStore as wb, selectValidWinner as wc, checkProgramDigest as wd, RunGraphOptions as wf, PeerMailReadout as wg, DELEGATE_INPUT_SCHEMA as wh, TrajectoryAnalysis as wi, StdioMcpConnection as wl, collectDelivered as wm, AnalystLensOutput as wn, supervisorInstructions as wo, delegatesWorkerBriefPrompt as wp, downMessageRefusalReasons as wr, AcquireOptions as ws, RootProviderModelEvidence as wt, FlatWidenGate as wu, McpToolDescriptor$1 as wv, RuntimeRunStateError as ww, ContinuationProfile as wx, DelegateUiAuditConfig as wy, RuntimeSessionStore as x, CreateWorktreeOptions as xC, ProfileKeyOf as xS, RuntimeRunCompleteInput as xT, AgentEnvironmentProviderRef as x_, InteractiveWorkerOptions as xa, DelegationPersistenceError as xb, loopUntil as xc, DeclaredCheckPlacement as xd, GraphEdgeCapError as xf, PeerMailEvent as xg, createInProcessTransport as xh, jjWorkspace as xi, MaterializeLocalMcpOptions as xl, FinalizerSettled as xm, AnalystDefinitionIssue as xn, assessAuthoredProfile as xo, RegisteredPrompt as xp, analystToolGroupNames as xr, SandboxLineageHandle as xs, RetainedExecutionState as xt, FanoutOptions as xu, JsonRpcMessage as xv, RetainedInteractiveBindingError as xw, ContinuationPanelInput as xx, DelegateResearchConfig as xy, RuntimeCanonicalStreamEvent as y, WorktreeHarnessResult as yC, PairwiseOptions as yS, ValidationCtx as yT, AgentEnvironmentEvent$1 as y_, InteractiveWorkerEnvironment as ya, composeLoopTraceEmitters as yb, fanout as yc, defineLeaderboard as yd, EdgeTraversal as yf, PEER_MAIL_WIRE_KEY as yg, McpServer as yh, WorkspaceRun as yi, HttpMcpServerSpec as yl, DeliveredOutput as ym, ANALYST_DEFINITION_BOUNDS as yn, ProfileRichnessThresholds as yo, PromptHandle as yp, WorkerSpawnContext as yr, BranchCapableBox as ys, ResumedKeyState as yt, EqualKVerdict as yu, ToolLoopMessageRecord as yv, PlannerError as yw, ContinuationNoteInput as yx, DelegateFeedbackResult as yy, BudgetViolation as z, localHarnessExecutable as zC, WaterfallSpan as zS, RetainedInteractiveAdmission as zT, ProviderExecutorOptions as z_, pickBestGraph as za, legacySupervisorRunDir as zb, BenchmarkConfig as zc, PursuitVersions as zd, superviseFleetCapabilities as zf, envKeyProvider as zg, RouterToolsSeam as zh, SearchSpec as zi, StrategyCtx as zl, FileCoordinationLog as zm, CoordinationTools as zn, composeCheckSources as zo, ResolvedSupervisorProfile as zp, SurfaceDiff as zr, RecoverRetainedInteractiveRunOptions as zs, SpendGap as zt, SteerContext as zu, detachedSessionDelegate as zv, ReservationShortfall as zw, completionAuthorizes as zx, FeedbackRefersTo as zy };
+//# sourceMappingURL=types-5r334mcg.d.ts.map