@tangle-network/agent-runtime 0.102.1 → 0.103.0

package/dist/loops.d.ts

@@ -1,28 +1,28 @@
-import { ChatClient, RunRecord, HarnessType, AgentProfile, MaximumCharge, AnalystFinding, AnalystRunInputs, ToolSpan, StreamingDetector, DetectorSignal, buildTrajectory } from '@tangle-network/agent-eval';
+import { ChatClient, RunRecord, HarnessType, AgentProfile, MaximumCharge, AnalystFinding, AnalystRunInputs, buildTrajectory } from '@tangle-network/agent-eval';
 export { AnalystFinding, DefaultVerdict, computeFindingId, makeFinding } from '@tangle-network/agent-eval';
 import { SandboxEvent, SandboxInstance, CreateSandboxOptions, PromptOptions, TaskOptions } from '@tangle-network/sandbox';
 export { AgentProfile, CreateSandboxOptions, SandboxEvent, SandboxInstance } from '@tangle-network/sandbox';
-import { a as ResultBlobStore, g as SpawnJournal, N as NodeId, j as SpawnEvent, E as ExecutorFactory, A as Agent, B as Budget, d as Settled, S as Scope, b as SupervisedResult, e as Spend, U as UsageEvent, h as ExecutorRegistry, k as Supervisor } from './types-D870JlH0.js';
-export { f as AgentSpec, c as Executor, l as ExecutorContext, m as ExecutorResult, R as Runtime, n as SupervisorOpts, T as TreeView, W as WidenGate } from './types-D870JlH0.js';
-import { M as MakeWorkerAgent, A as AnalystRegistry, o as CoordinationTools, n as CoordinationEvent, as as QuestionPolicy, E as ExecutorConfig } from './coordination-D9l_YmwW.js';
-export { bh as BusEvent, bi as BusRecord, bj as BusStats, bk as EventBus, bl as ProviderSeam, bm as PublishOptions, bn as cliWorktreeExecutor, bo as createEventBus, bp as createExecutor, bq as createExecutorRegistry } from './coordination-D9l_YmwW.js';
-import { R as RuntimeHooks, I as Iteration, S as SandboxClient, D as Driver, A as AgentRunSpec, O as OutputAdapter, V as Validator, E as ExecCtx, u as LoopWinner, v as LoopLineageOptions, w as LoopResult, L as LoopTokenUsage, M as MountRecorder } from './types-CLat4bT9.js';
-export { x as LoopDecisionPayload, y as LoopEndedPayload, z as LoopIterationDispatchPayload, B as LoopIterationEndedPayload, C as LoopIterationStartedPayload, F as LoopPlanDescription, G as LoopPlanPayload, b as LoopSandboxPlacement, H as LoopStartedPayload, J as LoopTeardownFailedPayload, d as LoopTraceEmitter, c as LoopTraceEvent, K as MountManifestEntry, N as RunProvenance, a as SelectionReceipt, P as ValidationCtx } from './types-CLat4bT9.js';
+import { b as ResultBlobStore, c as SpawnJournal, N as NodeId, l as SpawnEvent, m as TreeView, P as PendingWait, a as Settled, E as ExecutorFactory, A as Agent, B as Budget, S as Scope, e as SupervisedResult, g as Spend, U as UsageEvent, n as SpawnOpts, i as ExecutorRegistry, d as WaitProbeRegistry, o as Supervisor, T as TraceSource } from './types-lZTE_LBd.js';
+export { p as ActivityLog, q as ActivityNote, h as AgentSpec, D as DEFAULT_STALL_AFTER_MS, f as Executor, r as ExecutorContext, k as ExecutorProgress, s as ExecutorResult, t as ResumedWork, R as Runtime, u as ScopeProgressInput, v as SessionTraceBox, w as SupervisorOpts, x as WaitOutcome, y as WaitProbe, z as WaitRejection, C as WaitSpec, F as WidenGate, W as WorkerProgress, G as createActivityLog, H as createPushTraceSource, I as createWaitProbes, J as decodeToolPart, K as isWaitOutcome, L as pollFor, M as readWorkerProgress, O as sandboxSessionTraceSource, Q as timerAt, V as validateWaitSpec, X as waitUntil } from './types-lZTE_LBd.js';
+import { M as MakeWorkerAgent, A as AnalystRegistry, W as WorkerWatchOptions, o as CoordinationTools, n as CoordinationEvent, at as QuestionPolicy, E as ExecutorConfig } from './coordination-DTehA977.js';
+export { bi as BusEvent, bj as BusRecord, bk as BusStats, bl as DEFAULT_SANDBOX_STEERING_MAX_TURNS, bm as EventBus, bn as Inbox, bo as InboxMessage, bp as PI_RUNTIME, bq as PiSeam, br as ProviderSeam, bs as PublishOptions, bt as SandboxSteeringOptions, bu as SteerableSandboxSession, bv as WatchTraceOptions, bw as cliWorktreeExecutor, bx as createEventBus, by as createExecutor, bz as createExecutorRegistry, bA as createInbox, bB as createSteerableSandboxSession, bC as defaultToolDetectors, bD as piExecutor, bE as piSeamKey, bF as watchTrace } from './coordination-DTehA977.js';
+import { R as RuntimeHooks, I as Iteration, S as SandboxClient, D as Driver, A as AgentRunSpec, O as OutputAdapter, V as Validator, E as ExecCtx, u as LoopWinner, v as LoopLineageOptions, w as LoopResult, L as LoopTokenUsage, M as MountRecorder } from './types-DK11_O4L.js';
+export { x as LoopDecisionPayload, y as LoopEndedPayload, z as LoopIterationDispatchPayload, B as LoopIterationEndedPayload, C as LoopIterationStartedPayload, F as LoopPlanDescription, G as LoopPlanPayload, b as LoopSandboxPlacement, H as LoopStartedPayload, J as LoopTeardownFailedPayload, t as LoopTraceEmitter, c as LoopTraceEvent, K as MountManifestEntry, N as RunProvenance, a as SelectionReceipt, P as ValidationCtx } from './types-DK11_O4L.js';
 import { RunProfileMatrixResult, Scenario, ProfileDispatchFn, JudgeConfig, RunProfileMatrixOptions, DispatchFn } from '@tangle-network/agent-eval/campaign';
 export { AgentEnvironmentProviderRef, AgentEnvironmentProviderRegistry, ProviderAsSandboxClientOptions, ProviderExecutorOptions, SandboxClientProviderOptions, createAgentEnvironmentProviderRegistry, providerAsExecutor, providerAsSandboxClient, resolveAgentEnvironmentProvider, sandboxClientAsProvider } from './environment-provider.js';
-import { c as CorpusRecord, C as Corpus, S as ScopeAnalyzeInput, d as AssertTraceDerivedFindings, O as Outcome, e as SteerContext, f as ScopeAnalyst, F as FanoutOptions, g as CombinatorShape, h as ScopeWidenGate, L as LoopUntilSpec, P as PanelSpec, i as PipelineStage, W as WinnerStrategy, j as FanoutWinnerSelector, V as VerifySpec, k as WidenSpec, l as CorpusFilter, R as RenderCorpusToInstructionsOptions, D as DefinePersonaInput, m as Persona, n as RunPersonifiedOptions, o as ShapeRegistry, p as LoopShape, E as EqualKArm, q as EqualKOnCostOptions, r as EqualKVerdict, T as TrajectoryReportOptions, s as TrajectoryReport } from './worktree-fanout-DsIR4d6w.js';
-export { A as AuthoredHarness, t as DefinePersona, u as EqualKOnCost, v as Fanout, w as FanoutSynthesis, x as FlatWidenGate, y as LoopUntil, z as LoopUntilState, B as Panel, G as PanelJudge, H as PanelVerdict, I as PatchDeliverableOptions, J as PersonaContext, K as PersonaExecutors, M as Pipeline, N as RenderCorpusToInstructions, Q as RunPersonified, U as ShapeBudget, X as ShapeContext, Y as TrajectoryNode, Z as TrajectoryReportFn, _ as Verify, $ as Widen, a0 as WidenDecision, a1 as WidenLineage, a2 as WorktreeCliExecutorOptions, a as WorktreeFanoutOptions, b as WorktreePatchArtifact, a3 as createWorktreeCliExecutor, a4 as patchDelivered, a5 as worktreeFanout } from './worktree-fanout-DsIR4d6w.js';
+import { c as CorpusRecord, C as Corpus, S as ScopeAnalyzeInput, d as AssertTraceDerivedFindings, O as Outcome, e as SteerContext, f as ScopeAnalyst, F as FanoutOptions, g as CombinatorShape, h as ScopeWidenGate, L as LoopUntilSpec, P as PanelSpec, i as PipelineStage, W as WinnerStrategy, j as FanoutWinnerSelector, V as VerifySpec, k as WidenSpec, l as CorpusFilter, R as RenderCorpusToInstructionsOptions, D as DefinePersonaInput, m as Persona, n as RunPersonifiedOptions, o as ShapeRegistry, p as LoopShape, E as EqualKArm, q as EqualKOnCostOptions, r as EqualKVerdict, T as TrajectoryReportOptions, s as TrajectoryReport } from './worktree-fanout-DiiJWjJO.js';
+export { A as AuthoredHarness, t as DefinePersona, u as EqualKOnCost, v as Fanout, w as FanoutSynthesis, x as FlatWidenGate, y as LoopUntil, z as LoopUntilState, B as Panel, G as PanelJudge, H as PanelVerdict, I as PatchDeliverableOptions, J as PersonaContext, K as PersonaExecutors, M as Pipeline, N as RenderCorpusToInstructions, Q as RunPersonified, U as ShapeBudget, X as ShapeContext, Y as TrajectoryNode, Z as TrajectoryReportFn, _ as Verify, $ as Widen, a0 as WidenDecision, a1 as WidenLineage, a2 as WorktreeCliExecutorOptions, a as WorktreeFanoutOptions, b as WorktreePatchArtifact, a3 as createWorktreeCliExecutor, a4 as patchDelivered, a5 as worktreeFanout } from './worktree-fanout-DiiJWjJO.js';
 import { AgentProfileMcpServer, AgentProfile as AgentProfile$1, AgentProfileSecurityPolicy } from '@tangle-network/agent-interface';
-import { A as AgenticSurface, a as AgenticTask, b as AgenticOptions, c as Strategy, d as ArtifactHandle, e as SurfaceScore, f as AgenticTool } from './structural-rollout-D7xik9XR.js';
-export { g as AgenticRunResult, C as CheckExecChannel, h as CheckOutcome, i as CheckRunContext, j as CheckRunner, k as CheckSource, l as CheckSourceCtx, m as CorpusReadbackOptions, R as RepairStop, n as RunAgenticOptions, o as ShotPersona, p as ShotSpec, q as StrategyCtx, r as StrategyResult, s as StructuralRolloutConfig, S as StructuralRolloutPolicy, t as StructuralRolloutResult, V as VisibleCheck, u as adaptiveRefine, v as breadthStrategy, w as canDisplace, x as compareCheckOutcomes, y as composeCheckSources, z as defaultExtractCandidate, B as defaultStructuralRolloutPolicy, D as defineStrategy, E as depthStrategy, F as filterAuthoredAsserts, G as modelAuthoredChecks, H as officialChecksFromMeta, I as refine, J as resolveEntrySymbol, K as runAgentic, L as sample, M as sampleThenRefine, N as sandboxCheckRunner, O as selectBestIndex, P as structuralRollout, Q as visibleCheckScore } from './structural-rollout-D7xik9XR.js';
+import { A as AgenticSurface, a as AgenticTask, b as AgenticOptions, c as Strategy, d as ArtifactHandle, e as SurfaceScore, f as AgenticTool } from './structural-rollout-BFPIy3iw.js';
+export { g as AgenticRunResult, C as CheckExecChannel, h as CheckOutcome, i as CheckRunContext, j as CheckRunner, k as CheckSource, l as CheckSourceCtx, m as CorpusReadbackOptions, R as RepairStop, n as RunAgenticOptions, o as ShotPersona, p as ShotSpec, q as StrategyCtx, r as StrategyResult, s as StructuralRolloutConfig, S as StructuralRolloutPolicy, t as StructuralRolloutResult, V as VisibleCheck, u as adaptiveRefine, v as breadthStrategy, w as canDisplace, x as compareCheckOutcomes, y as composeCheckSources, z as defaultExtractCandidate, B as defaultStructuralRolloutPolicy, D as defineStrategy, E as depthStrategy, F as filterAuthoredAsserts, G as modelAuthoredChecks, H as officialChecksFromMeta, I as refine, J as resolveEntrySymbol, K as runAgentic, L as sample, M as sampleThenRefine, N as sandboxCheckRunner, O as selectBestIndex, P as structuralRollout, Q as visibleCheckScore } from './structural-rollout-BFPIy3iw.js';
 import { b as AnalystRegistryLike } from './types-CmYCMbFT.js';
 import { R as RouterConfig, T as ToolLoopChat, a as ToolLoopCompactionOptions } from './sanitize-DEbPNtyI.js';
 export { j as RouterChatResult, k as RouterChatToolsResult, l as RouterToolCall, m as RouterToolLoopResult, n as ToolLoopCompaction, b as ToolSpec, r as routerBrain, o as routerChatWithTools, p as routerChatWithUsage, q as routerToolLoop } from './sanitize-DEbPNtyI.js';
 import { R as RuntimeStreamEvent, c as AgentExecutionBackend, f as AgentTaskStatus, B as BackendErrorDetail } from './types-BwoZWq-i.js';
-import { D as DeliverableSpec } from './completion-gate-C6dhVN-N.js';
-export { g as WorktreeCommandResult, h as WorktreeProfileMaterializationReceipt, i as gateOnDeliverable } from './completion-gate-C6dhVN-N.js';
-import { S as SupervisorProfile } from './supervise-BQdNAXtK.js';
-export { D as DriveHarness, a as SuperviseOptions, b as SupervisorAgentDeps, s as supervise, c as supervisorAgent, w as workerFromBackend } from './supervise-BQdNAXtK.js';
+import { D as DeliverableSpec } from './completion-gate-DLINnrkM.js';
+export { g as WorktreeCommandResult, h as WorktreeProfileMaterializationReceipt, i as gateOnDeliverable } from './completion-gate-DLINnrkM.js';
+import { S as StopRule, a as SupervisorProfile } from './supervise-Cp8bNcJi.js';
+export { A as AllWorkersStalledOptions, D as DriveHarness, N as NoProgressForOptions, P as PlateauOptions, b as ProgressSample, c as ProgressTracker, d as ProgressTrackerOptions, e as ProgressView, f as StopDecision, g as SuperviseOptions, h as SupervisorAgentDeps, i as allOf, j as allWorkersStalled, k as anyOf, l as createProgressTracker, n as noProgressFor, p as plateau, s as sampleFromSettled, m as supervise, o as supervisorAgent, w as workerFromBackend } from './supervise-Cp8bNcJi.js';
 import { stuckLoopView, toolWasteView } from '@tangle-network/agent-eval/pipelines';
 export { AgentEnvironment, AgentEnvironmentCapabilities, AgentEnvironmentEvent, AgentEnvironmentProvider, AgentEnvironmentQuery, AgentEnvironmentStatus, AgentEnvironmentSummary, AgentProfileRef, AgentSession, AgentSessionRef, AgentSessionStatus, AgentTurnInput, AgentTurnResult, CheckpointRef, CheckpointRequest, CreateAgentEnvironmentInput, ExecRequest, ExecResult, ForkRequest, PlacementInfo, ResourceRequest, WorkspaceRequest } from '@tangle-network/agent-interface/environment-provider';
 import './substrate-Dyiqmd3o.js';
@@ -72,6 +72,18 @@ declare class InMemoryResultBlobStore implements ResultBlobStore {
     put(outRef: string, artifact: unknown): Promise<void>;
     get(outRef: string): Promise<unknown | undefined>;
 }
+/**
+ * FS `ResultBlobStore`. One JSON file per artifact under `dir`, named by a
+ * filesystem-safe encoding of the `outRef` (`sha256:<hex>` → `sha256-<hex>.json`).
+ * `put` fsyncs so a crash between writes never loses an acknowledged blob.
+ */
+declare class FileResultBlobStore implements ResultBlobStore {
+    private readonly dir;
+    constructor(dir: string);
+    put(outRef: string, artifact: unknown): Promise<void>;
+    get(outRef: string): Promise<unknown | undefined>;
+    private blobPath;
+}
 /**
  * In-memory `SpawnJournal`. Appends are observed-committed only; the impl enforces
  * the corruption guards a durable replay rests on:
@@ -85,6 +97,47 @@ declare class InMemorySpawnJournal implements SpawnJournal {
     beginTree(root: NodeId, at: string): Promise<void>;
     appendEvent(root: NodeId, ev: SpawnEvent): Promise<void>;
 }
+/**
+ * JSONL on disk. One line per record: the first record is `begin`, subsequent records
+ * are `event` envelopes wrapping a `SpawnEvent`. `loadTree` replays the whole file,
+ * filtering by `root`, and applies the same begin-precedes-events + unique-seq
+ * corruption guards as the in-memory impl. Each append fsyncs so a crash between
+ * writes never loses an acknowledged event.
+ */
+declare class FileSpawnJournal implements SpawnJournal {
+    private readonly path;
+    constructor(path: string);
+    loadTree(root: NodeId): Promise<SpawnEvent[] | undefined>;
+    beginTree(root: NodeId, at: string): Promise<void>;
+    appendEvent(root: NodeId, ev: SpawnEvent): Promise<void>;
+    private loadTreeBegin;
+    private appendRecord;
+}
+/**
+ * Re-feed a journaled spawn tree in strict `seq` order, rehydrating each settled
+ * child's `out` from the blob store by `outRef`, and return the `Settled[]` exactly
+ * as `scope.next()` originally delivered them.
+ *
+ * Determinism (B2): the events are sorted by `seq` BEFORE any blob `get`, so the
+ * replay order is the recorded cursor order regardless of how fast each rehydration
+ * resolves. `at` (wall-clock) is never a replay input. Fail loud on a tree that was
+ * never begun, a settled-done event missing its `outRef`, or a blob the store can't
+ * rehydrate — a silent gap would let `act` branch on the wrong evidence.
+ */
+declare function replaySpawnTree(journal: SpawnJournal, blobs: ResultBlobStore, root: NodeId): Promise<Settled<unknown>[]>;
+/**
+ * Materialize a recorded `TreeView` from a journaled event list for inspection. Folds
+ * `spawned`/`settled`/`cancelled` into a per-node snapshot in `seq` order, then adds each
+ * `metered` event's driver-inference spend onto its node in a separate additive pass so the view
+ * matches the recorded cursor. It does not recover live executors or driver state after restart.
+ */
+declare function materializeTreeView(events: SpawnEvent[]): TreeView;
+/**
+ * The waits a journaled tree shows as ARMED but never woken — what a resumed run re-arms with the
+ * ORIGINAL absolute deadline. Reading it from the journal (rather than from any live state) is
+ * what makes "SIGKILL a waiting tree, a new process keeps waiting to the same instant" true.
+ */
+declare function pendingWaits(events: SpawnEvent[]): PendingWait[];
 
 /**
  * createWaterfallCollector — 100% trajectory observability from the lifecycle stream:
@@ -210,6 +263,29 @@ interface AnytimeReport {
     /** One summary per (strategy, target) pair — the COCO-style multi-target view. */
     perStrategy: AnytimeStrategySummary[];
 }
+/**
+ * The best-so-far fold — the ONE definition of "how good was the run after k results", shared by
+ * the post-run anytime report below and by the LIVE progress-based stop rules
+ * (`supervise/stop-rules.ts`). Given the observed objective per settled result in order, it returns
+ * the running maximum. A result with no objective (`undefined` — it failed, or it was never
+ * scored) carries the previous best forward rather than resetting it.
+ *
+ * It is extracted rather than duplicated on purpose: a stop rule that decides a run has plateaued
+ * must agree, number for number, with the report that later says whether stopping was right.
+ */
+declare function bestSoFar(values: ReadonlyArray<number | undefined>): number[];
+/** Mean of a best-so-far curve — the anytime AUC when the curve is normalized to [0,1]. Higher =
+ *  the run climbed earlier. Shared with the stop rules so "improving" means one thing. */
+declare function areaUnderCurve(curve: ReadonlyArray<number>): number;
+/**
+ * How many trailing entries of a best-so-far curve are within `minDelta` of the curve's value
+ * `window` steps back — i.e. the length of the current PLATEAU, in settles. `0` means the most
+ * recent settle improved the best by more than `minDelta`.
+ *
+ * The plateau math the live stop rules read. Defined here, beside the report that measures whether
+ * the plateau was real, so there is exactly one notion of "not improving".
+ */
+declare function plateauLength(curve: ReadonlyArray<number>, minDelta: number): number;
 /** Derive anytime metrics from waterfall spans. `targets` are the satisficing score
  *  bars (default [1] = fully resolved; COCO-style multi-target: [0.5, 0.8, 1]);
  *  `targetFor` overrides the bar per task (task-specific satisfaction) — when set, the
@@ -1468,6 +1544,10 @@ declare function pipeline<Task, D>(stages: ReadonlyArray<PipelineStage<Task, unk
  * gathered settlements (one SEPARATE synthesis child) or return the best-valid child via the
  * single-sourced selector. A round that admitted zero children, or whose synthesis child could
  * not be admitted, is a concrete blocker.
+ *
+ * `opts.width` swaps the single round for `rollingDispatch`: at most `width` items live at once,
+ * refilled the instant one settles. Selection, blockers, and the conserved pool are unchanged —
+ * the refill behavior lives in the existing combinator rather than in a rival primitive.
  */
 declare function fanout<Task, Item, D>(items: ReadonlyArray<Item>, opts: FanoutOptions<Item, D>): CombinatorShape<Task, D>;
 /**
@@ -3298,6 +3378,13 @@ interface DriverAgentOptions {
      *  `finding` the driver pulls and composes its next steer from. The UP-leg of the self-improving
      *  loop. Omit/empty = no auto-analysis (status quo). Requires `analysts`. */
     readonly analyzeOnSettle?: ReadonlyArray<string>;
+    /** Run the ONLINE detector panel over each worker's LIVE tool trace and raise a `finding` the
+     *  moment it loops/error-storms — mid-run evidence to steer on, not a settle-time post-mortem.
+     *  Omit = no online watching. */
+    readonly watchWorkers?: WorkerWatchOptions;
+    /** Idle time after which `observe_agent` reports a worker as stalled (a derived read; nothing is
+     *  killed). Omit = the runtime default. */
+    readonly stallAfterMs?: number;
     /** The driver's stance — a string, or built from the task (the worker-driver prompt /
      *  the generator). INJECTED so the prompt is a pluggable, optimizable role. */
     readonly systemPrompt: string | ((task: unknown) => string);
@@ -3321,6 +3408,24 @@ interface DriverAgentOptions {
     /** 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) => 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,
@@ -3413,6 +3518,10 @@ declare function serveCoordinationMcp(opts: {
     analysts?: AnalystRegistry;
     /** Analyst kinds to auto-run when a worker settles `done` — findings flow up the bus. */
     analyzeOnSettle?: ReadonlyArray<string>;
+    /** Run the ONLINE detector panel over each worker's live tool trace (raises `finding` events). */
+    watchWorkers?: WorkerWatchOptions;
+    /** Idle time after which `observe_agent` reports a worker as stalled. */
+    stallAfterMs?: number;
     /** Pass-through subscriber for every bus event (settled / question / finding). */
     onEvent?: (event: CoordinationEvent) => void | Promise<void>;
     questionPolicy?: QuestionPolicy;
@@ -3483,149 +3592,150 @@ declare function delegate<Out = unknown>(intent: string, opts?: DelegateOptions<
 
 /**
  *
- * `TraceSource` — the ONE substrate-agnostic source of a worker's tool-call trace. The online
- * detectors and the settle-time analyzers consume agent-eval `ToolSpan`s from here, regardless of
- * whether the worker is:
- *   - an OWNED tool loop (router-tools, cli-bridge tool dispatch) → push spans as we dispatch them;
- *   - a SANDBOX / fleet box → read the harness's tool calls off the session (`streamPrompt` parts
- *     live, `session.messages()` / `findCompletedTurn` at settle).
- *
- * The common currency is agent-eval's `ToolSpan` (so the same detectors + `buildTrajectory`/
- * `stuckLoopView`/`toolWasteView` run over any source). A source exposes two lanes:
- *   - `onSpan` — live spans for ONLINE detection (best-effort; a black-box box may only collect).
- *   - `collect` — the full span set at settle for the BATCH analyzers (always available).
- *
- * This module imports NO substrate SDK — it decodes generic message parts / OpenAI tool-call shapes.
- * The sandbox wiring (`sandboxSessionTraceSource`) is the thin adapter that feeds box session parts in.
+ * `rollingDispatch` — the REFILLING dispatch policy over a `Scope`. It keeps `width` children in
+ * flight and admits the next queued unit of work the instant one settles, instead of waiting for
+ * a whole round to drain (`fanout`) or for a driver to decide again (`spawn → await → spawn`).
+ *
+ * The gap it closes: `fanout` opens every item at once and then drains — one round, no refill —
+ * and a driver brain's manual loop opens one worker per model turn. Between those two there was
+ * nothing that holds N slots full, which is why a 5-worker run can peak at 2 live workers and sit
+ * ~50% idle. This is a policy over the EXISTING `Scope.spawn` / `Scope.next` primitives: it adds
+ * no second admission path, so the conserved budget pool stays the only fence on total work and
+ * `width` is only a fence on simultaneous work.
+ *
+ * Fail-closed by construction: an admission rejection (`budget-exhausted` / `depth-exceeded`) is
+ * recorded and STOPS further admission — the loop then drains what is already live and returns.
+ * It never retries a rejected spawn against the same pool, and it never spawns past `width`.
+ *
+ * ── The concurrency-cap ledger (read this before adding a fourth cap) ──────────────────────────
+ *
+ * Three unrelated caps bound "how much runs at once" in this stack, at three different layers.
+ * They are NOT aware of each other, and the smallest one silently wins:
+ *
+ *   1. `CoordinationToolsOptions.maxLiveWorkers` (`src/mcp/tools/coordination.ts`) — supervisor
+ *      level. How many workers may be spawned-but-not-settled at once; `spawn_agent` fails closed
+ *      with `error: 'max-live-workers'` past it. Unset by default ⇒ NO cap at this layer.
+ *   2. `SandboxLineage`'s `maxConcurrency` / `DEFAULT_FORK_CONCURRENCY = 4`
+ *      (`src/runtime/sandbox-lineage.ts`) — kernel level. How many BOXES one `runLoop` fork wave
+ *      provisions at once. It bounds a single leaf's fanout, not the supervisor's worker count.
+ *   3. A host's own live-box governor (e.g. loops' `ComputeGovernor`, `maxSandboxes = 4`) — fleet
+ *      level. How many sandboxes may exist across the whole host process.
+ *
+ * The honest effective limit on simultaneous WORKERS is the minimum of the caps that apply to the
+ * worker layer — (1) and (3). (2) is a different unit (boxes per fork wave inside one leaf) and
+ * must not be min'd into it, or a 4-way fork inside one worker reads as a 4-worker ceiling.
+ * `effectiveConcurrency` computes that minimum in one place so a host derives ONE number and
+ * passes it to BOTH `maxLiveWorkers` and this dispatcher's `width`, instead of leaving a fleet
+ * governor of 4 and an unset worker fence as unrelated numbers.
+ *
+ * ── Why this is not a copy of the kernel's batch loop ──────────────────────────────────────────
+ *
+ * `runBatch` (`src/runtime/run-loop.ts`) runs the same hold-N-slots-full shape over the KERNEL's
+ * substrate: bare promises in a `Set`, raced with `Promise.race`, bounded by `maxConcurrency`.
+ * This one runs it over the SUPERVISOR's substrate — `Scope.spawn`'s atomic reservation against
+ * the conserved pool, `Scope.next`'s journaled settlement cursor, and the blob store behind each
+ * result. Neither can be expressed in the other's terms without dragging its whole substrate
+ * along: the kernel loop has no budget to reserve and no cursor to order settlements by, and this
+ * one cannot race raw promises because a settlement is only real once it is journaled. The shape
+ * repeating across the two deliberate layers is resonance, not duplication — do not "unify" them
+ * into a shared helper that would have to know about both.
  *
  * @experimental
  */
 
-interface ToolStepInput {
-    readonly toolName: string;
-    readonly args: unknown;
-    readonly status?: 'ok' | 'error';
-    readonly result?: unknown;
-    /** Stable id of the tool call — used to de-duplicate the repeated state transitions a harness
-     *  streams for one call (opencode emits pending→running→completed, plus a `raw`-wrapped copy). */
-    readonly callId?: string;
-    /** Real per-call wall-clock when the source has it (owned tool-loop; opencode parts with `time`).
-     *  When omitted the span collapses to a single instant (`at`) — order + counts only, no duration. */
-    readonly startedAt?: number;
-    readonly endedAt?: number;
-}
-interface TraceSource {
-    /** Subscribe to tool spans as they are produced (ONLINE). Returns an unsubscribe. A source that
-     *  only exposes its trace at the end registers nothing and returns a no-op. */
-    onSpan(handler: (span: ToolSpan) => void): () => void;
-    /** The full set of tool spans for the run (SETTLE / batch). Always available. */
-    collect(): Promise<ToolSpan[]>;
-}
-/** Decode a part with a specific harness's adapter when known, else try every registered adapter
- *  (the composite — robust to mixed/unknown streams). Never throws. */
-declare function decodeToolPart(part: unknown, harness?: string): ToolStepInput | undefined;
-/** A push source for OWNED tool loops (router-tools / cli-bridge tool dispatch): the loop calls
- *  `record(step)` for each tool call; it becomes a span, fan-out to live subscribers + buffered for
- *  `collect`. */
-declare function createPushTraceSource(opts?: {
-    runId?: string;
-    now?: () => number;
-}): {
-    source: TraceSource;
-    record: (input: ToolStepInput) => ToolSpan;
-};
-/** A harness session message carrying parts (the shape `box.messages()` returns). Structurally typed
- *  so this works with the real `@tangle-network/sandbox` box AND a test double, no SDK import. */
-interface SessionMessageLike {
-    readonly parts?: ReadonlyArray<unknown>;
-}
-/** The minimal box surface this needs: list a session's messages (incl. mid-turn partials). */
-interface SessionTraceBox {
-    messages(opts: {
-        sessionId: string;
-    }): Promise<ReadonlyArray<SessionMessageLike>>;
-}
-/** The SANDBOX / fleet trace source: read a box session's message parts and decode the harness's tool
- *  calls into spans. `collect` (settle) is the solid path — `box.messages({sessionId})` → parts → spans;
- *  black-box harnesses aren't mid-step interruptible, so online steering is the owned-loop's job and a
- *  live `subscribe` is opt-in (pass `subscribeParts` from `streamPrompt` when the harness streams parts). */
-declare function sandboxSessionTraceSource(box: SessionTraceBox, sessionId: string, opts?: {
-    /** The box's harness (e.g. 'opencode', 'claude-code') → selects its decoder adapter. */
-    harness?: string;
-    subscribeParts?: (onPart: (part: unknown) => void) => () => void;
-    runId?: string;
-    now?: () => number;
-}): TraceSource;
-
+/** One unit of queued work: the agent to run, its task, and the spawn options (budget + label).
+ *  `nextUnit` mints these lazily so a queue can be generated, re-ordered, or grown while the
+ *  dispatcher runs. */
+interface DispatchUnit<Out> {
+    readonly agent: Agent<unknown, Out>;
+    readonly task: unknown;
+    readonly opts: SpawnOpts;
+}
+/** Why the dispatcher stopped admitting work. `drained` = the queue ran dry (the ordinary end);
+ *  `not-admitted` = the conserved pool or the depth ceiling refused a spawn; `stopped` = the
+ *  caller's `shouldStop` returned true; `aborted` = the scope's signal fired. */
+type DispatchStopReason = 'drained' | 'not-admitted' | 'stopped' | 'aborted';
+interface RollingDispatchOptions<Out> {
+    /**
+     * How many children to hold in flight. Must be a positive integer. This is a SIMULTANEITY fence
+     * only — the conserved pool still bounds total work, and a `width` larger than the pool can
+     * afford simply hits `not-admitted` sooner. Derive it with `effectiveConcurrency` when the host
+     * also runs a fleet-level box governor.
+     */
+    readonly width: number;
+    /**
+     * Produce the next unit of work, or `undefined` when the queue is dry. Called only when a slot
+     * is free, so a caller may compute the next unit from what has already settled (the point of a
+     * refilling dispatcher: the queue is allowed to react). Never called after a stop.
+     */
+    nextUnit(): DispatchUnit<Out> | undefined | Promise<DispatchUnit<Out> | undefined>;
+    /**
+     * Called once per settlement, in cursor order, BEFORE the freed slot is refilled — so an
+     * `onSettled` that appends to the caller's queue is visible to the very next `nextUnit`.
+     */
+    onSettled?(settled: Settled<Out>): void | Promise<void>;
+    /**
+     * Consulted before each admission. `true` stops admitting; the already-live children are still
+     * drained to completion (no orphan, no lost settlement). Use it for a progress/plateau rule.
+     */
+    shouldStop?(): boolean;
+}
+interface DispatchReport<Out> {
+    /** Every settlement, in the order `scope.next()` yielded them. */
+    readonly settled: ReadonlyArray<Settled<Out>>;
+    /** How many children this dispatcher admitted. */
+    readonly admitted: number;
+    /** Admission rejections, in order — `label: reason`. Non-empty ⇒ the pool or depth fenced. */
+    readonly rejected: ReadonlyArray<string>;
+    readonly stopReason: DispatchStopReason;
+    /** The highest simultaneous live count actually reached — the number to compare against
+     *  `width` when asking "did the slots really stay full?" */
+    readonly peakLive: number;
+}
 /**
+ * Run the refilling dispatch loop over `scope` until the queue is dry (or a stop fires) and every
+ * admitted child has settled. Returns the settlements in cursor order plus the admission ledger.
  *
- * The ONLINE analyst: watch a `TraceSource` and fold each tool span through agent-eval's published
- * streaming detector kernel (`repeatedActionDetector`/`errorStreakDetector` — the SAME kernel the
- * control loop folds), firing `onSignal` the moment a worker loops or error-storms. Substrate-
- * agnostic: it consumes spans from any source (owned router/bridge loop OR a sandbox box session),
- * never the raw tool seam. Detection logic + the failure taxonomy live in agent-eval; not reimplemented.
- *
- * @experimental
+ * The loop is: fill free slots from `nextUnit` → `await scope.next()` → deliver the settlement →
+ * refill → repeat. Because the refill happens immediately after each settlement rather than after
+ * a whole round, a slow child never idles the other slots.
  */
-
-interface WatchTraceOptions {
-    /** The detectors to run online. Defaults to a stuck-loop + error-streak panel. */
-    readonly detectors?: ReadonlyArray<StreamingDetector>;
-    /** Fired for each signal a detector raises — the seam that raises a `finding` on the bus. */
-    readonly onSignal?: (signal: DetectorSignal, span: ToolSpan) => void | Promise<void>;
+declare function rollingDispatch<Out>(scope: Scope<Out>, opts: RollingDispatchOptions<Out>): Promise<DispatchReport<Out>>;
+/**
+ * Free worker slots under a simultaneity cap: `cap - live`, floored at 0, or `null` when there is
+ * no cap (the conserved pool is then the only fence and "free slots" is not a finite number).
+ * The one place the answer is computed, so the driver-facing tool payload and a dispatcher agree.
+ */
+declare function freeSlots(liveCount: number, cap: number | undefined): number | null;
+/** The caps a host can set on simultaneous work. See the ledger in this module's header for what
+ *  each one actually bounds. */
+interface ConcurrencyCaps {
+    /** Supervisor level: max spawned-but-unsettled workers. */
+    readonly maxLiveWorkers?: number;
+    /** Fleet level: max live sandboxes/boxes across the host process (a `ComputeGovernor`-style
+     *  cap). Applies to the worker layer, so it participates in the minimum. */
+    readonly maxSandboxes?: number;
 }
-/** The default online panel for a tool-call pipe: a worker repeating the same call, or hammering
- *  consecutive errors. (No-progress needs a domain progress-probe, so it is opt-in, not default.)
- *
- *  Coverage note: `repeated-action` works for EVERY harness (it needs only tool name + args, which
- *  every adapter provides). `error-streak` needs per-call status — opencode carries it inline
- *  (`state.status`, VALIDATED live), but claude-code/codex tool-call parts do NOT (their errors live
- *  in separate result blocks not yet decoded), so error-streak is silent for those until result-block
- *  decoding is added + live-validated. It is in the panel because it is correct where status exists. */
-declare function defaultToolDetectors(): StreamingDetector[];
-/** Subscribe to a `TraceSource` and run the streaming detectors over its live spans. Returns an
- *  unsubscribe. A defensive `argHash` failure (circular args) never throws out of the side-channel. */
-declare function watchTrace(source: TraceSource, opts?: WatchTraceOptions): () => void;
-
 /**
+ * The ONE honest effective limit on simultaneous workers: the minimum of the caps that actually
+ * bound the worker layer. Ignores unset/non-positive caps; returns `undefined` when no cap applies
+ * (uncapped — the conserved pool remains the only fence).
  *
- * The worker-side receive end of the down-leg: a per-worker inbox an executor exposes as
- * `Executor.deliver`. The driver's `steer_agent` / `answer_question` land here,
- * and the worker's agent loop drains them at two points (Drew's two delivery modes):
- *
- *   - QUEUED (default): the message accumulates and is FLUSHED at the next step boundary — folded
- *     into the conversation before the next think. A worker is also forced to flush BEFORE it may
- *     settle, so it can never finish while a steer/answer it never read is still pending.
- *   - FORCEFUL (`interrupt: true`): trips `freshInterrupt()`'s signal so the loop can abort its
- *     in-flight turn immediately, then re-plan with the message folded in — breaking the worker out
- *     of a wrong path mid-task instead of waiting for it to finish the step.
+ * Deliberately does NOT fold in `SandboxLineage`'s fork concurrency: that bounds boxes inside ONE
+ * leaf's fork wave, a different unit. Folding it in would report a 4-worker ceiling for what is
+ * really a 4-box fanout inside a single worker.
  *
- * `deliver` never throws — a malformed message is ignored, per the `Executor.deliver` contract.
- *
- * @experimental
+ * Use it once, at the top of a run, and pass the result to BOTH `maxLiveWorkers` and a
+ * dispatcher's `width` — that is what turns three unrelated numbers into one.
  */
-interface InboxMessage {
-    readonly kind: 'steer' | 'answer';
-    readonly text: string;
-    /** Forceful messages abort the in-flight turn; queued ones wait for the boundary flush. */
-    readonly interrupt: boolean;
-    /** Present for an `answer` — the question id it resolves. */
-    readonly questionId?: string;
-}
-interface Inbox {
-    /** The `Executor.deliver` implementation — accept a raw down-message from `Scope.send`. */
-    deliver(msg: unknown): void;
-    /** Remove and return all pending messages (the flush). */
-    drain(): InboxMessage[];
-    pending(): number;
-    /** Open a fresh per-turn interrupt signal; a later forceful `deliver` aborts it. The loop links
-     *  this into the signal it passes to its inference call, then re-plans when it fires. */
-    freshInterrupt(): AbortSignal;
-    /** Render drained messages as ONE operator turn to fold into the worker's conversation. */
-    fold(messages: ReadonlyArray<InboxMessage>): string;
-}
-/** Create the worker-side inbox for the down-leg: the driver's `steer_agent` / `answer_question` messages queue here and the worker's loop drains them at step boundaries and before settle. */
-declare function createInbox(): Inbox;
+declare function effectiveConcurrency(caps: ConcurrencyCaps): number | undefined;
+/** Convenience: a `DispatchUnit` factory over a fixed array of tasks, for the common case where
+ *  the queue is known up front and only the refill behavior is wanted. */
+declare function queueOf<Out>(units: ReadonlyArray<{
+    agent: Agent<unknown, Out>;
+    task: unknown;
+    label: string;
+}>, budget: Budget): () => DispatchUnit<Out> | undefined;
 
 /**
  * Throw a `ConfigError` when `allowed` is set, `model` is defined, and `model` is not a
@@ -3660,7 +3770,7 @@ declare function assertModelAllowed(model: string | undefined, allowed: readonly
  * @experimental
  */
 
-/** Options for the in-memory run context. */
+/** Options for a supervised run context. */
 interface InMemoryRunContextOptions {
     /**
      * Wrap the executor registry with `withDriverExecutor` so a spawned child marked
@@ -3678,12 +3788,35 @@ interface InMemoryRunContext {
     readonly journal: SpawnJournal;
     readonly blobs: ResultBlobStore;
     readonly executors: ExecutorRegistry;
+    /**
+     * Present (and `true`) only on a DURABLE context (`createFileRunContext`), so spreading the
+     * context into `SupervisorOpts` also opts the run into resume-first. An in-memory context
+     * leaves it undefined: there is never a prior tree to resume, and the default stays fresh-run.
+     */
+    readonly resume?: boolean;
 }
+/** The stores a supervised run needs, in-memory or file-backed. `InMemoryRunContext` is the
+ *  historical name for the same shape. */
+type RunContext = InMemoryRunContext;
 /**
  * Build a fresh in-memory run context. Every call returns NEW stores (no shared global
  * state between runs), so two runs never cross-contaminate their journals/blobs.
  */
 declare function createInMemoryRunContext(opts?: InMemoryRunContextOptions): InMemoryRunContext;
+/**
+ * Build a DURABLE run context: the spawn journal and the result blobs are file-backed (fsynced
+ * per append/write) under `dir`, and the context carries `resume: true` so spreading it into
+ * `SupervisorOpts` makes the supervisor `loadTree`-first. A run that dies mid-flight therefore
+ * resumes when it is re-run with the SAME `runId` and the SAME `dir`: the committed children come
+ * back on `Scope.resume` (rehydrated by `replaySpawnTree`) instead of being re-executed.
+ *
+ * Layout: `${dir}/spawn-journal.jsonl` (one JSONL record per event) and `${dir}/blobs/` (one
+ * content-addressed JSON file per settled result). The directory is created on first write.
+ *
+ * Opt-in by construction — `createInMemoryRunContext()` is unchanged and stays the default, so no
+ * existing consumer writes to disk or resumes unless it asks for this.
+ */
+declare function createFileRunContext(dir: string, opts?: InMemoryRunContextOptions): RunContext;
 
 /**
  *
@@ -3728,6 +3861,11 @@ interface ScopeArgs {
     readonly blobs: ResultBlobStore;
     /** The open executor resolver (BYO → router/inline → registered harness factory). */
     readonly executors: ExecutorRegistry;
+    /** Predicate resolver for `poll` wait-states. Absent ⇒ `wait` refuses a `poll` with
+     *  `unknown-probe`; `timer` waits never touch it. */
+    readonly probes?: WaitProbeRegistry;
+    /** Injected sleeper for wait-states — a test drives a week-long timer in microseconds. */
+    readonly waitSleep?: (ms: number, signal: AbortSignal) => Promise<void>;
     /** Per-spawn executor-construction seams (sandbox client, router config, cli bin). */
     readonly seams: Readonly<Record<string, unknown>>;
     /** This scope's recursion depth (root = 0). */
@@ -3742,6 +3880,25 @@ interface ScopeArgs {
      *  SAME stream `runLoop`/`tool-loop` feed, so the recursive tree is ONE observable stream
      *  (the topology viewer reads it). Undefined ⇒ the journal stays the only record. */
     readonly hooks?: RuntimeHooks;
+    /**
+     * Resume seam — set ONLY by the supervisor when `SupervisorOpts.resume` is on AND a non-empty
+     * journal tree exists for this root. It carries the replayed committed work (so `scope.resume`
+     * exposes it to a resume-aware `act`) and the recorded ordinal/cursor maxima the new counters
+     * continue past, so a freshly-spawned child never reuses a journaled `seq`. Absent ⇒ fresh run.
+     */
+    readonly resumeFrom?: {
+        readonly settled: ReadonlyArray<Settled<unknown>>;
+        readonly view: TreeView;
+        /** Highest `spawned` ordinal already journaled; new spawns start at `+1`. */
+        readonly maxSpawnOrdinal: number;
+        /** Highest cursor `seq` already journaled; new settlements start at `+1`. */
+        readonly maxCursorSeq: number;
+        /** Highest `waiting` ordinal already journaled; new waits start at `+1`. */
+        readonly maxWaitOrdinal: number;
+        /** Waits journaled as armed but never woken — re-armed (same node id, same absolute deadline)
+         *  when `wait` is called again with the SAME label. */
+        readonly waits: ReadonlyArray<PendingWait>;
+    };
 }
 /** Create the reactive `Scope` a driver's `Agent.act` runs inside: spawn children on an atomically reserved conserved budget, settle via the `next()` cursor, journal for replay. */
 declare function createScope<Out>(args: ScopeArgs): Scope<Out>;
@@ -3979,4 +4136,4 @@ declare function runInWorkspace<T>(ws: Workspace, body: (cwd: string) => Promise
     commitOnInvalid?: boolean;
 }): Promise<WorkspaceRun<T>>;
 
-export { Agent, AgentRunSpec, type AgentTurnBackend, type AgentTurnUsage, AgenticOptions, AgenticSurface, AgenticTask, AgenticTool, AnalystRegistry, type AnytimeReport, type AnytimeStrategySummary, type AnytimeTaskCurve, type ApplyContinuation, ArtifactHandle, AssertTraceDerivedFindings, type AuditIntentInput, type AuditIntentOptions, type AuthorStrategyOptions, type AuthoredProfile, type AuthoredStrategy, type BenchmarkCell, type BenchmarkConfig, type BenchmarkLift, type BenchmarkReport, type BenchmarkStrategySummary, type BenchmarkTaskRow, Budget, type BudgetPool, type BudgetReadout, type ChampionPick, type ChampionPolicy, type CheckpointCapableBox, type CollectedAgentTurn, CombinatorShape, type CompletionAnalyst, type CompletionEvidence, type CompletionPolicy, type CompletionVerdict, CoordinationEvent, type CoordinationMcpHandle, Corpus, CorpusFilter, CorpusRecord, type CreateScopeAnalystOptions, type CriuCapableClient, DefinePersonaInput, type DefinedLeaderboard, type DelegateOptions, type Deliverable, DeliverableSpec, Driver, type DriverAgentOptions, type DumbDriverOptions, type Environment, EqualKArm, EqualKOnCostOptions, EqualKVerdict, type EvolutionArchiveNode, type EvolutionAuthor, type EvolutionBandInfo, type EvolutionCandidate, type EvolutionGeneration, type EvolutionReport, ExecCtx, ExecutorConfig, ExecutorFactory, ExecutorRegistry, FanoutOptions, FanoutWinnerSelector, FileCorpus, type ForkCapableBox, type GitWorkspaceOptions, type HarvestCorpusOptions, type HarvestFailure, type HarvestReport, InMemoryCorpus, InMemoryResultBlobStore, type InMemoryRunContext, type InMemoryRunContextOptions, InMemorySpawnJournal, type InProcessOnPrompt, type InProcessPromptCtx, type InProcessSandboxClientOptions, type Inbox, type InboxMessage, type IntentAudit, type Interval, Iteration, type KeyProvider, type Leaderboard, type LeaderboardBenchScore, type LeaderboardBenchTask, type LeaderboardBenchmarkAdapter, type LeaderboardFlagSpec, type LeaderboardIterationInfo, type LeaderboardOptions, type LeaderboardRow, type LeaderboardRunContext, type LeaderboardScenario, type LeaderboardScore, type LeaderboardSpec, type LocalMcpMaterialization, type LocalSandboxClientOptions, type LoopCampaignDispatchOptions, type LoopDispatchOptions, LoopLineageOptions, type LoopOptionsForDispatch, LoopResult, LoopShape, LoopTokenUsage, LoopUntilSpec, LoopWinner, MakeWorkerAgent, type MaterializeLocalMcpOptions, type McpEndpoint, type McpEnvironmentOptions, McpSpawnFault, type McpToolDescriptor, MountRecorder, type NaiveDriverOptions, type Observation, type ObserveInput, type ObserveOptions, type OpenSandboxRunBeforeStartContext, type OpenSandboxRunOptions, type OpenSandboxRunPromptOptions, Outcome, OutputAdapter, type PairwiseOptions, type PairwiseVerdict, PanelSpec, Persona, PipelineStage, type ProfileRichness, type ProfileRichnessThresholds, type PromotionGateOptions, type PromotionVerdict, type RegistryAnalyzeProjection, RenderCorpusToInstructionsOptions, type ReservationTicket, type ResolveSandboxClientOptions, ResultBlobStore, RouterConfig, RunPersonifiedOptions, type SandboxCapabilities, SandboxClient, type SandboxLineage, type SandboxLineageHandle, type SandboxRun, SandboxRunAbortError, type SandboxToolPartState, Scope, ScopeAnalyst, ScopeAnalyzeInput, ScopeWidenGate, type SessionCapableBox, type SessionTraceBox, Settled, ShapeRegistry, type Shell, Spend, type StdioMcpConnection, type StdioMcpServerSpec, SteerContext, type SteeringDecision, Strategy, type StrategyEvolutionConfig, type StreamAgentTurnOptions, type SuperviseSurfaceOptions, type SuperviseSurfaceResult, SupervisedResult, Supervisor, SupervisorProfile, SurfaceScore, type SurfaceWorkerConfig, type SurfaceWorkerOut, ToolLoopChat, ToolLoopCompactionOptions, type TraceSource, type TrajectoryAnalysis, TrajectoryReport, TrajectoryReportOptions, type TurnResult, UsageEvent, type UsageSink, Validator, type VerifierEnvironmentOptions, VerifySpec, type WatchTraceOptions, type WaterfallCollector, type WaterfallReport, type WaterfallSpan, WidenSpec, WinnerStrategy, type Workspace, type WorkspaceCommit, type WorkspaceRun, acquireSandbox, analyzeTrace, anytimeReport, asAuthoredProfile, assertModelAllowed, assertStrategyContract, assertTraceDerivedFindings, assessAuthoredProfile, auditIntent, authorStrategy, authoredWorker, buildSteerContext, builtinShapes, collectAgentTurn, completionAuthorizes, connectStdioMcp, contentAddress, createBudgetPool, createInMemoryRunContext, createInbox, createMcpEnvironment, createPushTraceSource, createSandboxLineage, createSandboxToolPartState, createScope, createScopeAnalyst, createShapeRegistry, createSupervisor, createVerifierEnvironment, createWaterfallCollector, decodeToolPart, defaultAnalystInstruction, defaultAuditorInstruction, defaultDelegateBudget, defaultProfileRichnessThresholds, defaultSelectWinner, defaultToolDetectors, defineLeaderboard, definePersona, delegate, deterministicCompletion, discriminatingMeans, driverAgent, dumbDriver, envKeyProvider, equalKOnCost, extractLlmCallEvent, failuresAnalyst, fanout, finalizeBestDelivered, flatWidenGate, gitWorkspace, harvestCorpus, inProcessSandboxClient, inlineSandboxClient, jjWorkspace, leaderboard, localSandboxClient, localShell, loopCampaignDispatch, loopDispatch, loopUntil, mapSandboxEvent, mapSandboxToolEvent, materializeLocalMcp, mcpSecretEnvMetadataKey, naiveDriver, observe, openSandboxRun, pairwiseSignificance, panel, pickChampion, pipeline, printBenchmarkReport, probeSandboxCapabilities, profileRichnessFinding, promotionGate, registerShape, registryScopeAnalyst, renderAnytimeTable, renderCorpusToInstructions, renderLeaderboardHtml, renderLeaderboardMarkdown, renderLeaderboardSvg, renderPairwiseMarkdown, renderReport, reportLoopUsage, resolveSandboxClient, resolveSecretEnv, runBenchmark, runInWorkspace, runLoop, runPersonified, runStrategyEvolution, sandboxSessionTraceSource, sanitizeMcpToolSchema, secretEnvOfMcpServer, selectChampion, selectValidWinner, sentinelCompletion, serveCoordinationMcp, settledToIteration, spendFromUsageEvents, stopSentinel, strategyAuthorContract, streamAgentTurn, sumSandboxUsage, superviseSurface, supervisorInstructions, trajectoryReport, verify, watchTrace, widen };
+export { Agent, AgentRunSpec, type AgentTurnBackend, type AgentTurnUsage, AgenticOptions, AgenticSurface, AgenticTask, AgenticTool, AnalystRegistry, type AnytimeReport, type AnytimeStrategySummary, type AnytimeTaskCurve, type ApplyContinuation, ArtifactHandle, AssertTraceDerivedFindings, type AuditIntentInput, type AuditIntentOptions, type AuthorStrategyOptions, type AuthoredProfile, type AuthoredStrategy, type BenchmarkCell, type BenchmarkConfig, type BenchmarkLift, type BenchmarkReport, type BenchmarkStrategySummary, type BenchmarkTaskRow, Budget, type BudgetPool, type BudgetReadout, type ChampionPick, type ChampionPolicy, type CheckpointCapableBox, type CollectedAgentTurn, CombinatorShape, type CompletionAnalyst, type CompletionEvidence, type CompletionPolicy, type CompletionVerdict, type ConcurrencyCaps, CoordinationEvent, type CoordinationMcpHandle, Corpus, CorpusFilter, CorpusRecord, type CreateScopeAnalystOptions, type CriuCapableClient, DefinePersonaInput, type DefinedLeaderboard, type DelegateOptions, type Deliverable, DeliverableSpec, type DispatchReport, type DispatchStopReason, type DispatchUnit, Driver, type DriverAgentOptions, type DumbDriverOptions, type Environment, EqualKArm, EqualKOnCostOptions, EqualKVerdict, type EvolutionArchiveNode, type EvolutionAuthor, type EvolutionBandInfo, type EvolutionCandidate, type EvolutionGeneration, type EvolutionReport, ExecCtx, ExecutorConfig, ExecutorFactory, ExecutorRegistry, FanoutOptions, FanoutWinnerSelector, FileCorpus, FileResultBlobStore, FileSpawnJournal, type ForkCapableBox, type GitWorkspaceOptions, type HarvestCorpusOptions, type HarvestFailure, type HarvestReport, InMemoryCorpus, InMemoryResultBlobStore, type InMemoryRunContext, type InMemoryRunContextOptions, InMemorySpawnJournal, type InProcessOnPrompt, type InProcessPromptCtx, type InProcessSandboxClientOptions, type IntentAudit, type Interval, Iteration, type KeyProvider, type Leaderboard, type LeaderboardBenchScore, type LeaderboardBenchTask, type LeaderboardBenchmarkAdapter, type LeaderboardFlagSpec, type LeaderboardIterationInfo, type LeaderboardOptions, type LeaderboardRow, type LeaderboardRunContext, type LeaderboardScenario, type LeaderboardScore, type LeaderboardSpec, type LocalMcpMaterialization, type LocalSandboxClientOptions, type LoopCampaignDispatchOptions, type LoopDispatchOptions, LoopLineageOptions, type LoopOptionsForDispatch, LoopResult, LoopShape, LoopTokenUsage, LoopUntilSpec, LoopWinner, MakeWorkerAgent, type MaterializeLocalMcpOptions, type McpEndpoint, type McpEnvironmentOptions, McpSpawnFault, type McpToolDescriptor, MountRecorder, type NaiveDriverOptions, NodeId, type Observation, type ObserveInput, type ObserveOptions, type OpenSandboxRunBeforeStartContext, type OpenSandboxRunOptions, type OpenSandboxRunPromptOptions, Outcome, OutputAdapter, type PairwiseOptions, type PairwiseVerdict, PanelSpec, PendingWait, Persona, PipelineStage, type ProfileRichness, type ProfileRichnessThresholds, type PromotionGateOptions, type PromotionVerdict, type RegistryAnalyzeProjection, RenderCorpusToInstructionsOptions, type ReservationTicket, type ResolveSandboxClientOptions, ResultBlobStore, type RollingDispatchOptions, RouterConfig, type RunContext, RunPersonifiedOptions, type SandboxCapabilities, SandboxClient, type SandboxLineage, type SandboxLineageHandle, type SandboxRun, SandboxRunAbortError, type SandboxToolPartState, Scope, ScopeAnalyst, ScopeAnalyzeInput, ScopeWidenGate, type SessionCapableBox, Settled, ShapeRegistry, type Shell, SpawnEvent, SpawnJournal, SpawnOpts, Spend, type StdioMcpConnection, type StdioMcpServerSpec, SteerContext, type SteeringDecision, StopRule, Strategy, type StrategyEvolutionConfig, type StreamAgentTurnOptions, type SuperviseSurfaceOptions, type SuperviseSurfaceResult, SupervisedResult, Supervisor, SupervisorProfile, SurfaceScore, type SurfaceWorkerConfig, type SurfaceWorkerOut, ToolLoopChat, ToolLoopCompactionOptions, TraceSource, type TrajectoryAnalysis, TrajectoryReport, TrajectoryReportOptions, TreeView, type TurnResult, UsageEvent, type UsageSink, Validator, type VerifierEnvironmentOptions, VerifySpec, WaitProbeRegistry, type WaterfallCollector, type WaterfallReport, type WaterfallSpan, WidenSpec, WinnerStrategy, type Workspace, type WorkspaceCommit, type WorkspaceRun, acquireSandbox, analyzeTrace, anytimeReport, areaUnderCurve, asAuthoredProfile, assertModelAllowed, assertStrategyContract, assertTraceDerivedFindings, assessAuthoredProfile, auditIntent, authorStrategy, authoredWorker, bestSoFar, buildSteerContext, builtinShapes, collectAgentTurn, completionAuthorizes, connectStdioMcp, contentAddress, createBudgetPool, createFileRunContext, createInMemoryRunContext, createMcpEnvironment, createSandboxLineage, createSandboxToolPartState, createScope, createScopeAnalyst, createShapeRegistry, createSupervisor, createVerifierEnvironment, createWaterfallCollector, defaultAnalystInstruction, defaultAuditorInstruction, defaultDelegateBudget, defaultProfileRichnessThresholds, defaultSelectWinner, defineLeaderboard, definePersona, delegate, deterministicCompletion, discriminatingMeans, driverAgent, dumbDriver, effectiveConcurrency, envKeyProvider, equalKOnCost, extractLlmCallEvent, failuresAnalyst, fanout, finalizeBestDelivered, flatWidenGate, freeSlots, gitWorkspace, harvestCorpus, inProcessSandboxClient, inlineSandboxClient, jjWorkspace, leaderboard, localSandboxClient, localShell, loopCampaignDispatch, loopDispatch, loopUntil, mapSandboxEvent, mapSandboxToolEvent, materializeLocalMcp, materializeTreeView, mcpSecretEnvMetadataKey, naiveDriver, observe, openSandboxRun, pairwiseSignificance, panel, pendingWaits, pickChampion, pipeline, plateauLength, printBenchmarkReport, probeSandboxCapabilities, profileRichnessFinding, promotionGate, queueOf, registerShape, registryScopeAnalyst, renderAnytimeTable, renderCorpusToInstructions, renderLeaderboardHtml, renderLeaderboardMarkdown, renderLeaderboardSvg, renderPairwiseMarkdown, renderReport, replaySpawnTree, reportLoopUsage, resolveSandboxClient, resolveSecretEnv, rollingDispatch, runBenchmark, runInWorkspace, runLoop, runPersonified, runStrategyEvolution, sanitizeMcpToolSchema, secretEnvOfMcpServer, selectChampion, selectValidWinner, sentinelCompletion, serveCoordinationMcp, settledToIteration, spendFromUsageEvents, stopSentinel, strategyAuthorContract, streamAgentTurn, sumSandboxUsage, superviseSurface, supervisorInstructions, trajectoryReport, verify, widen };