@tangle-network/agent-runtime 0.300.0 → 0.306.1

package/dist/{index-sC6sl88d.d.ts → index-DflDZq_I.d.ts}

@@ -1,9 +1,9 @@
-import { $ as SpawnJournal, $i as LeakedReservation, A as NodeExecutionIdentity, Aa as LoopWinner, An as RetainedPendingCause, At as TraceContext, B as ResultBlobStore, Bn as ReconnectRetainedInteractiveRunOptions, Ca as LoopResult, Di as RecoverRetainedRunOptions, Dr as DriverReentry, Ei as RecoverRetainedRunIntentOptions, Fa as SandboxClient, I as ProviderModelExecutionEvidence, Ia as SelectionReceipt, J as RootStreamReceipt, Ji as StartRetainedRunOptions, Jn as HarnessTranscriptCapture, Kn as StartRetainedInteractiveRunOptions, L as RecursiveReservationPolicy, Ln as WorkerProgress, Lr as CheckRead, Lt as OtelExportConfig, M as NodeSnapshot, Ma as MountRecorder, Na as OutputAdapter, Oa as LoopTraceEmitter, Oi as RecoverRetainedRunResult, P as ProfileMaterializationReceipt, Pn as ExecutorProgress, Q as SpawnEvent, Ra as Validator, Ri as RetainedRunEffect, Rt as OtelExportStats, Sr as DriverContinuationRecord, Ti as ReconnectRetainedRunOptions, Tn as TraceSource, U as RetainedExecutionState, V as ResumedKeyState, Vi as RetainedRunHandle, Vn as RecoverRetainedInteractiveRunOptions, W as RootHandle, Wn as RetainedInteractiveRunHandle, X as Scope, Xa as AgentExecutionBackend, Y as Runtime, Yi as BudgetPool, Yn as HarnessTranscriptEvidence, Z as Settled, at as SpendGap, b as ExecutorRegistry, ba as LoopLineageOptions, bi as WorkerSlots, bt as WorkerInteractiveUnavailableReason, ct as SubtreeSummary, et as SpawnOpts, fa as Driver, fr as ProviderWorkspaceCaptureProvenance, g as ExecutorFactory, i as Budget, j as NodeId, ja as MountManifestEntry, k as NoWinnerError, ka as LoopTraceEvent, kn as RetainedChildRecovery, kr as DriverRetryPolicy, l as ExecutionBindingReceipt, lt as SupervisedResult, ma as Iteration, mt as UnconfirmedTeardown, n as AgentExecutionRef, o as BudgetViolation, oi as AgentEvalError$1, ot as SteerableRootHandle, pa as ExecCtx, pn as WaitProbeRegistry, po as RuntimeSessionStore, pt as TreeView, qi as StartRetainedRunInEnvironmentOptions, qr as ContinuationPolicy, r as AgentSpec, rt as Spend, s as DefaultVerdict, t as Agent, u as Executor, ua as AgentRunSpec, un as PendingWait, ut as Supervisor, vr as DriverAttemptRecord, w as FleetYield, wt as WorkerTraceResolver, x as ExecutorResult, xt as WorkerTraceEvidence, yi as SlotPermit, yt as WorkerInteractiveSession, zr as CheckVerdict, zt as OtelExporter } from "./types-C73caP0U.js";
+import { $ as SpawnJournal, $i as ExecCtx, A as NodeExecutionIdentity, B as ResultBlobStore, Ct as WorkerTraceResolver, Di as RetainedRunHandle, Dn as ReconnectRetainedInteractiveRunOptions, Er as CheckVerdict, Fi as BudgetPool, Fn as HarnessTranscriptCapture, I as ProviderModelExecutionEvidence, In as HarnessTranscriptEvidence, It as OtelExportConfig, J as RootStreamReceipt, Kr as AgentEvalError$1, L as RecursiveReservationPolicy, Lt as OtelExportStats, M as NodeSnapshot, Ni as StartRetainedRunInEnvironmentOptions, Nn as StartRetainedInteractiveRunOptions, On as RecoverRetainedInteractiveRunOptions, P as ProfileMaterializationReceipt, Pi as StartRetainedRunOptions, Pr as ContinuationPolicy, Q as SpawnEvent, Qi as Driver, Rt as OtelExporter, Sa as SelectionReceipt, U as RetainedExecutionState, V as ResumedKeyState, W as RootHandle, X as Scope, Xi as AgentRunSpec, Y as Runtime, Z as Settled, _a as MountManifestEntry, _n as RetainedPendingCause, _r as DriverRetryPolicy, ai as SlotPermit, at as SpendGap, b as ExecutorRegistry, bt as WorkerTraceEvidence, ct as SubtreeSummary, di as ReconnectRetainedRunOptions, ea as Iteration, er as ProviderWorkspaceCaptureProvenance, et as SpawnOpts, fi as RecoverRetainedRunIntentOptions, fn as TraceSource, g as ExecutorFactory, ga as LoopWinner, gn as RetainedChildRecovery, ha as LoopTraceEvent, hr as DriverReentry, i as Budget, j as NodeId, jn as RetainedInteractiveRunHandle, k as NoWinnerError, kt as TraceContext, l as ExecutionBindingReceipt, la as LoopResult, lt as SupervisedResult, ma as LoopTraceEmitter, mi as RecoverRetainedRunResult, mt as UnconfirmedTeardown, n as AgentExecutionRef, o as BudgetViolation, oa as LoopLineageOptions, oi as WorkerSlots, or as DriverAttemptRecord, ot as SteerableRootHandle, pi as RecoverRetainedRunOptions, pt as TreeView, r as AgentSpec, rt as Spend, s as DefaultVerdict, t as Agent, u as Executor, ur as DriverContinuationRecord, ut as Supervisor, va as MountRecorder, vt as WorkerInteractiveSession, w as FleetYield, wa as Validator, wi as RetainedRunEffect, wn as WorkerProgress, wr as CheckRead, x as ExecutorResult, xa as SandboxClient, xn as ExecutorProgress, ya as OutputAdapter, yt as WorkerInteractiveUnavailableReason, zi as LeakedReservation } from "./types-DeuEkBhI.js";
 import { n as AnalystRegistryLike } from "./types-zWfqDjeL.js";
 import { l as RuntimeHooks, o as RuntimeHookEvent, r as RuntimeDecisionPoint } from "./runtime-hooks-Bj6wJHlH.js";
-import { E as AgentCandidateOutputArtifactPort, c as AgentCandidateArtifactPort, t as AgentCandidateWorkspaceArchiveLimits } from "./workspace-archive-pz8YJ1fr.js";
-import { Bn as ToolLoopCompactionOptions, D as Inbox, Fn as RouterTransportConfig, Hn as ToolLoopToolCall, In as ToolSpec, Mt as AgentEnvironmentProviderRegistry, Nn as runLocalHarness, P as KeyProvider, Pn as RouterResponseReceipt, Rn as ToolLoopChat, Vn as ToolLoopMessageRecord, Yn as PeerMailLimits, cn as InPlaceHarnessResult, cr as JsonRpcResponse, dn as WorktreeHarnessResult, dr as McpTransport, er as PeerMailbox, f as ExecutorConfig, fr as Redactor, gn as GitRunner, h as RouterToolsSeam, ln as WorktreeCheckRunner, qn as PeerMailEvent, sr as JsonRpcMessage, ur as McpToolDescriptor$1 } from "./stream-agent-turn-I3bb0eqF.js";
-import { _ as CoderTask, d as ResearchSource, o as UiLens, r as UiFinding } from "./substrate-UjsxukjZ.js";
+import { P as AgentCandidateOutputArtifactPort, g as AgentCandidateArtifactPort, l as AgentCandidateWorkspaceArchiveLimits } from "./workspace-streams-CpSmt3zx.js";
+import { Bn as ToolLoopCompactionOptions, D as Inbox, Fn as RouterTransportConfig, Hn as ToolLoopToolCall, In as ToolSpec, Mt as AgentEnvironmentProviderRegistry, Nn as runLocalHarness, P as KeyProvider, Pn as RouterResponseReceipt, Rn as ToolLoopChat, Vn as ToolLoopMessageRecord, Yn as PeerMailLimits, cn as InPlaceHarnessResult, cr as JsonRpcResponse, dn as WorktreeHarnessResult, dr as McpTransport, er as PeerMailbox, f as ExecutorConfig, fr as Redactor, gn as GitRunner, h as RouterToolsSeam, ln as WorktreeCheckRunner, qn as PeerMailEvent, sr as JsonRpcMessage, ur as McpToolDescriptor$1 } from "./stream-agent-turn-B1giFgOg.js";
+import { _ as CoderTask, d as ResearchSource, o as UiLens, r as UiFinding } from "./substrate-L_sC7jCD.js";
 import { AGENT_PROFILE_MATERIALIZATION_AXES, AgentCandidateWorkspaceManifestMaterial, AgentCandidateWorkspaceSnapshotEvidence, AgentInteractiveSessionControlClaim, AgentInteractiveSessionRef, AgentProfile, AgentProfile as AgentProfile$2, AgentProfile as AgentProfile$3, AgentProfileDiff, AgentProfilePrompt, AgentProfileSecurityPolicy, CanonicalAgentProfileMaterializationAxis, Sha256Digest, profileMaterializationAxes as profileMaterializationAxes$1 } from "@tangle-network/agent-interface";
 import { AgentProfile as AgentProfile$1, AnalystFinding, AnalystFinding as AnalystFinding$1, AnalystFinding as AnalystFinding$2, AnalystRunInputs, ChatClient, CustomTokenPricing, DetectorSignal, HarnessType as HarnessType$1, MaximumCharge, PairedPromotionDecision, ProposalFinding, RankTestMethod, RegistryRunOpts, RunRecord, StreamingDetector, ToolSpan, TraceAnalysisEngine, TraceAnalysisStore, buildTrajectory, computeFindingId as computeFindingId$1, makeFinding as makeFinding$1 } from "@tangle-network/agent-eval";
 import { AgentRunOutcome } from "@tangle-network/sandbox/runtime";
@@ -258,434 +258,16 @@ declare function replaySpawnTree(journal: SpawnJournal, blobs: ResultBlobStore,
  * 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[];
-//#endregion
-//#region src/durable/spawn-journal-sql.d.ts
-/** The minimal statement seam; structurally the same shape `SqlConversationJournal` accepts. */
-interface SqlStatements {
-  /** Execute a write statement (INSERT/UPDATE/DELETE/DDL). */
-  exec(sql: string, params?: readonly unknown[]): Promise<{
-    rowsAffected: number;
-  }>;
-  /** Execute a read statement (SELECT). Returns rows as plain objects. */
-  query<TRow = Record<string, unknown>>(sql: string, params?: readonly unknown[]): Promise<TRow[]>;
-}
-/** SQL-backed `SpawnJournal`. One row per event; insertion order is replay order. */
-declare class SqlSpawnJournal implements SpawnJournal {
-  private readonly db;
-  private readonly table;
-  private readonly cache;
-  private appendTail;
-  constructor(db: SqlStatements, table?: string);
-  /** Create the journal's tables if absent. Idempotent. */
-  migrate(): Promise<void>;
-  loadTree(root: NodeId): Promise<SpawnEvent[] | undefined>;
-  beginTree(root: NodeId, at: string): Promise<void>;
-  appendEvent(root: NodeId, ev: SpawnEvent): Promise<void>;
-  private validationIndex;
-  private maxEventId;
-  private migrated;
-  private ensureMigrated;
-  private serializeAppend;
-}
-/** SQL-backed `ResultBlobStore`. One content-addressed row per settled result. */
-declare class SqlResultBlobStore implements ResultBlobStore {
-  private readonly db;
-  private readonly table;
-  private migrated;
-  constructor(db: SqlStatements, table?: string);
-  migrate(): Promise<void>;
-  put(outRef: string, artifact: unknown): Promise<void>;
-  get(outRef: string): Promise<unknown | undefined>;
-  private ensureMigrated;
-}
 //#endregion
-//#region src/conversation/call-policy.d.ts
+//#region src/durable/sql-adapter.d.ts
 /**
- *
- * Per-call resilience policy for participant backends: deadline, retry with
- * backoff, and a circuit breaker. Each policy is applied *around* a single
- * turn's backend invocation, not across the whole conversation — the
- * conversation-level credit cap and `maxTurns` bound the broader run.
- *
- * Deadlines abort the underlying backend stream via `AbortSignal` linkage so
- * the OpenAI/SDK clients tear down their HTTP request cleanly instead of
- * leaking sockets. Retries replay the same logical turn (same `turnId`) so
- * any caching gateway can dedupe. Circuit breakers are *per participant*: A's
- * failures don't open B's breaker.
+ * SQL seam for Runtime's shared-SQL run persistence (`openSqlRunStore`,
+ * `createFencedSqlRunContext`). Callers wire a `SqlAdapter` against the driver
+ * their deployment already uses (D1, postgres, sqlite, libSQL); Runtime takes
+ * no native database dependency.
  *
  * @stable
  */
-/** Pure judgment of whether an error is worth retrying. Defaults: TimeoutError, AbortError, fetch-level network errors. */
-type RetryableErrorPredicate = (err: unknown) => boolean;
-/** Backoff between attempts. Constant ms, or `(attempt: 1-indexed) => ms`. */
-type RetryBackoff = number | ((attempt: number) => number);
-/** Circuit-breaker tuning. `failuresToOpen` consecutive failures opens it; closed only after `cooldownMs`. */
-interface CircuitBreakerConfig {
-  failuresToOpen: number;
-  cooldownMs: number;
-}
-interface BackendCallPolicy {
-  /** Per-attempt wall clock limit. Exceeding fires an AbortSignal and is treated as a retryable failure. */
-  perAttemptDeadlineMs?: number;
-  /** Number of retries after the first attempt; total attempts = 1 + maxRetries. Default 0. */
-  maxRetries?: number;
-  /** Backoff between attempts. Default 250ms with jitter. */
-  retryBackoffMs?: RetryBackoff;
-  /** Custom retry classifier. Defaults to retrying transport failures and retryable HTTP statuses. */
-  isRetryable?: RetryableErrorPredicate;
-  /** Circuit breaker that opens after N consecutive failures per participant. */
-  circuitBreaker?: CircuitBreakerConfig;
-}
-//#endregion
-//#region src/conversation/headers.d.ts
-/**
- * Header bag carried through `AgentBackendContext.propagatedHeaders` so
- * backends that opt in can merge them into their outbound HTTP requests.
- * Distinct from `buildForwardHeaders` so callers can attach extra
- * non-protocol headers (e.g. tracing) without colliding.
- */
-type PropagatedHeaders = Readonly<Record<string, string>>;
-//#endregion
-//#region src/conversation/types.d.ts
-/** @stable */
-interface ConversationParticipant {
-  /**
-   * Stable name used as the speaker label in the transcript. Must be unique
-   * within a `Conversation`.
-   */
-  name: string;
-  /**
-   * Backend that runs this participant's turn. Reuses the existing
-   * `AgentExecutionBackend` contract from `runAgentTaskStream`, so an iterable,
-   * sandbox, or profile-backed Runtime executor works through the same runner.
-   */
-  backend: AgentExecutionBackend;
-  /**
-   * Optional human label for traces / dashboards. Distinct from `name`, which
-   * is the addressing key.
-   */
-  label?: string;
-  /**
-   * Optional per-participant override of the conversation's default
-   * `callPolicy`. Use to tighten the deadline or raise the retry budget for
-   * a participant known to be slow or flaky.
-   */
-  callPolicy?: BackendCallPolicy;
-  /**
-   * Who pays for THIS participant's outbound calls?
-   *
-   * - `'forward-user'` (default) — propagate the caller's
-   *   `X-Tangle-Forwarded-Authorization` so the downstream gateway bills the
-   *   original user. Right for pass-through agents that aggregate/route
-   *   without taking economic risk.
-   * - `'agent-owned'` — DO NOT forward the user's auth; the participant's
-   *   backend uses its own credentials (typically a sk-tan-AGENT or x402
-   *   wallet baked into the backend at construction). Downstream charges
-   *   land on the agent, not the user. Right for resold-bundle agents that
-   *   take margin between their inbound price and their sub-agent costs.
-   * - `(state) => AuthSource` — per-turn / per-condition decision, e.g. base
-   *   sub-services are agent-owned but premium add-ons forward the user.
-   *
-   * The agent's own credentials live on its caller-owned backend or
-   * profile-bound Runtime executor; this field is purely about *whether to
-   * also forward the user's identity downstream*.
-   */
-  authSource?: AuthSource;
-}
-/** @stable */
-type AuthSource = 'forward-user' | 'agent-owned' | ((state: ConversationDriveState) => 'forward-user' | 'agent-owned');
-/** @stable */
-type TurnOrder = 'alternate' | 'round-robin' | ((state: ConversationDriveState) => number);
-/** @stable */
-interface ConversationDriveState {
-  transcript: readonly ConversationTurn[];
-  turnIndex: number;
-  spentCreditsCents: number;
-}
-/** @stable */
-interface HaltContext extends ConversationDriveState {
-  lastTurn: ConversationTurn;
-}
-/** @stable */
-interface HaltSignal {
-  halted: true;
-  reason: string;
-}
-/** @stable */
-type HaltPredicate = (ctx: HaltContext) => boolean | HaltSignal | Promise<boolean | HaltSignal>;
-/** @stable */
-type HaltReason = {
-  kind: 'max_turns';
-  turns: number;
-} | {
-  kind: 'max_credits';
-  spentCents: number;
-  capCents: number;
-} | {
-  kind: 'predicate';
-  reason: string;
-} | {
-  kind: 'abort';
-} | {
-  kind: 'participant_error';
-  participant: string;
-  message: string;
-};
-/** @stable */
-interface ConversationPolicy {
-  /** Hard cap on speaker-turns. Each call into a participant's backend counts as 1. */
-  maxTurns: number;
-  /**
-   * Hard cap on aggregate credit spend across all participants, in cents.
-   * Computed by summing `llm_call.costUsd` from every participant's stream.
-   * Unset (`undefined`) means no credit ceiling — the run is bounded only by
-   * `maxTurns` and `haltOn`.
-   */
-  maxCreditsCents?: number;
-  /**
-   * Speaker selection. Defaults to `'alternate'` for two-participant
-   * conversations and `'round-robin'` for any other arity.
-   */
-  turnOrder?: TurnOrder;
-  /**
-   * Optional convergence / content-based halt. Called after every turn ends;
-   * returning truthy stops the loop with `{ kind: 'predicate', ... }`.
-   */
-  haltOn?: HaltPredicate;
-  /**
-   * Default per-turn resilience policy applied to every participant call
-   * (deadline, retries, circuit breaker). Individual participants may
-   * override via `ConversationParticipant.callPolicy`.
-   */
-  defaultCallPolicy?: BackendCallPolicy;
-}
-/** @stable */
-interface ConversationTurn {
-  index: number;
-  speaker: string;
-  /**
-   * Deterministic turn identifier — stable across retries of the same logical
-   * turn so caching gateways and trace backends can dedupe. Shape:
-   * `${runId}.t${index}.${speakerSlug}`.
-   */
-  turnId: string;
-  /** Backend session used for this turn. Present on turns recorded by session-aware runners. */
-  sessionId?: string;
-  text: string;
-  /**
-   * Aggregated backend usage for this turn alone. Populated from any
-   * `llm_call` stream events the backend emitted; `undefined` when the
-   * backend reports no usage.
-   */
-  usage?: {
-    tokensIn?: number;
-    tokensOut?: number;
-    costUsd?: number;
-    latencyMs?: number;
-    model?: string;
-  };
-  /**
-   * Number of attempts that ran before this turn committed. `1` is the
-   * common case; higher means the call policy retried after transient
-   * failures.
-   */
-  attempts: number;
-  startedAt: string;
-  endedAt: string;
-}
-/** @stable */
-interface Conversation {
-  participants: readonly ConversationParticipant[];
-  policy: ConversationPolicy;
-}
-/** @stable */
-interface RunConversationOptions {
-  /** First message kicking off the conversation. Routes to the first speaker. */
-  seed: string;
-  /**
-   * Optional run identifier for cross-participant trace correlation. Auto-
-   * generated when omitted. Reusing a runId against the same `journal`
-   * resumes the prior run — the runner replays the persisted transcript and
-   * continues from the first un-recorded turn.
-   */
-  runId?: string;
-  /** Cancellation signal — aborts mid-stream and halts with `{ kind: 'abort' }`. */
-  signal?: AbortSignal;
-  /**
-   * Event sink for per-turn micro-events. Distinct from the result transcript:
-   * the sink fires for every text-delta, every turn-start/end, and the
-   * conversation-start/end markers. Used to drive SSE / dashboard updates
-   * without waiting for the conversation to finish.
-   */
-  onEvent?: (event: ConversationStreamEvent) => void | Promise<void>;
-  /**
-   * Optional durable transcript. When set, the runner persists every
-   * committed turn before yielding `turn_end`. Reusing the same `runId`
-   * against the same journal resumes from the last committed turn — so a
-   * driver process crash mid-run loses zero acknowledged turns.
-   */
-  journal?: ConversationJournal;
-  /**
-   * Stores each participant's backend session. The runner keeps an in-memory
-   * store for one invocation when omitted. Reuse a durable store with the same
-   * `runId` and journal after a process restart. Backends implementing `resume`
-   * continue their provider session; other backends receive the full transcript.
-   */
-  sessionStore?: RuntimeSessionStore;
-  /**
-   * Headers to forward verbatim to every participant backend call (gateway
-   * propagation: `X-Tangle-Forwarded-Authorization`, run/turn correlation,
-   * depth counter). Backends opt in by reading `propagatedHeaders` from
-   * their `AgentBackendContext`; backends that ignore the field still work.
-   */
-  propagatedHeaders?: PropagatedHeaders;
-  /**
-   * Inbound depth at the point this driver was invoked. The runner
-   * increments it on every outbound participant call; gateways refuse at
-   * `DEFAULT_MAX_DEPTH`. Default 0 (origin caller).
-   */
-  inboundDepth?: number;
-  /**
-   * Parent turn id when this conversation is *inside* another turn (i.e. the
-   * driver is itself a participant via `createConversationBackend`). The
-   * runner stamps each outbound call with this as `X-Tangle-Parent-TurnId`
-   * so trace stitching survives nested orchestration.
-   */
-  parentTurnId?: string;
-}
-/** @stable */
-interface ConversationResult {
-  runId: string;
-  transcript: ConversationTurn[];
-  turns: number;
-  spentCreditsCents: number;
-  halted: HaltReason;
-  durationMs: number;
-  startedAt: string;
-  endedAt: string;
-}
-/** @stable */
-type ConversationStreamEvent = {
-  type: 'conversation_start';
-  runId: string;
-  participants: readonly string[];
-  seed: string;
-  timestamp: string;
-} | {
-  type: 'conversation_resumed';
-  runId: string;
-  participants: readonly string[];
-  transcript: readonly ConversationTurn[];
-  timestamp: string;
-} | {
-  type: 'turn_start';
-  runId: string;
-  index: number;
-  speaker: string;
-  turnId: string;
-  attempt: number;
-  timestamp: string;
-} | {
-  type: 'turn_text_delta';
-  runId: string;
-  index: number;
-  speaker: string;
-  turnId: string;
-  text: string;
-  timestamp?: string;
-} | {
-  type: 'turn_retry';
-  runId: string;
-  index: number;
-  speaker: string;
-  turnId: string;
-  attempt: number;
-  reason: string;
-  timestamp: string;
-} | {
-  type: 'turn_end';
-  runId: string;
-  turn: ConversationTurn;
-  timestamp: string;
-} | {
-  type: 'conversation_end';
-  runId: string;
-  result: ConversationResult;
-  timestamp: string;
-};
-//#endregion
-//#region src/conversation/journal.d.ts
-interface ConversationJournalEntry {
-  runId: string;
-  startedAt: string;
-  /** Set when the run reaches a terminal state. */
-  halted?: HaltReason;
-  endedAt?: string;
-  turns: ConversationTurn[];
-}
-interface ConversationJournal {
-  /**
-   * Load any prior state for `runId`. Returns `undefined` for a fresh run.
-   * Implementations MUST NOT mutate the returned object — the runner clones
-   * before continuing — but the runtime treats absence and emptiness
-   * identically, so a journal with zero turns is equivalent to "fresh."
-   */
-  loadRun(runId: string): Promise<ConversationJournalEntry | undefined>;
-  /**
-   * Initialise journal state for a fresh run. Called once per run, before any
-   * `appendTurn`. Idempotent: calling with an existing runId is a no-op if
-   * the entry already exists with the same `startedAt`.
-   */
-  beginRun(runId: string, startedAt: string): Promise<void>;
-  /**
-   * Append a committed turn. The runner only calls this AFTER the turn's
-   * backend stream completed and the credit total has been updated, so an
-   * appended turn is observed-committed and never speculative.
-   */
-  appendTurn(runId: string, turn: ConversationTurn): Promise<void>;
-  /**
-   * Record the run's terminal halt reason + end time. Once called, the run
-   * is observed-final; subsequent `loadRun` returns the same halt.
-   */
-  recordHalt(runId: string, halt: HaltReason, endedAt: string): Promise<void>;
-}
-/** In-memory `ConversationJournal` — suitable for testing and single-process runs. */
-declare class InMemoryConversationJournal implements ConversationJournal {
-  private readonly entries;
-  loadRun(runId: string): Promise<ConversationJournalEntry | undefined>;
-  beginRun(runId: string, startedAt: string): Promise<void>;
-  appendTurn(runId: string, turn: ConversationTurn): Promise<void>;
-  recordHalt(runId: string, halt: HaltReason, endedAt: string): Promise<void>;
-}
-/**
- * JSONL on disk. One line per record; first line is the `begin`, subsequent
- * lines are `turn` records, terminal line is `halt`. Replays the whole file
- * on `loadRun` — cheap for the conversation sizes this is designed for
- * (thousands of turns, not millions). For huge runs, plug in a real DB
- * adapter; the interface is small.
- *
- * Reads and appends over the shared append-only spine (`durable/jsonl-file`): each
- * `appendTurn` / `recordHalt` finishes a short write and calls `fsync`, so a process
- * crash between writes never loses an acknowledged turn, and a crash DURING one leaves
- * an uncommitted final line that the next read skips and the next append truncates.
- */
-declare class FileConversationJournal implements ConversationJournal {
-  private readonly path;
-  constructor(path: string);
-  loadRun(runId: string): Promise<ConversationJournalEntry | undefined>;
-  beginRun(runId: string, startedAt: string): Promise<void>;
-  appendTurn(runId: string, turn: ConversationTurn): Promise<void>;
-  recordHalt(runId: string, halt: HaltReason, endedAt: string): Promise<void>;
-  private appendRecord;
-}
-//#endregion
-//#region src/conversation/journal-sql.d.ts
 /**
  * Minimal SQL driver shape. Implementations forward to whichever client the
  * deployment already uses; agent-runtime takes no opinion on which.
@@ -722,32 +304,6 @@ interface D1StmtLike {
     results?: TRow[];
   }>;
 }
-/**
- * SQL-backed ConversationJournal. Two tables — runs (one row per runId, holds
- * start/halt timestamps + halt reason) and turns (one row per committed turn,
- * payload is the ConversationTurn JSON). Replays the turns table on
- * `loadRun` and writes append-only per `appendTurn`.
- */
-declare class SqlConversationJournal implements ConversationJournal {
-  private readonly db;
-  private readonly table;
-  /**
-   * @param db    SQL adapter (D1, postgres, sqlite, libSQL — all work)
-   * @param table Table-name prefix; the journal creates `${table}_runs` and
-   *              `${table}_turns`. Lets multiple journals share a database
-   *              without colliding (e.g. one per product surface).
-   */
-  constructor(db: SqlAdapter, table?: string);
-  /**
-   * Create the journal's tables if absent. Idempotent. Call once at deploy
-   * (or at app boot) — running on every request is harmless but adds latency.
-   */
-  migrate(): Promise<void>;
-  loadRun(runId: string): Promise<ConversationJournalEntry | undefined>;
-  beginRun(runId: string, startedAt: string): Promise<void>;
-  appendTurn(runId: string, turn: ConversationTurn): Promise<void>;
-  recordHalt(runId: string, halt: HaltReason, endedAt: string): Promise<void>;
-}
 //#endregion
 //#region src/durable/sql-run-store.d.ts
 /** @internal The SQL run context owns the payload schema; this store owns publication. */
@@ -927,6 +483,9 @@ interface EventBus<E extends BusEvent> {
   /** Register a pass-through handler; it receives the stamped record of every event published after
    *  registration. Returns an unsubscribe fn. */
   subscribe(handler: (record: BusRecord<E>) => void | Promise<void>): () => void;
+  /** Register a handler called once an event has entered the pull queue, after every subscriber
+   *  acknowledged it — the moment a waiting consumer can pull it. Returns an unsubscribe fn. */
+  onQueued(handler: (record: BusRecord<E>) => void): () => void;
   /** Count of queued, not-yet-pulled events (filtered by `kinds` when given). */
   pending(kinds?: ReadonlyArray<E['type']>): number;
   /** The full ordered log of every event published in this process (audit evidence, not replay). */
@@ -2408,7 +1967,7 @@ type ResolveSpawnResourcePathsResult = {
 declare function resolveSpawnResourcePaths(profile: unknown, source: string | SpawnResourceReader | undefined): Promise<ResolveSpawnResourcePathsResult>;
 //#endregion
 //#region src/mcp/tools/coordination.d.ts
-/** A worker the driver has drained via `await_event`. */
+/** A worker whose settlement reached the manager's inbox. */
 interface SettledWorker {
   readonly id: string;
   readonly status: 'done' | 'down';
@@ -2886,18 +2445,31 @@ type CoordinationEvent = {
   readonly type: 'analyst-assignment';
   readonly assignment: AnalystAssignmentRecord;
 } |
-/** The manager processed events `await_event` delivered to it. Record-only, and separate from
+/** The manager processed events a wake delivered to it. Record-only, and separate from
  *  delivery on purpose: an event delivered to a turn that then FAILED stays unacknowledged, and
  *  the manager's next re-entry names it again instead of losing it with the dead turn. */
 {
   readonly type: 'acknowledgement';
   readonly acknowledgement: EventAcknowledgement;
+} |
+/** A tool call that outlived its response fence settled. Queued: the manager's next wake
+ *  carries it, so the caller never re-calls to collect it. */
+{
+  readonly type: 'tool-outcome';
+  readonly outcome: ToolOutcomeEvent;
+} |
+/** This manager's lead (its parent manager, or the operator for a root) sent it a steer or an
+ *  answer. Queued: a manager's harness has no live inbox between turns, so the message is the
+ *  input of its next wake instead of a refused delivery. */
+{
+  readonly type: 'lead-message';
+  readonly message: LeadMessage;
 };
 /** One acknowledgement record: which delivered events are now processed, and on whose word. */
 interface EventAcknowledgement {
   /** Bus `seq` of each acknowledged event, in this process's sequence space. */
   readonly seqs: ReadonlyArray<number>;
-  /** `manager`: the manager named them in `await_event`'s `acknowledge`. `turn-completed`: the
+  /** `manager`: legacy rows from a manager that named them. `turn-completed`: the
    *  driver turn that received them ended normally. `result-accepted`: a submission passed the
    *  completion check after they were delivered. */
   readonly by: 'manager' | 'turn-completed' | 'result-accepted';
@@ -2917,14 +2489,14 @@ interface ManagerReentryState {
     readonly label: string;
     readonly status: string;
   }>;
-  /** Workers that settled, with whether their settlement reached the manager through `await_event`. */
+  /** Workers that settled, with whether their settlement reached the manager in a wake. */
   readonly settled: ReadonlyArray<{
     readonly id: string;
     readonly status: 'done' | 'down';
     readonly valid?: boolean;
     readonly delivered: boolean;
   }>;
-  /** Events queued for `await_event` and not yet delivered, including settlements the coordinator
+  /** Events queued for the next wake and not yet delivered, including settlements the coordinator
    *  holds but has not queued yet. */
   readonly waiting: ReadonlyArray<{
     readonly type: string;
@@ -3049,7 +2621,7 @@ interface CoordinationToolsOptions {
   readonly questionPolicy?: QuestionPolicy;
   /** Analyst lenses run AUTOMATICALLY when a worker settles `done` (the analyst-on-settle hook).
    *  A bare string names a lens whose findings go to THE DRIVER: published as a `finding` event on
-   *  the bus — pass-through to subscribers and queued for `await_event`. An
+   *  the bus — pass-through to subscribers and queued for the driver's next wake. An
    *  {@link AnalyzeOnSettleRoute} generalizes the DESTINATION: findings can be delivered to a
    *  named live WORKER (wrapped in the route's directive, through the same authorized steer
    *  machinery a driver steer uses) instead of being hardwired to the spawning driver, and `over`
@@ -3059,20 +2631,10 @@ interface CoordinationToolsOptions {
    *  the driver can still run lenses on demand via `run_analyst`). Lens routes require
    *  `analysts`; agent routes do not. */
   readonly analyzeOnSettle?: ReadonlyArray<string | AnalyzeOnSettleRoute>;
-  /** Max wall-clock ms a single `await_event` call may block waiting on a live worker to settle
-   *  before it returns a non-error `{ pending: true, live }` snapshot and lets the caller re-poll.
-   *  The underlying `scope.next()` blocks for the WHOLE (multi-minute) worker run; over a remote MCP
-   *  transport that block outlives the client's per-request timeout, so an unbounded await surfaces
-   *  to the supervisor as a hard tool ERROR on every call — the exact failure that leaves it flying
-   *  blind. Bounding the wait converts that error into a re-pollable liveness signal. The background
-   *  drain keeps running, so a settlement that lands after the bound is published to the bus and
-   *  pulled by the next call — nothing is lost. Omit = {@link DEFAULT_AWAIT_EVENT_TIMEOUT_MS}; `<= 0`
-   *  restores the prior UNBOUNDED block (only safe for in-process drivers with no transport timeout). */
-  readonly awaitTimeoutMs?: number;
   /**
    * OPT-IN: run the ONLINE detector panel over each spawned worker's live tool trace and raise a
    * `finding` on the bus the moment a detector fires — so the driver learns "this worker is
-   * looping" mid-run, from `await_event`, instead of at settle.
+   * looping" mid-run, in its next wake, instead of at settle.
    *
    * This closes the `watchTrace` → `raiseFinding` wire whose own docstring already described it
    * ("the seam an ONLINE detector uses to tell the driver 'this worker is looping/erroring' the
@@ -3257,13 +2819,58 @@ interface WorkerWatchOptions {
    *  driver's inbox with the same signal every span. Default 3; `<= 0` = unlimited. */
   readonly maxFindingsPerWorker?: number;
 }
-/** Default ceiling for a single `await_event` block (ms). Every `pending` return costs the driver an
- *  inference turn, so the ceiling is as long as the harness clients allow: Claude Code 2.1.287 and
- *  Codex both time out an MCP tool call at 60 s by default (measured 2026-10-03: a 150 s HTTP MCP
- *  call failed at about 60 s and passed with `MCP_TOOL_TIMEOUT=300000`), and the Sandbox edge held
- *  a 200 s response. 45 s leaves 15 s of that minute for transfer and the driver's own latency. At
- *  15 s a Discovery root director spent 303 of its 401 native tool calls (76%) re-polling. */
-declare const DEFAULT_AWAIT_EVENT_TIMEOUT_MS = 45000;
+/** What a manager waits for, from `awaitWake`. */
+interface AwaitWakeInput {
+  /** The driver attempt the wake will start: its deliveries are acknowledged when that turn
+   *  completes, and named again on re-entry when it fails. Omit for the current attempt. */
+  readonly attempt?: number;
+  readonly signal: AbortSignal;
+  /** Wake with no event after this long, so a waiting manager can reconsider. */
+  readonly heartbeatMs: number;
+  /** After the first event, wait this long for more and deliver them together. */
+  readonly debounceMs: number;
+  /** Epoch ms of a deadline warning: wake once then, with or without an event. */
+  readonly deadlineAt?: number;
+  /** Something outside the bus that also ends the wait, such as a delivery to the manager's own
+   *  inbox. */
+  readonly alsoWakeOn?: Promise<unknown>;
+}
+/** One wake of a manager that ended its turn with work open. */
+interface ManagerWake {
+  /** `events`: something reached the inbox. `heartbeat`: the heartbeat elapsed with nothing new.
+   *  `deadline`: the deadline warning came due. */
+  readonly reason: 'events' | 'heartbeat' | 'deadline';
+  /** Everything that reached the inbox since the last turn, in bus order. */
+  readonly events: ReadonlyArray<Record<string, unknown> & {
+    readonly eventSeq: number;
+  }>;
+  /** Workers still running. */
+  readonly live: ReadonlyArray<Record<string, unknown>>;
+  /** How many more workers can start now; `null` when uncapped. */
+  readonly freeSlots: number | null;
+  /** How long the manager waited, with no model turn, before this wake. */
+  readonly idleMs: number;
+}
+/** A steer or an answer this manager received from its lead. */
+interface LeadMessage {
+  readonly kind: 'steer' | 'answer';
+  readonly text: string;
+  readonly questionId?: string;
+  /** The lead asked for the message to interrupt; it is delivered at the next wake either way. */
+  readonly interrupt: boolean;
+}
+/** A tool call that outlived its response fence, and its outcome once it settled. */
+interface ToolOutcomeEvent {
+  /** The receipt the caller was given when the fence elapsed. */
+  readonly receipt: string;
+  readonly tool: string;
+  readonly ok: boolean;
+  /** The tool's result, when it succeeded. */
+  readonly value?: unknown;
+  /** The tool's error message, when it failed. */
+  readonly error?: string;
+  readonly elapsedMs: number;
+}
 /**
  * The supervisor-side toolbox returned by {@link createCoordinationTools}: the MCP tool
  * descriptors a driver `AgentProfile` calls to spawn, steer, observe, and settle workers
@@ -3304,7 +2911,7 @@ interface CoordinationTools {
   readonly peerMail?: PeerMailbox;
   /** Raise a `finding` on the bus from outside the settle hook — the seam an ONLINE detector
    *  (mid-run, on the worker pipe) uses to tell the driver "this worker is looping/erroring" the
-   *  moment it happens, instead of only at settle. Queued for `await_event` + pass-through. */
+   *  moment it happens, instead of only at settle. Queued for the next wake + pass-through. */
   raiseFinding(finding: AnalystFindingEvent): Promise<void>;
   /** Authorize, durably record, and attempt one external steer through the same down-leg used by
    * `steer_agent`. The returned outcome is exact and is never inferred from queue admission. */
@@ -3344,6 +2951,32 @@ interface CoordinationTools {
   /** Mark the end of the current driver attempt. A completed turn acknowledges what it received;
    *  a failed one leaves its deliveries unacknowledged for the next re-entry to name. */
   endDriverAttempt(outcome: 'completed' | 'failed'): Promise<void>;
+  /** True while this manager has work it must hear back about: a worker running, a result or
+   *  question not yet delivered, or a tool call still running past its response fence. A turn
+   *  that ends with open work is a wait, not a completion. */
+  hasOpenWork(): boolean;
+  /** Wait, with no model turn, until something reaches this manager's inbox, the heartbeat
+   *  elapses, or the deadline warning comes due; then deliver everything that arrived. Undefined
+   *  when no work is open or the signal aborted. */
+  awaitWake(input: AwaitWakeInput): Promise<ManagerWake | undefined>;
+  /** Wait in code, with no model turn, until at least one of `workerIds` has settled into this
+   *  manager's ledger; returns the ids that have. Nothing is taken from the inbox: the manager
+   *  still receives each settlement in its own wake. Empty when none of them is live or settled. */
+  awaitSettlement(workerIds: ReadonlyArray<string>, signal?: AbortSignal): Promise<ReadonlyArray<string>>;
+  /** Queue a steer or answer from this manager's lead for its next wake. False when the message
+   *  is neither. The publish is in-process; a durable subscriber records it. */
+  receiveLeadMessage(message: unknown): boolean;
+  /** Register a tool call that outlived its response fence; returns the receipt its caller is
+   *  given. The call is open work until {@link CoordinationTools.settleToolReceipt}. */
+  openToolReceipt(tool: string): string;
+  /** Publish the outcome of a receipted tool call to the inbox, where the next wake delivers it. */
+  settleToolReceipt(receipt: string, outcome: {
+    readonly ok: true;
+    readonly value: unknown;
+  } | {
+    readonly ok: false;
+    readonly error: unknown;
+  }): Promise<void>;
   /** The run state a re-entered manager is told, read from this coordinator's own records. */
   reentryState(): ManagerReentryState;
   /** Every time this manager's completion check ran, oldest first: each `submit_result`, and each
@@ -3493,45 +3126,6 @@ declare function anytimeReport(spans: WaterfallSpan[], opts?: {
 /** One row per (strategy, satisficing target): the shareable time-to-satisfactory table. */
 declare function renderAnytimeTable(report: AnytimeReport): string;
 //#endregion
-//#region src/runtime/audit-intent.d.ts
-interface AuditIntentInput {
-  /** The declared intent: the task text / acceptance criteria the agent was given. */
-  declaredIntent: string;
-  /** The trajectory so far — tool calls + results + assistant turns (any event shapes). */
-  trace: ReadonlyArray<unknown>;
-  /** The principal's actual intent when it differs from the literal task (the contract). */
-  userIntent?: string;
-  /** The loop-level purpose (meta-intent): what the WHOLE run is for — lets the auditor
-   *  flag locally-sensible work that serves the wrong larger objective. */
-  metaIntent?: string;
-  runId?: string;
-}
-interface AuditIntentOptions {
-  /** Exact auditor identity. */
-  profile: AgentProfile;
-  /** Execution substrate. All behavior comes from the profile. */
-  executor: ExecutorConfig;
-  /** Cap trace lines fed to the auditor. Default 80. */
-  maxTraceLines?: number;
-  signal?: AbortSignal;
-}
-interface IntentAudit {
-  /** What the agent's actions reveal it is actually optimizing — one sentence. */
-  revealedIntent: string;
-  verdict: 'aligned' | 'drifting' | 'diverged';
-  /** Trajectory-grounded evidence for the verdict (specific calls/patterns). */
-  evidence: string;
-  /** The single recommended intervention. */
-  recommendation: 'continue' | 'steer' | 'abort';
-  /** When recommendation is 'steer': the corrective instruction to inject. */
-  steer?: string;
-  confidence: number;
-}
-/** Default system instruction for intent-auditor agents: diagnose diverged/drifting trajectories. */
-declare const defaultAuditorInstruction: string;
-/** The route-rigor analyst: compare declared vs revealed vs user intent over a trajectory and return aligned / drifting / diverged with evidence and one recommended intervention. */
-declare function auditIntent(input: AuditIntentInput, opts: AuditIntentOptions): Promise<IntentAudit>;
-//#endregion
 //#region src/runtime/benchmark-report.d.ts
 /** Pull the headline score in [0,1] from a record. Default: the held-out split, else the search split,
  *  else a `composite`/`passed`/`score` entry in the raw bag. Override to score a domain differently. */
@@ -4163,18 +3757,13 @@ declare function serveCoordinationMcp(opts: CoordinationTransportOptions & {
   perWorker: Budget;
   /** Independent completion check exposed to the driver as `submit_result`. The check runs
    *  inside that call, so the call is served single-flight and fenced like `nodeTools`: a check
-   *  still running at the fence returns a pending result, and an identical resubmission joins
-   *  that check and returns its verdict. */
+   *  still running at the fence returns a receipt, and the verdict reaches the manager in its
+   *  next wake. */
   deliverable?: DeliverableSpec<unknown>;
   /** Serve `read_continuation` from the manager's continuation records. */
   readContinuation?: (continuation: number | undefined) => unknown;
   /** Called once when the external manager accepts a result or declares completion. */
   onStop?: (reason: string | undefined) => void;
-  /** Max wall-clock ms a single `await_event` may block before returning a re-pollable
-   *  `{ pending, live }` snapshot instead of erroring on the client's request timeout. Omit =
-   *  the `coordinationResponseFenceMs` derived from the request timeout; `<= 0` = prior unbounded
-   *  block (in-process only). */
-  awaitTimeoutMs?: number;
   /** Trace-analyst lenses the driver can run (`run_analyst`) or auto-fire on settle. */
   analysts?: AnalystRegistry$1;
   /** Analyst kinds to auto-run when a worker settles `done` — findings flow up the bus. */
@@ -4208,7 +3797,8 @@ declare function serveCoordinationMcp(opts: CoordinationTransportOptions & {
   /** Product-selected tools already bound to this exact supervisor node. They share this server
    *  with the coordination verbs, so the existing MCP duplicate-name guard applies before listen.
    *  Each is served single-flight and fenced (`./single-flight-tools`): an identical call joins
-   *  the unreturned run, and a call still running at the fence returns a pending result. */
+   *  the running call, and a call still running at the fence returns a receipt whose outcome
+   *  reaches the manager in its next wake. */
   nodeTools?: ReadonlyArray<McpToolDescriptor$1>;
   /** Exact bare tool names to expose from the coordination and node-tool set. Runtime never
    *  grants an implicit complete tool set. An unknown name fails before the listener opens. */
@@ -4250,7 +3840,7 @@ declare function serveCoordinationMcp(opts: CoordinationTransportOptions & {
   /** Called with this server's exact MCP tool descriptors once they exist and BEFORE the listener
    *  opens — the seam a caller uses to give an already-bound node tool a way to call the same
    *  verbs in code (`SupervisorToolInvocationContext.verbs`). */
-  onCoordinationTools?: (tools: ReadonlyArray<McpToolDescriptor$1>) => void;
+  onCoordinationTools?: (tools: ReadonlyArray<McpToolDescriptor$1>, coordination: Pick<CoordinationTools, 'awaitSettlement'>) => void;
 }): Promise<CoordinationMcpHandle>;
 //#endregion
 //#region src/runtime/supervise/finalizer.d.ts
@@ -4389,9 +3979,6 @@ interface ProgressView {
   readonly workers: ReadonlyArray<WorkerProgress>;
   /** Nodes running or acquiring. */
   readonly inFlight: number;
-  /** Armed wait-state nodes — deliberately separate from `inFlight`: a tree whose only remaining
-   *  nodes are waits is NOT stalled, it is waiting on the world. */
-  readonly waiting: number;
 }
 /** A stop rule's answer. `reason` is required when stopping — a run that ends must be able to say
  *  why in the result, and an unexplained early stop is indistinguishable from a bug. */
@@ -4499,6 +4086,19 @@ declare function anyOf(...rules: ReadonlyArray<StopRule>): StopRule;
 /** Stop only when EVERY rule stops — for a conservative gate that needs corroboration. */
 declare function allOf(...rules: ReadonlyArray<StopRule>): StopRule;
 //#endregion
+//#region src/runtime/supervise/wake.d.ts
+/** How Runtime wakes a manager that ended its turn with work open. */
+interface ManagerWakePolicy {
+  /** Wake with no event after this long, so a waiting manager can reconsider. Default 15 min. */
+  readonly heartbeatMs?: number;
+  /** After the first event, wait this long for more and deliver them together. Default 2 s. */
+  readonly debounceMs?: number;
+  /** Wake once this long before the deadline and ask for the best result now. Default 15 min. */
+  readonly deadlineWarningMs?: number;
+}
+/** How long before its deadline a manager is woken once to submit its best result: 15 min. */
+declare const DEFAULT_DEADLINE_WARNING_MS: number;
+//#endregion
 //#region src/runtime/supervise/supervisor-agent.d.ts
 /** A supervisor is an exact canonical AgentProfile; no looser model/prompt shape exists. */
 type SupervisorProfile = AgentProfile;
@@ -4552,7 +4152,9 @@ type SupervisorNodeContextSeed = Omit<SupervisorNodeContext, 'nodeId' | 'profile
  */
 interface CoordinationVerbs {
   spawnAgent(args: unknown): Promise<unknown>;
-  awaitEvent(args: unknown): Promise<unknown>;
+  /** Wait in code until at least one of `{ workerIds }` has settled; returns `{ settled: ids }`.
+   *  Takes nothing from the manager's inbox, so the manager still hears of each settlement. */
+  awaitSettlement(args: unknown): Promise<unknown>;
   steerAgent(args: unknown): Promise<unknown>;
   observeAgent(args: unknown): Promise<unknown>;
   listQuestions(args: unknown): Promise<unknown>;
@@ -4598,7 +4200,7 @@ type ObserveSupervisorNodeEvent = (context: SupervisorNodeContext, event: Coordi
 /** How to run an external harness as the DRIVER, with the coordination verbs mounted — the substrate
  *  seam the caller supplies (mirrors `makeWorkerAgent` for spawned children). It runs `profile` on
  *  `task` in its backend (remote sandbox or local CLI bridge) with `coordinationMcpUrl` mounted as an MCP server,
- *  so the harness calls spawn_worker / await_event / stop as native tools over the live scope. */
+ *  so the harness calls spawn_worker / observe_agent / submit_result as native tools over the live scope. */
 interface DriveHarness {
   (args: {
     /** The exact provider-visible projection. Runtime-owned coordination tool declarations are
@@ -4734,9 +4336,9 @@ interface SupervisorAgentDeps {
   readonly watchWorkers?: WorkerWatchOptions;
   /** Idle time after which `observe_agent` reports a worker as stalled. Omit = runtime default. */
   readonly stallAfterMs?: number;
-  /** Router-driver arm only: max ms one `await_event` blocks before returning `{ pending }`. The
-   *  harness arm keeps the fence derived from its MCP request timeout. Omit = runtime default. */
-  readonly awaitTimeoutMs?: number;
+  /** How Runtime wakes this manager after it ends a turn with work open (both arms). Omit = the
+   *  defaults in `./wake`. */
+  readonly wake?: ManagerWakePolicy;
   /** Default continuity per worker PROFILE NAME (both arms) — `'resume'` re-attaches spawns of
    *  that name to the node's latest settled worker; `spawn_worker`'s per-call `continuity`
    *  overrides. Omit = every spawn fresh (status quo). */
@@ -5094,21 +4696,21 @@ declare function workerFromBackend(backend: ExecutorConfig, deliverable?: Delive
 /** Manager-authored profiles are untrusted until product policy says otherwise. Remote MCP and
  * ambient connection grants therefore fail closed by default, in addition to local MCP and hooks. */
 declare const DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY: AgentProfileSecurityPolicy;
-/** A name→value table, in this package's resolver-port shape (the same one `WaitProbeRegistry`
- *  uses): construction stays the caller's, lookup stays lazy, and a table backed by a file, a
- *  plugin loader, or a plain object all satisfy one interface. */
+/** A name→value table in this package's resolver-port shape: construction stays the caller's,
+ *  lookup stays lazy, and a table backed by a file, a plugin loader, or a plain object all
+ *  satisfy one interface. */
 interface SuperviseRegistryTable<T> {
   resolve(name: string): T | undefined;
-  /** The names the table holds. The four code-valued tables may omit it, because a caller names
+  /** The names the table holds. The three code-valued tables may omit it, because a caller names
    *  their entries from data it already has. The profiles table must list them, because a
    *  director can choose only from a menu it can read. */
   names?(): readonly string[];
 }
 /**
- * The name→value tables that make the four CODE-valued options expressible as run DATA, and the
+ * The name→value tables that make the three CODE-valued options expressible as run DATA, and the
  * profiles a director may spawn by name.
  *
- * `deliverable` / `finalizer` / `analysts` / `probes` are functions and registries, so a recorded
+ * `deliverable` / `finalizer` / `analysts` are functions and registries, so a recorded
  * run configuration (a JSON row, a campaign spec, a resumed run's options) cannot carry them — and
  * a run with no `deliverable` cannot return a `winner` at all outside the sandbox backend, because
  * the finalizer keeps only children whose oracle passed and nothing else writes that verdict. A
@@ -5125,7 +4727,6 @@ interface SuperviseRegistry {
   readonly deliverables?: SuperviseRegistryTable<DeliverableSpec<unknown>>;
   readonly finalizers?: SuperviseRegistryTable<SupervisorFinalizer>;
   readonly analysts?: SuperviseRegistryTable<AnalystRegistry$1>;
-  readonly probes?: SuperviseRegistryTable<WaitProbeRegistry>;
   readonly profiles?: SuperviseRegistryTable<SuperviseProfileEntry> & {
     names(): readonly string[];
   };
@@ -5266,7 +4867,7 @@ interface SuperviseOptions {
    *  Omit to run profiles exactly as authored: Runtime selects no standing guidance by itself. */
   readonly profileGuidance?: 'profile-kb';
   /** Whether a spawned profile that declares no Runtime coordination tool receives its manager's
-   *  coordination grants (`spawn_worker`, `await_event`, and the rest, plus `submit_result` so it
+   *  coordination grants (`spawn_worker`, `observe_agent`, and the rest, plus `submit_result` so it
    *  can still deliver work it does itself), so every child can lead children of its own. Default
    *  `true`. A child whose author wrote any coordination entry, true or false, keeps what was
    *  written (a `false` entry is dropped once it has kept the child a leaf). A child this run
@@ -5422,13 +5023,13 @@ interface SuperviseOptions {
    *  `registry.analysts`. */
   readonly analysts?: AnalystRegistry$1 | string;
   /** Analyst kind ids run AUTOMATICALLY when a worker settles `done` — each re-enters as a `finding`
-   *  the driver pulls (`await_event`) and composes its next steer from. The self-improving UP-leg,
+   *  the driver receives in its next wake and composes its next steer from. The self-improving UP-leg,
    *  threaded to the driver at this level (propagate to sub-drivers via a recursive `makeWorkerAgent`).
    *  Omit/empty = status quo (no analyst feed). Requires `analysts`. */
   readonly analyzeOnSettle?: ReadonlyArray<string | AnalyzeOnSettleRoute>;
   /**
    * Watch every worker's LIVE tool trace with the online detector panel and raise a `finding` the
-   * moment one loops or error-storms — so the supervisor learns it mid-run (via `await_event`)
+   * moment one loops or error-storms — so the supervisor learns it mid-run (in its next wake)
    * instead of at settle. Pairs with a steerable worker: the finding is the evidence, `steer_agent`
    * is the correction. Requires a backend whose executor exposes a trace source (the steerable
    * sandbox worker and the pi wrapper do); other runtimes are simply not watched.
@@ -5439,11 +5040,10 @@ interface SuperviseOptions {
   /** Idle time after which `observe_agent` reports a running worker as `stalled`. A derived read
    *  at observation time — nothing is killed or retried. Omit = the runtime default. */
   readonly stallAfterMs?: number;
-  /** Max wall-clock ms one `await_event` of an in-process Router driver blocks before it returns a
-   *  re-pollable `{ pending, live }` snapshot. Each return costs the driver a turn, so a run whose
-   *  workers take hours needs either a large `maxTurns` or a longer wait. A harness-driven
-   *  supervisor keeps the fence derived from its MCP request timeout. Omit = the runtime default. */
-  readonly awaitTimeoutMs?: number;
+  /** How Runtime wakes a manager that ended its turn with work open: the heartbeat, the debounce
+   *  that coalesces events into one wake, and the deadline warning. Omit = the defaults in
+   *  `./wake` (15 min, 2 s, 15 min). */
+  readonly wake?: ManagerWakePolicy;
   /** Default continuity per worker PROFILE NAME: `'resume'` makes each spawn of that name after
    *  the first re-attach to the node's most recent SETTLED worker — a NEW live worker whose spawn
    *  context carries the prior worker's identity (`WorkerSpawnContext.resume`), which the executor
@@ -5479,8 +5079,9 @@ interface SuperviseOptions {
    * resumable run per directory but collides across concurrent runs sharing one `runDir`.
    */
   readonly runDir?: string;
-  /** Opt into resume-first explicitly when the durable stores are caller-supplied (`journal` +
-   * `blobs`, e.g. `createSqlRunContext`) instead of derived from `runDir`. Exactly what the file
+  /** Advanced test seam: opt into resume-first when the durable stores are caller-supplied
+   * (`journal` + `blobs` / `runContext`) instead of derived from `runDir`. The normal durable path
+   * is `runDir` or a `runContext` (see `docs/durability.md`). Exactly what the file
    * context sets automatically: load the prior tree for `runId` before starting fresh, refuse a
    * reused id without it. Ignored when `runDir` is also set — the file context owns the flag. */
   readonly resume?: boolean;
@@ -5489,11 +5090,6 @@ interface SuperviseOptions {
   /** Override the spawn journal directly (advanced; `runDir` is the ordinary durable path). Pair
    *  with `blobs` — a journal whose result payloads live in a different store cannot replay. */
   readonly journal?: SpawnJournal;
-  /** Predicate registry for `poll` wait-states (`Scope.wait`). A `poll` names its predicate so the
-   *  wait survives a restart; this is what the name resolves against. Unset ⇒ `poll` waits are
-   *  refused `unknown-probe` and `timer` waits still work. A `string` names an entry in
-   *  `registry.probes`. */
-  readonly probes?: WaitProbeRegistry | string;
   /**
    * PROGRESS-derived stop rule (BOTH arms). Ends a run that has stopped LEARNING before it
    * exhausts a ceiling — the answer to "a run should end because it is done or stuck, not because
@@ -5801,11 +5397,6 @@ declare class FileObserverJournal implements ObserverJournal {
 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;
-/** Build the canonical durable observer hook in one call. */
-declare function createFileObserverHooks(path: string, pursuitId: string): {
-  readonly journal: FileObserverJournal;
-  readonly hooks: RuntimeHooks;
-};
 //#endregion
 //#region src/durable/observer-projection.d.ts
 /**
@@ -5992,7 +5583,6 @@ interface PursuitNodeProjection {
   /** Each channel on which the settled spend exceeded the node's reservation. The status is the
    *  node's own outcome: a `done` node that overspent still delivered its output. */
   readonly budgetViolation?: BudgetViolation;
-  readonly wait?: unknown;
   readonly firstSequence: number;
   readonly lastSequence: number;
   readonly firstObservedAt: number;
@@ -6062,19 +5652,6 @@ interface PursuitObserverDelivery {
   readonly timeoutMs?: number;
   readonly fetch?: typeof fetch;
 }
-/** The execution state Runtime reports. It never claims the pursuit's semantic success. */
-type PursuitObserverState = 'running' | 'done' | 'failed';
-type PursuitObserverDeliveryOutcome = {
-  readonly succeeded: true;
-  readonly status: number;
-} | {
-  readonly succeeded: false;
-  readonly reason: string;
-};
-/** The Intelligence route that persists a delivered projection on its run spine. */
-declare const PURSUIT_OBSERVER_DELIVERY_PATH = "/v1/ingest/pursuit-observer";
-/** POST one projection. Never throws; the outcome says whether Intelligence accepted it. */
-declare function deliverPursuitObserver(delivery: PursuitObserverDelivery, state: PursuitObserverState, projection: PursuitProjection): Promise<PursuitObserverDeliveryOutcome>;
 //#endregion
 //#region src/durable/run-fork.d.ts
 /**
@@ -6105,8 +5682,6 @@ interface PursuitFork {
  * spend of every version of one lineage groups under one id.
  */
 declare const RUN_FORK_CORRELATION_KEYS: readonly ["forkParentRunId", "forkParentSettleDigest", "forkProfileDiffId", "lineageRootRunId"];
-/** The correlation key an accepted uncertain parent adds: its uncertain node ids, comma-joined. */
-declare const FORK_PARENT_UNCERTAIN_NODES_KEY = "forkParentUncertainNodes";
 //#endregion
 //#region src/durable/supervise-pursuit.d.ts
 interface SupervisePursuitOptions extends SuperviseOptions {
@@ -6228,6 +5803,13 @@ interface PursuitVersionStop {
   /** A version takes the lead when its score beats the kept version's by more than this.
    *  Default 0. */
   readonly minImprovement?: number;
+  /**
+   * Stop after this many versions in a row failed identically: each run ended `driver-failed`
+   * with the same error, or the judge could not score it. Such a failure repeats whatever the
+   * next change is (a refused workspace file, a broken credential), so neither patience nor a
+   * version cap should be what stops it. Default 3.
+   */
+  readonly identicalFailures?: number;
 }
 /** An outside judge. Runtime calls it after a version's settle record exists, never inside the
  *  version's tree, and gives it no handle into that tree. Place it where you like, such as its own
@@ -6292,6 +5874,12 @@ interface PursuitVersionChain {
   /** Why the chain stopped: the kernel's close reason (`patience`, `max-nodes`, `budget`,
    *  `deadline` or `converged`). */
   readonly reason: SearchCloseReason;
+  /** Present when the chain stopped because its last `versions` versions failed identically
+   *  (`stop.identicalFailures`); `reason` is then `converged`. */
+  readonly identicalFailures?: {
+    readonly versions: number;
+    readonly failure: string;
+  };
   /** The kept version's number: the kernel's leader when the chain closed. */
   readonly best: number;
   /** Every judged version, first first. */
@@ -6301,11 +5889,6 @@ interface PursuitVersionChain {
   /** A bounded receipt over the exact ledger bytes. */
   readonly receipt: SearchHistoryReceipt;
 }
-/** Where `'review-of-best'` mounts a review: `inputs/review/version-<n>.md`. One review lives in
- *  a profile at a time. */
-declare const REVIEW_DIR = "inputs/review/";
-/** The chain's directory beside the first version's: the ledger and its content blobs. */
-declare function pursuitVersionsLedgerPath(runDir: string): string;
 /**
  * Validate a `versions` option before any compute. The same check runs inside `supervisePursuit`;
  * a caller that records the option as data can run it at preflight.
@@ -6473,7 +6056,7 @@ interface DeclaredCheckPlacement {
 type DeclaredCheckStateCapture = (into: string) => Promise<void>;
 /** Refuse a malformed declaration before any compute. */
 declare function assertDeclaredCheck(check: DeclaredCheck, context: string): void;
-/** The canonical digest of a directory's files: the digest a record names a program by. */
+/** The canonical digest of a check program's files: the digest a record names a program by. */
 declare function checkProgramDigest(dir: string): Promise<Sha256Digest>;
 /** The digest a version judge records: the program, the sealed cases, and how they are run. */
 declare function declaredCheckDigest(check: DeclaredCheck): Sha256Digest;
@@ -7339,9 +6922,8 @@ interface TrajectoryNode {
   readonly children: ReadonlyArray<NodeId>;
   readonly label: string;
   readonly runtime: string;
-  /** Terminal status the journal recorded for this node. `'waiting'` is a wait-state node that was
-   *  armed and never woken — the journal's record of a run that died mid-wait. */
-  readonly status: 'done' | 'failed' | 'cancelled' | 'pending' | 'waiting';
+  /** Terminal status the journal recorded for this node. */
+  readonly status: 'done' | 'failed' | 'cancelled' | 'pending';
   /** This node's OWN conserved spend (from its `settled` event). */
   readonly ownSpend: Spend;
   /** This node's spend PLUS every descendant's — the rolled-up subtree cost. The cost a parent
@@ -8680,7 +8262,13 @@ declare function resolveSandboxClient(opts: ResolveSandboxClientOptions): Sandbo
  * @stable
  */
 declare function startRetainedInteractiveRun(options: StartRetainedInteractiveRunOptions): Promise<RetainedInteractiveRunHandle>;
-/** Retry one exact start after its provider response may have been lost. @stable */
+/**
+ * Retry one exact start after its provider response may have been lost.
+ *
+ * Resolves to the handle of the admitted process (resumed through the exact,
+ * idempotent start request), or `null` when the provider no longer holds the
+ * environment (not found; nothing remains to stop). @stable
+ */
 declare function recoverRetainedInteractiveRun(options: RecoverRetainedInteractiveRunOptions): Promise<RetainedInteractiveRunHandle | null>;
 /** Rebuild controls for one exact provider-owned coding-agent process. @stable */
 declare function reconnectRetainedInteractiveRun(options: ReconnectRetainedInteractiveRunOptions): Promise<RetainedInteractiveRunHandle | null>;
@@ -8829,44 +8417,6 @@ interface AcquireOptions {
  */
 declare function acquireSandbox(client: SandboxClient, options: CreateSandboxOptions, acquire?: AcquireOptions): Promise<SandboxInstance>;
 //#endregion
-//#region src/runtime/sandbox-capabilities.d.ts
-/**
- * What the loop kernel is allowed to know about a sandbox backend: a single
- * capability bit, never the backend's identity. `canFork` gates the legacy
- * checkpoint+fork fanout path; current live branching is detected on the box.
- *
- * @experimental
- */
-interface SandboxCapabilities {
-  /**
-   * True only when `client.criuStatus()` returned `{ available: true }`.
-   * Current live `branch(count)` boxes do not need this bit. When both paths
-   * are absent, a fork-enabled fanout degrades to independent fresh boxes.
-   */
-  canFork: boolean;
-}
-/**
- * Probe (and memoize per client) what the loop may rely on. A client without a
- * `criuStatus` method, or whose probe rejects, yields `canFork = false` — a
- * failed probe must never claim a capability the platform may not have. The
- * promise is cached so concurrent fanout branches share one round-trip.
- *
- * @experimental
- */
-declare function probeSandboxCapabilities(client: SandboxClient): Promise<SandboxCapabilities>;
-/**
- * Narrowed view of the optional CRIU probe. The loop-side `SandboxClient`
- * does not require `criuStatus`; this widens it optionally so the probe can be
- * read without importing sandbox-backend specifics. @experimental
- */
-interface CriuCapableClient {
-  criuStatus?: () => Promise<{
-    available: boolean;
-    criuVersion?: string;
-    reason?: string;
-  }>;
-}
-//#endregion
 //#region src/runtime/sandbox-lineage.d.ts
 /**
  * A live box plus the session that threads its iterations together. Handed back
@@ -8882,8 +8432,7 @@ interface SandboxLineageHandle {
    * Stable session id threaded through this box's `streamPrompt` calls. Minted
    * by the lineage on `start`; reused on `continue` so the server continues the
    * same conversation. A forked handle starts a fresh session on its new box —
-   * the shared context comes from the live branch or legacy checkpoint, not a
-   * shared session id.
+   * the shared context comes from the live branch, not a shared session id.
    */
   sessionId: string;
 }
@@ -8916,8 +8465,8 @@ interface SandboxLineage {
    * the parent's IMAGE and PROFILE: under a real fork `specs[i]` does NOT
    * re-select a per-branch
    * profile (the SDK forks the running box, it can't swap the image). `specs[i]`
-   * picks the per-branch profile ONLY on the degraded fresh-box path (no branch
-   * or legacy fork support).
+   * picks the per-branch profile ONLY on the degraded fresh-box path (no live
+   * branch support).
    * A heterogeneous-profile fanout therefore homogenizes to the parent's profile
    * when fork is available — pass a single shared spec for forked fanouts, or
    * use `random@k` (no fork) when branches must differ. Each child's first turn
@@ -8942,13 +8491,11 @@ interface SandboxLineage {
   teardown(): Promise<void>;
 }
 /**
- * Build a lineage bound to one client + its probed capabilities. The
- * capabilities are passed in (not re-probed) so the kernel probes once per run
- * and the lineage stays a pure function of "what this platform can do".
+ * Build a lineage bound to one client. Branching is read from each box.
  *
  * @experimental
  */
-declare function createSandboxLineage(client: SandboxClient, capabilities: SandboxCapabilities, options?: {
+declare function createSandboxLineage(client: SandboxClient, options?: {
   maxConcurrency?: number;
   streaming?: 'sse' | 'poll';
   /** Run provenance recorder forwarded to every `prepareBox` the lineage runs
@@ -8961,30 +8508,10 @@ declare function createSandboxLineage(client: SandboxClient, capabilities: Sandb
   beforeDelete?: (box: SandboxInstance) => Promise<void>;
   onAcquire?: (box: SandboxInstance, profile: AgentProfile) => void;
 }): SandboxLineage;
-/**
- * Loop-side widening of the box's optional checkpoint method. The
- * `SandboxClient`/`SandboxInstance` surface the kernel relies on does not
- * require checkpointing; this reads it optionally so the lineage can probe-gate
- * without importing sandbox-backend specifics. @experimental
- */
-interface CheckpointCapableBox {
-  checkpoint?: (options?: {
-    leaveRunning?: boolean;
-    tags?: string[];
-  }) => Promise<{
-    checkpointId: string;
-  }>;
-}
 /** Loop-side view of the current Sandbox SDK's live branch method. @experimental */
 interface BranchCapableBox {
   branch?: (count: number, options?: BranchOptions) => Promise<SandboxInstance[]>;
 }
-/** Loop-side widening of the legacy checkpoint fork method. @experimental */
-interface ForkCapableBox {
-  fork?: (checkpointId: string, options?: {
-    name?: string;
-  }) => Promise<SandboxInstance>;
-}
 /**
  * Loop-side widening of the box's optional session accessor. The real
  * `SandboxInstance` exposes `session(id).status()`; the loop reads it optionally
@@ -9771,11 +9298,9 @@ interface DriverAgentOptions {
   /** Idle time after which `observe_agent` reports a worker as stalled (a derived read; nothing is
    *  killed). Omit = the runtime default. */
   readonly stallAfterMs?: number;
-  /** Max wall-clock ms one `await_event` blocks before it returns a re-pollable `{ pending, live }`
-   *  snapshot. Every return is one driver turn, so a driver whose workers run for hours spends a
-   *  turn per interval. This driver runs in process with no transport timeout; a larger value
-   *  trades liveness reads for fewer turns. Omit = `DEFAULT_AWAIT_EVENT_TIMEOUT_MS`. */
-  readonly awaitTimeoutMs?: number;
+  /** How Runtime wakes this driver after a turn that ends with work open. Omit = the defaults in
+   *  `./wake`. */
+  readonly wake?: ManagerWakePolicy;
   /** Default continuity per worker PROFILE NAME — `'resume'` makes spawns of that name re-attach
    *  to the node's latest settled worker (see
    *  `CoordinationToolsOptions.continuityByProfile`); `spawn_worker`'s per-call `continuity`
@@ -9906,7 +9431,7 @@ interface DriverAgentOptions {
   /** 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>) => void;
+  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.
@@ -10214,7 +9739,7 @@ declare class GraphEdgeCapError extends Error {
  * 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", "driverBackend", "profileSecurity", "authorizeSpawn", "router", "driveHarness", "driverRetry", "onDriverAttempt", "workerRetry", "onWorkerRetry", "continuation", "childSettleGraceMs", "teardownConfirmMs", "retainedAtSettlement", "resolveDriveHarness", "driveHarnessMaterialization", "resolveSupervisorTools", "extraTools", "executeExtraTool", "recoverExecutor", "perWorker", "reservationPolicy", "workerSlots", "watchWorkers", "stallAfterMs", "awaitTimeoutMs", "runDir", "resume", "runContext", "steerDir", "probes", "stopRule", "onProgressStop", "maxDepth", "maxTurns", "compaction", "now", "allowedModels", "finalizer", "otel"];
+declare const GRAPH_FORWARDED_SUPERVISE_OPTIONS: readonly ["backend", "profileGuidance", "escalateQuestion", "rootHandle", "signal", "execution", "resolveDeliverable", "coordination", "peerMail", "driverBackend", "profileSecurity", "authorizeSpawn", "router", "driveHarness", "driverRetry", "onDriverAttempt", "workerRetry", "onWorkerRetry", "continuation", "childSettleGraceMs", "teardownConfirmMs", "retainedAtSettlement", "resolveDriveHarness", "driveHarnessMaterialization", "resolveSupervisorTools", "extraTools", "executeExtraTool", "recoverExecutor", "perWorker", "reservationPolicy", "workerSlots", "watchWorkers", "stallAfterMs", "wake", "runDir", "resume", "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.
@@ -10386,10 +9911,6 @@ type WorkerInteractiveAdmission = {
   readonly ref: AgentInteractiveSessionRef;
   readonly refDigest: `sha256:${string}`;
 };
-/** Return the exact credential-free admission file for one worker and phase. */
-declare function workerInteractiveAdmissionFile(eventDir: string, workerId: string, phase: WorkerInteractiveAdmission['phase']): string;
-/** Read all durable admissions for one worker, oldest phase first. */
-declare function readWorkerInteractiveAdmissions(eventDir: string, workerId: string): ReadonlyArray<WorkerInteractiveAdmission>;
 //#endregion
 //#region src/runtime/supervise/interactive-worker.d.ts
 /** Environment fields supplied to every interactive worker after Runtime adds the exact profile. */
@@ -10601,17 +10122,6 @@ interface ProvisionedSupervisor {
  */
 declare function provisionSupervisor(request: ProvisionSupervisorRequest): Promise<ProvisionedSupervisor>;
 //#endregion
-//#region src/runtime/supervise/run-context-sql.d.ts
-interface SqlRunContext {
-  readonly journal: SpawnJournal;
-  readonly blobs: ResultBlobStore;
-  readonly executors: ExecutorRegistry;
-  /** Always `true` — a SQL context is durable by construction, so runs resume-first. */
-  readonly resume: true;
-}
-/** Build a durable run context over one SQL statement seam. Tables are created on first use. */
-declare function createSqlRunContext(db: SqlStatements): SqlRunContext;
-//#endregion
 //#region src/runtime/supervise/scope.d.ts
 /** Construction args for `createScope`. The supervisor threads the shared pool, journal,
  *  blob store, and executor registry through; `depth`/`maxDepth` pair the runtime
@@ -10629,11 +10139,6 @@ 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). */
@@ -10706,11 +10211,6 @@ interface ScopeArgs {
     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>;
     /** Keyed assignments from the prior journal — what a keyed re-spawn resolves against. */
     readonly keys: ReadonlyMap<string, ResumedKeyState<unknown>>;
     /** Prior committed spend summed off the journal (settled child work + metered inference). */
@@ -10973,10 +10473,6 @@ interface AttachWorkerOptions {
   readonly providers: WorkerInteractiveProviderSource;
   readonly signal?: AbortSignal;
 }
-/** Directory containing exact per-worker interactive binding records. @stable */
-declare function workerInteractiveBindingsDir(eventDir: string): string;
-/** Exact durable binding file for one worker id. @stable */
-declare function workerInteractiveBindingFile(eventDir: string, workerId: string): string;
 /** Read and validate one exact durable worker binding. @stable */
 declare function readWorkerInteractiveBinding(eventDir: string, workerId: string): WorkerInteractiveBinding | undefined;
 /**
@@ -11042,17 +10538,7 @@ interface WorktreeFanoutOptions extends PatchDeliverableOptions {
  */
 declare function worktreeFanout<Task>(options: WorktreeFanoutOptions): CombinatorShape<Task, WorktreePatchArtifact>;
 //#endregion
-//#region src/runtime/supervise-surface.d.ts
-/** What a surface worker settles with — the surface verdict the driver + deliverable read. `resolved` is
- *  the surface check's pass/fail (settled ⟺ resolved); `score` is the partial-credit fraction; `failing`
- *  carries the tests this worker left red (so the analyst can target them). */
-interface SurfaceWorkerOut {
-  readonly resolved: boolean;
-  readonly score: number;
-  readonly shots: number;
-  readonly summary: string;
-  readonly failing?: readonly string[];
-}
+//#region src/runtime/supervise-analysts.d.ts
 /**
  * Adapt an `agent-eval` `AnalystRegistry` into the lens shape `supervise({ analysts })` takes.
  *
@@ -11102,52 +10588,6 @@ interface AnalystAuthoring {
  *  the driver the still-FAILING tests (not just a score), so the next spawn targets the persistently-hard
  *  cases. Swap `analysts` to change what the driver improves from — that's the one knob. */
 declare function failuresAnalyst(): AnalystRegistry$1;
-/** How a worker runs the surface task (its router substrate + per-attempt bounds). */
-interface SurfaceWorkerConfig {
-  readonly routerBaseUrl: string;
-  readonly routerKey: string;
-  /** Exact worker behavior, tools, and model. */
-  readonly profile: AgentProfile;
-  readonly analystProfile?: AgentProfile;
-  readonly innerTurns?: number;
-  /** Refine-shot budget for ONE worker attempt (max steered shots). Default 1. */
-  readonly budget?: number;
-}
-interface SuperviseSurfaceOptions {
-  /** The graded surface workers solve (open/tools/call/score/close). */
-  readonly surface: AgenticSurface;
-  /** Where/how each worker runs the surface task. */
-  readonly worker: SurfaceWorkerConfig;
-  /** The conserved compute pool for the whole supervised run. Default: sized off the worker's inner-loop
-   *  bounds for a handful of worker spawns — raise it to let the driver try more. */
-  readonly budget?: Budget;
-  /** The driver brain's Router endpoint/auth. Model and behavior remain owned by `profile`. */
-  readonly router?: RouterTransportConfig;
-  /** The self-improvement lens fed to the driver on each settled worker. Default `failuresAnalyst()`
-   *  (target the still-failing tests). Pass a custom registry to change it, or `null` to turn the
-   *  within-run self-improvement OFF (the driver sees raw settled outputs). */
-  readonly analysts?: AnalystRegistry$1 | null;
-  /** The strategy each worker runs over the surface. Default `refine` (iterate-with-feedback). */
-  readonly strategy?: Strategy;
-  /** Max workers working at once; later spawns queue. Default 1 (serial — required when workers share
-   *  a persistent artifact, so they continue each other instead of racing the file). */
-  readonly workerSlots?: number;
-}
-/** The deployable outcome of a supervised surface run. */
-interface SuperviseSurfaceResult {
-  readonly resolved: boolean;
-  readonly score: number;
-  readonly usd: number;
-  readonly tokensIn: number;
-  readonly tokensOut: number;
-  readonly ms: number;
-  /** Total conserved-pool iterations = the driver + worker LLM rounds the run actually spent. */
-  readonly completions: number;
-}
-/** Drive a team of agents (spawned + steered by `profile`) to solve a graded `AgenticSurface` task, and
- *  report the deployable outcome + the full conserved spend. This is `supervise()` configured for surfaces
- *  — there is no other entrypoint to learn. */
-declare function superviseSurface(profile: SupervisorProfile, task: AgenticTask, opts: SuperviseSurfaceOptions): Promise<SuperviseSurfaceResult>;
 //#endregion
 //#region src/runtime/surface-diff.d.ts
 /** Outcome of reading one surface back at settle. `missing: true` means the path no longer exists
@@ -11284,5 +10724,5 @@ interface VerifierEnvironmentOptions {
 /** Any checkable task as an `Environment`, no tool surface required: the artifact is the worker's answer and the domain is one deployable `check` over it. */
 declare function createVerifierEnvironment(opts: VerifierEnvironmentOptions): Environment;
 //#endregion
-export { WorkspaceRun as $, SandboxEvidenceReceipt as $a, withWorkerSpawnRetry as $c, ContinuationInstruction as $d, createMcpServer as $f, AgentProfileMaterializationAxis as $h, registryScopeAnalyst as $i, FinalizeContext as $l, DeliverableSpec as $m, RepairStop as $n, TrajectoryReport as $o, DelegateCodeConfig as $p, SandboxLineageHandle as $r, SettledPursuitVersion as $s, defaultEdgeTraversalCap as $t, CompletionAnalyst as $u, worktreeFanout as A, adaptiveRefine as Aa, ObserverRecord as Ac, AnytimeTaskCurve as Ad, SuperviseProfileEntry as Af, BackendCallPolicy as Ah, equalKOnCost as Ai, supervisorAgent as Al, DelegationTraceCaps as Am, unsafeInProcessRunner as An, EqualKOnCostOptions as Ao, DetachedSessionRefParts as Ap, authorStrategy as Ar, LeaderboardSpec as As, WorktreeCliExecutorOptions as At, readRunCancellation as Au, VERIFY_TAIL_CHARS as B, LoopOptionsForDispatch as Ba, SuperviseRegistry as Bc, ANALYST_DEFINITION_BOUNDS as Bd, questionEscalationTargets as Bf, InMemorySpawnJournal as Bh, fanout as Bi, StopRule as Bl, FileDelegationStore as Bm, ProfileRichness as Bn, Panel as Bo, runDetachedTurn as Bp, materializeLocalMcp as Br, readDeclaredCheck as Bs, workerInteractiveAdmissionFile as Bt, supervisorWorkersDir as Bu, SurfaceWorkerConfig as C, Strategy as Ca, PursuitProjection as Cc, AuditIntentInput as Cd, QuestionRecord as Cf, ConversationTurn as Ch, assertModelAllowed as Ci, SupervisorNodeContext as Cl, ResearchOutputShape as Cm, delegate as Cn, AssertTraceDerivedFindings as Co, settleDetachedCoderTurn as Cp, TournamentCell as Cr, LeaderboardBenchTask as Cs, ProvisionSupervisorConnection as Ct, WorkerSteerRequest as Cu, superviseSurface as D, StrategyResult as Da, projectPursuit as Dc, defaultAuditorInstruction as Dd, SpawnPreflightContext as Df, HaltSignal as Dh, PrivateCasOffloadReport as Di, SupervisorToolInvocationContext as Dl, CappedDelegationTrace as Dm, CodeModeOptions as Dn, CorpusRecord as Do, SiblingSandboxExecutorOptions as Dp, AuthorStrategyOptions as Dr, LeaderboardRunContext as Ds, provisionSupervisor as Dt, legacySupervisorRunDir as Du, failuresAnalyst as E, StrategyMessage as Ea, PursuitStatus as Ec, auditIntent as Ed, SpawnPreflight as Ef, HaltReason as Eh, PrivateCasDurableStore as Ei, SupervisorToolDescriptor as El, delegationProfiles as Em, finalizeBestDelivered as En, CorpusFilter as Eo, FleetWorkspaceExecutorOptions as Ep, strategyTournament as Er, LeaderboardIterationInfo as Es, SupervisorCleanupReceipt as Et, cancelWorker as Eu, readWorkerInteractiveBinding as F, runAgentic as Fa, AuthorizedSpawn as Fc, renderAnytimeTable as Fd, canonicalFindingEvent as Ff, SqlSpawnJournal as Fh, definePersona as Fi, ProgressSample as Fl, composeLoopTraceEmitters as Fm, ChatWorkerSeamOptions as Fn, FanoutWinnerSelector as Fo, RunDetachedTurnOptions as Fp, McpSpawnFault as Fr, assertDeclaredCheck as Fs, InteractiveWorkerOptions as Ft, runCancelRequestFile as Fu, CopyOptions as G, superviseDispatch as Ga, workerFromBackend as Gc, AnalystLensOutput as Gd, SpawnResourceRead as Gf, SpawnForestNode as Gh, selectValidWinner as Gi, noProgressFor as Gl, BusRecord as Gm, profileRichnessFinding as Gn, PipelineStage as Go, DelegationResumeTick as Gp, SandboxRun as Gr, runIsolatedCheck as Gs, EdgeTraversal as Gt, workerInboxFile as Gu, closingWorkerNote as H, SuperviseOptionsForDispatch as Ha, SuperviseTestOptions as Hc, AnalystDefinitionIssue as Hd, ResolvedSpawnResourcePath as Hf, SpawnForestEvent as Hh, loopUntil as Hi, allWorkersStalled as Hl, InMemoryDelegationStore as Hm, asAuthoredProfile as Hn, PanelSpec as Ho, DelegationRecord as Hp, OpenSandboxRunBeforeStartContext as Hr, IsolatedCheckBoxEvidence as Hs, createInPlaceCliExecutor as Ht, workerCancellationFile as Hu, workerInteractiveBindingFile as I, sample as Ia, AuthorizedSpawnContext as Ic, WaterfallCollector as Id, createCoordinationTools as If, SqlStatements as Ih, runPersonified as Ii, ProgressTracker as Il, createDelegationTraceCollector as Im, chatTransportExecutor as In, FlatWidenGate as Io, createDetachedTurnResumeDriver as Ip, McpToolDescriptor as Ir, checkProgramDigest as Is, InteractiveWorkerResult as It, runCancellationFile as Iu, withUntrackedArtifacts as J, TerminalDecision as Ja, WorkerSpawnRetryHooks as Jc, AnalyzeOnSettleRoute as Jd, hostDirectoryReader as Jf, materializeTreeView as Jh, CreateScopeAnalystOptions as Ji, ReentryContinuity as Jl, PublishOptions as Jm, CheckOutcome as Jn, ScopeAnalyst as Jo, DelegationTaskQueueOptions as Jp, openSandboxRun as Jr, NextPursuitVersionInput as Js, GraphNode as Jt, workerSteerAcknowledgementsDir as Ju, UntrackedCopyStats as K, RunAgentRoundsOptions as Ka, ResolvedWorkerSpawnRetry as Kc, AnalystRegistry$1 as Kd, SpawnResourceReader as Kf, SpawnForestTree as Kh, verify as Ki, plateau as Kl, BusStats as Km, supervisorInstructions as Kn, RenderCorpusToInstructions as Ko, DelegationRunContext as Kp, SandboxRunAbortError as Kr, JudgedPursuitVersion as Ks, GraphEdge as Kt, workerInboxFileFromEventDir as Ku, workerInteractiveBindingsDir as L, sampleThenRefine as La, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as Lc, WaterfallReport as Ld, downMessageRefusalReasons as Lf, FileResultBlobStore as Lh, FileCorpus as Li, ProgressTrackerOptions as Ll, DelegationPersistenceError as Lm, chatWorkerSeam as Ln, LoopUntil as Lo, detachedTurnEvents as Lp, StdioMcpConnection as Lr, declaredCheckDeliverable as Ls, workerFromInteractiveProvider as Lt, safeWorkerFile as Lu, WorkerInteractiveBinding as M, defineStrategy as Ma, createFileObserverHooks as Mc, areaUnderCurve as Md, WorkerSpawnContext as Mf, RetryBackoff as Mh, builtinShapes as Mi, AllWorkersStalledOptions as Ml, DelegationTraceSpan as Mm, ChatSessionStore as Mn, Fanout as Mo, DetachedTurnResumeDriverOptions as Mp, strategyAuthorSystemPrompt as Mr, DeclaredCheck as Ms, createWorktreeCliExecutor as Mt, readWorkerCancellation as Mu, WorkerInteractiveProviderSource as N, depthStrategy as Na, observerRecordDigest as Nc, bestSoFar as Nd, WorkerWatchOptions as Nf, RetryableErrorPredicate as Nh, createShapeRegistry as Ni, NoProgressForOptions as Nl, buildDelegationTraceSpans as Nm, ChatTransportExecutorOptions as Nn, FanoutOptions as No, DriveTurnCapableBox as Np, LocalMcpMaterialization as Nr, DeclaredCheckPlacement as Ns, InteractiveWorkerEnvironment as Nt, readWorkerSteerAcknowledgement as Nu, AuthoredHarness as O, StrategyShotResult as Oa, FileObserverJournal as Oc, AnytimeReport as Od, SpawnRefusal as Of, RunConversationOptions as Oh, PrivateCasOptions as Oi, assertCoordinationBinding as Ol, DELEGATION_TRACE_MAX_BYTES as Om, CodeModeRunner as On, EqualKArm as Oo, createFleetWorkspaceExecutor as Op, AuthoredStrategy as Or, LeaderboardScenario as Os, PatchDeliverableOptions as Ot, legacySupervisorRunsRoot as Ou, attachWorker as P, refine as Pa, verifyObserverRecords as Pc, plateauLength as Pd, analystToolGroupNames as Pf, SqlResultBlobStore as Ph, registerShape as Pi, PlateauOptions as Pl, capDelegationTrace as Pm, ChatTransportTool as Pn, FanoutSynthesis as Po, DriveTurnTick as Pp, MaterializeLocalMcpOptions as Pr, DeclaredCheckStateCapture as Ps, InteractiveWorkerKeyInput as Pt, readWorkerSteerRequests as Pu, WorkspaceCommit as Q, SandboxEvidenceContext as Qa, retryPreSpawnRefusals as Qc, AuthorizedDownMessage as Qd, createInProcessTransport as Qf, AGENT_PROFILE_MATERIALIZATION_AXES as Qh, createScopeAnalyst as Qi, DeliveredOutput as Ql, watchTrace as Qm, CheckSourceCtx as Qn, TrajectoryNode as Qo, DelegateCodeArgs as Qp, SandboxLineage as Qr, REVIEW_DIR as Qs, TraversalContinuity as Qt, writeWorkerSteer as Qu, EVIDENCE_MAX_CHARS as R, LoopCampaignDispatchOptions as Ra, DeliverableResolutionInput as Rc, WaterfallSpan as Rd, normalizeAnalyzeOnSettle as Rf, FileSpawnJournal as Rh, InMemoryCorpus as Ri, ProgressView as Rl, DelegationStateCorruptError as Rm, createChatSessionStore as Rn, LoopUntilSpec as Ro, formatDetachedSessionRef as Rp, StdioMcpServerSpec as Rr, declaredCheckDigest as Rs, WorkerInteractiveAdmission as Rt, supervisorRunDir as Ru, SuperviseSurfaceResult as S, ShotSpec as Sa, PursuitNodeUsage as Sc, renderPairwiseMarkdown as Sd, QuestionPolicy as Sf, ConversationStreamEvent as Sh, profileOptimizerModelCall as Si, SupervisorAgentTestDeps as Sl, FeedbackRefersTo as Sm, defaultDelegateBudget as Sn, renderReport as So, detachedSessionDelegate as Sp, StrategyTournament as Sr, LeaderboardBenchScore as Ss, createSqlRunContext as St, WorkerSteerAcknowledgement as Su, analystsFromRegistry as T, StrategyCtx as Ta, PursuitRunTotals as Tc, IntentAudit as Td, SettledWorker as Tf, HaltPredicate as Th, PrivateCasArtifactPort as Ti, SupervisorProfile as Tl, UiAuditorDelegationOutput as Tm, driverAgent as Tn, Corpus as To, FleetHandle as Tp, runStrategyEvolution as Tr, LeaderboardFlagSpec as Ts, ProvisionedSupervisor as Tt, cancelRun as Tu, composeWorkerEvidence as U, loopCampaignDispatch as Ua, supervise as Uc, AnalystFindingEvent as Ud, SPAWN_RESOURCE_PATH_MAX_BYTES as Uf, SpawnForestInDoubtNode as Uh, panel as Ui, anyOf as Ul, CoderOutput as Um, assessAuthoredProfile as Un, PanelVerdict as Uo, DelegationResumeContext as Up, OpenSandboxRunOptions as Ur, IsolatedCheckOptions as Us, AgentGraph as Ut, workerCancellationsDir as Uu, WorkerEvidenceInput as V, SuperviseDispatchOptions as Va, SuperviseRegistryTable as Vc, AnalystAssignmentRecord as Vd, ResolveSpawnResourcePathsResult as Vf, SpawnForest as Vh, flatWidenGate as Vi, allOf as Vl, FileDelegationStoreOptions as Vm, ProfileRichnessThresholds as Vn, PanelJudge as Vo, DelegationArgs as Vp, Deliverable as Vr, IsolatedCheckBox as Vs, InPlaceCliExecutorOptions as Vt, workerCancelRequestsFile as Vu, settledWorkerOut as W, loopDispatch as Wa, superviseWithTestBrain as Wc, AnalystKind as Wd, SpawnResourceBytes as Wf, SpawnForestMissingTree as Wh, pipeline as Wi, createProgressTracker as Wl, BusEvent as Wm, defaultProfileRichnessThresholds as Wn, Pipeline as Wo, DelegationResumeDriver as Wp, OpenSandboxRunPromptOptions as Wr, IsolatedCheckResult as Ws, EdgeDeliveryOutcome as Wt, workerControlLogFile as Wu, Shell as X, isTerminalDecision as Xa, isPreSpawnExecutorFailure as Xc, AuthoredAnalystLimits as Xd, McpServer as Xf, replaySpawnTree as Xh, assertTraceDerivedFindings as Xi, UNPROVEN_CONTINUITY as Xl, WatchTraceOptions as Xm, CheckRunner as Xn, ScopeWidenGate as Xo, SubmitOutput as Xp, CheckpointCapableBox as Xr, PursuitVersionStop as Xs, RunGraphOptions as Xt, workerSteerRequestsDir as Xu, GitWorkspaceOptions as Y, defaultSelectWinner as Ya, WorkerSpawnRetryPolicy as Yc, AuthoredAnalystDefinition as Yd, resolveSpawnResourcePaths as Yf, pendingWaits as Yh, RegistryAnalyzeProjection as Yi, ReentryTaskInput as Yl, createEventBus as Ym, CheckRunContext as Yn, ScopeAnalyzeInput as Yo, SubmitInput as Yp, BranchCapableBox as Yr, PursuitVersionChain as Ys, GraphResult as Yt, workerSteerRequestFile as Yu, Workspace as Z, runAgentRounds as Za, resolveWorkerSpawnRetry as Zc, AuthorizeDownMessage as Zd, McpServerOptions as Zf, contentAddress as Zh, buildSteerContext as Zi, composeReentryTask as Zl, defaultToolDetectors as Zm, CheckSource as Zn, SteerContext as Zo, hashIdempotencyInput as Zp, ForkCapableBox as Zr, PursuitVersions as Zs, RunGraphTestOptions as Zt, workerSteersDir as Zu, boxSurfaceReader as _, AgenticTask as _a, PursuitNodeCost as _c, leaderboard as _d, QuestionEscalationOutcome as _f, sandboxActProfileMaterialization as _g, Conversation as _h, recoverRetainedInteractiveRun as _i, ObserveSupervisorNodeEvent as _l, DelegationResultPayload as _m, RollingDispatchOptions as _n, ObservationError as _o, DetachedSessionDelegateOptions as _p, visibleCheckScore as _r, RunPersonifiedOptions as _s, SUBTREE_RESULT_LIMIT as _t, PriorCoordination as _u, SandboxInstance$1 as a, BenchmarkCell as aa, SupervisePursuitOptions as ac, sentinelCompletion as ad, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as af, ProfileMaterializationIssue as ag, SqlRunStoreOptions as ah, AcquireOptions as ai, createInMemoryRunContext as al, DelegateResearchResult as am, analyzesFindingsReportPrompt as an, inlineSandboxClient as ao, DelegateHandlerOptions as ap, canDisplace as ar, WidenDecision as as, analyzeTrace as at, runFinalizer as au, AnalystAuthoring as b, CorpusReadbackOptions as ba, PursuitNodeProjection as bc, renderLeaderboardMarkdown as bd, QuestionLevel as bf, ConversationPolicy as bh, resolveSandboxClient as bi, ResolvedSupervisorProfile as bl, DelegationStatusResult as bm, rollingDispatch as bn, defaultAnalystInstruction as bo, UiAuditorDelegate as bp, EvolutionStrategy as br, ShapeRegistry as bs, settledToIteration as bt, WorkerCancelRequest as bu, VerifierEnvironmentOptions as c, BenchmarkReport as ca, FORK_PARENT_UNCERTAIN_NODES_KEY as cc, GroupOf as cd, DownMessageDeliveryAttempt as cf, controlProfileMaterialization as cg, D1StmtLike as ch, S3PrivateCasStoreOptions as ci, SupervisorSpanOptions as cl, DelegateUiAuditResult as cm, dumbContinuationFailPrompt as cn, InProcessSandboxClientOptions as co, validateDelegateArgs as cp, defaultExtractCandidate as cr, WinnerStrategy as cs, captureWorkerTraceEvidence as ct, CoordinationPublicAddress as cu, HarvestSurfaceDiffsOptions as d, Environment as da, PURSUIT_OBSERVER_DELIVERY_PATH as dc, LeaderboardOptions as dd, EscalateQuestion as df, profileMaterializationAxes$1 as dg, d1ToSqlAdapter as dh, recoverRetainedRun as di, createSupervisorSpanRecorder as dl, DelegationFeedbackSnapshot as dm, kernelPromptRegistry as dn, HarvestError as do, InMemoryFeedbackStore as dp, modelAuthoredChecks as dr, LoopShape as ds, DEFAULT_MAX_DEPTH as dt, CoordinationHttpAudit as du, observationFromRegistry as ea, VersionJudge as ec, CompletionEvidence as ed, ContinuityMode as ef, AssertProfileMaterializationOptions as eg, ExecutorResultMapping as eh, SessionCapableBox as ei, InMemoryRunContext as el, DelegateCodeResult as em, runGraph as en, SandboxEvidenceRetentionError as eo, DELEGATE_DESCRIPTION as ep, StructuralRolloutConfig as er, TrajectoryReportFn as es, gitWorkspace as et, FinalizerSettled as eu, SurfaceDiff as f, printBenchmarkReport as fa, PursuitObserverDelivery as fc, LeaderboardRow as fd, EventAcknowledgement as ff, promptControlProfileMaterialization as fg, ConversationJournal as fh, startRetainedRun as fi, CoordinationBinding as fl, DelegationHistoryArgs as fm, naiveContinuationPrompt as fn, HarvestFailure as fo, eventToSnapshot as fp, officialChecksFromMeta as fr, Outcome as fs, createRootHandle as ft, CoordinationHttpOptions as fu, WatchedSurface as g, AgenticSurface as ga, PursuitCostProvenance as gc, ScoreOf as gd, QuestionDecision as gf, renderProfileMaterializationIssues as gg, AuthSource as gh, reconnectRetainedInteractiveRun as gi, DriveHarnessOwnerContext as gl, DelegationProgress as gm, DispatchUnit as gn, ObservationAnalysis as go, DelegateRunCtx as gp, structuralRollout as gr, RunPersonified as gs, createFencedSqlRunContext as gt, FileCoordinationLog as gu, SurfaceReader as h, AgenticRunResult as ha, deliverPursuitObserver as hc, ProfileKeyOf as hd, Question as hf, promptResourceProfileMaterialization as hg, InMemoryConversationJournal as hh, claimRetainedInteractiveControl as hi, DriveHarness as hl, DelegationProfile as hm, DispatchStopReason as hn, Observation as ho, CoderReviewer as hp, selectBestIndex as hr, PersonaExecutors as hs, SqlRunContextOptions as ht, CoordinationOwnerId as hu, SandboxEvent$1 as i, sanitizeMcpToolSchema as ia, SupervisePursuitError as ic, deterministicCompletion as id, CoordinationToolsOptions as if, ProfileMaterializationContract as ig, SqlRunOwnershipError as ih, probeSandboxCapabilities as ii, createFileRunContext as il, DelegateResearchConfig as im, RegisteredPrompt as in, localSandboxClient as io, DelegateError as ip, VisibleCheck as ir, Widen as is, TrajectoryAnalysis as it, pickBestDelivered as iu, AttachWorkerOptions as j, breadthStrategy as ja, ObserverRecordKind as jc, anytimeReport as jd, WorkerResumeContext as jf, CircuitBreakerConfig as jh, trajectoryReport as ji, supervisorAgentWithTestBrain as jl, DelegationTraceCollector as jm, ChatCompletionsTransport as jn, EqualKVerdict as jo, DetachedTurn as jp, strategyAuthorContract as jr, defineLeaderboard as js, WorktreePatchArtifact as jt, readWorkerCancelRequests as ju, WorktreeFanoutOptions as k, SurfaceScore as ka, ObserverJournal as kc, AnytimeStrategySummary as kd, SpawnRefusalCause as kf, TurnOrder as kh, createPrivateCasArtifactPort as ki, resolveSupervisorProfile as kl, DELEGATION_TRACE_MAX_SPANS as km, codeModeSupervisorTools as kn, EqualKOnCost as ko, createSiblingSandboxExecutor as kp, assertStrategyContract as kr, LeaderboardScore as ks, patchDelivered as kt, readRunCancelRequest as ku, createVerifierEnvironment as l, BenchmarkStrategySummary as la, PursuitFork as lc, Interval as ld, DownMessageDeliveryOutcome as lf, defineProfileMaterializationContract as lg, SqlAdapter as lh, createS3PrivateCasStore as li, SupervisorSpanOutcome as ll, DelegateUiAuditRoute as lm, dumbContinuationPassPrompt as ln, inProcessSandboxClient as lo, FeedbackEvent as lp, defaultStructuralRolloutPolicy as lr, DefinePersona as ls, parseWorkerToolTraceArtifact as lt, CoordinationTransportOptions as lu, SurfaceReadOutcome as m, AgenticOptions as ma, PursuitObserverState as mc, PairwiseVerdict as md, ManagerReentryState as mf, promptOnlyProfileMaterialization as mg, FileConversationJournal as mh, ClaimRetainedInteractiveControlOptions as mi, CoordinationVerbs as ml, DelegationHistoryResult as mm, DispatchReport as mn, harvestCorpus as mo, CoderReview as mp, sandboxCheckRunner as mr, PersonaContext as ms, FencedSqlRunContext as mt, CoordinationLog as mu, AnalystFinding$1 as n, McpEnvironmentOptions as na, assertPursuitVersions as nc, CompletionVerdict as nd, CoordinationStats as nf, DefineProfileMaterializationContractOptions as ng, mapExecutorResult as nh, CriuCapableClient as ni, RunContext as nl, DelegateFeedbackResult as nm, PromptHandle as nn, captureBeforeDestroy as no, DELEGATE_TOOL_NAME as np, StructuralRolloutPolicy as nr, Verify as ns, localShell as nt, bestDelivered as nu, computeFindingId$1 as o, BenchmarkConfig as oa, SupervisedPursuitResult as oc, stopSentinel as od, DefinedAnalystRecord as of, ValidateProfileMaterializationOptions as og, openSqlRunStore as oh, acquireSandbox as oi, withRunContext as ol, DelegateUiAuditArgs as om, createPromptRegistry as on, InProcessOnPrompt as oo, DelegateResult as op, compareCheckOutcomes as or, WidenLineage as os, WORKER_TOOL_TRACE_SCHEMA_VERSION as ot, CoordinationAuthentication as ou, SurfaceReadBox as p, runBenchmark as pa, PursuitObserverDeliveryOutcome as pc, PairwiseOptions as pd, MakeWorkerAgent as pf, promptModelProfileMaterialization as pg, ConversationJournalEntry as ph, startRetainedRunInEnvironment as pi, CoordinationToolFace as pl, DelegationHistoryEntry as pm, promptHandle as pn, HarvestReport as po, CoderDelegate as pp, resolveEntrySymbol as pr, Persona as ps, createSupervisor as pt, CoordinationDeliveryEvidence as pu, copyUntrackedIntoClone as q, TERMINAL_DECISIONS as qa, WorkerSpawnRetryAttempt as qc, AnalystToolGroupName as qd, environmentReader as qf, loadSpawnForest as qh, widen as qi, sampleFromSettled as ql, EventBus as qm, CheckExecChannel as qn, RenderCorpusToInstructionsOptions as qo, DelegationTaskQueue as qp, TurnResult as qr, NextPursuitVersion as qs, GraphEdgeCapError as qt, workerSteerAcknowledgementFile as qu, CreateSandboxOptions$1 as r, createMcpEnvironment as ra, pursuitVersionsLedgerPath as rc, completionAuthorizes as rd, CoordinationTools as rf, KnownAgentProfileMaterializationAxis as rg, SqlRunLease as rh, SandboxCapabilities as ri, RunContextLease as rl, DelegateResearchArgs as rm, PromptRegistry as rn, LocalSandboxClientOptions as ro, DelegateArgs as rp, StructuralRolloutResult as rr, VerifySpec as rs, runInWorkspace as rt, collectDelivered as ru, makeFinding$1 as s, BenchmarkLift as sa, supervisePursuit as sc, AxisScoresOf as sd, DownMessageAuthorizationInput as sf, assertProfileMaterialization as sg, D1DatabaseLike as sh, S3PrivateCasStore as si, SupervisorSpanAttributes as sl, DelegateUiAuditConfig as sm, delegatesWorkerBriefPrompt as sn, InProcessPromptCtx as so, createDelegateHandler as sp, composeCheckSources as sr, WidenSpec as ss, WorkerToolTraceArtifact as st, CoordinationMcpHandle as su, AgentProfile$2 as t, McpEndpoint as ta, VersionVerdict as tc, CompletionPolicy as td, CoordinationEvent as tf, CanonicalAgentProfileMaterializationAxis as tg, gateOnDeliverable as th, createSandboxLineage as ti, InMemoryRunContextOptions as tl, DelegateFeedbackArgs as tm, runGraphWithTestBrain as tn, SandboxEvidenceRetentionPort as to, DELEGATE_INPUT_SCHEMA as tp, StructuralRolloutMessage as tr, TrajectoryReportOptions as ts, jjWorkspace as tt, SupervisorFinalizer as tu, BoxSurfaceReaderOptions as u, BenchmarkTaskRow as ua, RUN_FORK_CORRELATION_KEYS as uc, Leaderboard as ud, DownMessageEvent as uf, fullProfileMaterialization as ug, SqlConversationJournal as uh, reconnectRetainedRun as ui, SupervisorSpanRecorder as ul, DelegationError as um, formatPromptHandle as un, HarvestCorpusOptions as uo, FeedbackStore as up, filterAuthoredAsserts as ur, DefinePersonaInput as us, workerTraceAnalysisStore as ut, serveCoordinationMcp as uu, fsSurfaceReader as v, AgenticTool as va, PursuitNodePlacement as vc, pairwiseSignificance as vd, QuestionEscalationRecord as vf, validateProfileMaterialization as vg, ConversationDriveState as vh, startRetainedInteractiveRun as vi, ResolveDriveHarness as vl, DelegationStatus as vm, freeSlots as vn, ObserveInput as vo, DetachedWinnerSelection as vp, EvolutionAuthor as vr, ShapeBudget as vs, ScopeArgs as vt, RunCancelRequest as vu, SurfaceWorkerOut as w, StrategyArtifacts as wa, PursuitRunProjection as wc, AuditIntentOptions as wd, QuestionUrgency as wf, HaltContext as wh, assertProfileModelsAllowed as wi, SupervisorNodeContextSeed as wl, UiAuditLensFilter as wm, DriverAgentOptions as wn, CombinatorShape as wo, DelegationExecutor as wp, TournamentRow as wr, LeaderboardBenchmarkAdapter as ws, ProvisionSupervisorRequest as wt, WriteWorkerSteerOptions as wu, SuperviseSurfaceOptions as x, RunAgenticOptions as xa, PursuitNodeTiming as xc, renderLeaderboardSvg as xd, QuestionOption as xf, ConversationResult as xh, profileChatClient as xi, SupervisorAgentDeps as xl, FeedbackRating as xm, DelegateOptions as xn, observe as xo, coderTaskFromArgs as xp, StrategyEvolutionConfig as xr, DefinedLeaderboard as xs, SqlRunContext as xt, WorkerCancellation as xu, harvestSurfaceDiffs as y, ArtifactHandle as ya, PursuitNodePlatform as yc, renderLeaderboardHtml as yd, QuestionEscalationTarget as yf, worktreeCliProfileMaterialization as yg, ConversationParticipant as yh, ResolveSandboxClientOptions as yi, ResolveSupervisorTools as yl, DelegationStatusArgs as ym, queueOf as yn, ObserveOptions as yo, SettleDetachedCoderTurnOptions as yp, EvolutionReport as yr, ShapeContext as ys, createScope as yt, RunCancellation as yu, NOTE_MAX_CHARS as z, LoopDispatchOptions as za, SuperviseOptions as zc, createWaterfallCollector as zd, parseAuthoredAnalystDefinition as zf, InMemoryResultBlobStore as zh, renderCorpusToInstructions as zi, StopDecision as zl, DelegationStore as zm, AuthoredProfile as zn, LoopUntilState as zo, parseDetachedSessionRef as zp, connectStdioMcp as zr, declaredCheckJudge as zs, readWorkerInteractiveAdmissions as zt, supervisorRunsRoot as zu };
-//# sourceMappingURL=index-sC6sl88d.d.ts.map
+export { WORKER_TOOL_TRACE_SCHEMA_VERSION as $, Observation as $a, SupervisorNodeContext as $c, QuestionUrgency as $d, settleDetachedCoderTurn as $f, AgenticRunResult as $i, WorkerCancellation as $l, replaySpawnTree as $m, filterAuthoredAsserts as $n, PersonaExecutors as $o, ResearchOutputShape as $p, claimRetainedInteractiveControl as $r, PursuitNodeUsage as $s, formatPromptHandle as $t, renderLeaderboardSvg as $u, readWorkerInteractiveBinding as A, RunAgentRoundsOptions as Aa, InMemoryRunContext as Ac, CoordinationStats as Ad, DELEGATE_DESCRIPTION as Af, verify as Ai, DeliveredOutput as Al, ExecutorResultMapping as Am, ProfileRichnessThresholds as An, RenderCorpusToInstructions as Ao, DelegateCodeResult as Ap, Deliverable as Ar, JudgedPursuitVersion as As, InPlaceCliExecutorOptions as At, writeWorkerSteer as Au, copyUntrackedIntoClone as B, captureBeforeDestroy as Ba, SupervisorSpanRecorder as Bc, LeadMessage as Bd, FeedbackStore as Bf, McpEnvironmentOptions as Bi, CoordinationPublicAddress as Bl, d1ToSqlAdapter as Bm, CheckSource as Bn, Verify as Bo, DelegationError as Bp, SandboxLineageHandle as Br, SupervisePursuitError as Bs, RunGraphTestOptions as Bt, GroupOf as Bu, AuthoredHarness as C, LoopDispatchOptions as Ca, WorkerSpawnRetryAttempt as Cc, AuthoredAnalystLimits as Cd, environmentReader as Cf, renderCorpusToInstructions as Ci, noProgressFor as Cl, EventBus as Cm, ChatTransportTool as Cn, LoopUntilState as Co, DelegationTaskQueue as Cp, MaterializeLocalMcpOptions as Cr, declaredCheckJudge as Cs, createWorktreeCliExecutor as Ct, workerInboxFile as Cu, WorkerInteractiveBinding as D, loopCampaignDispatch as Da, resolveWorkerSpawnRetry as Dc, ContinuationInstruction as Dd, McpServerOptions as Df, panel as Di, ReentryTaskInput as Dl, defaultToolDetectors as Dm, createChatSessionStore as Dn, PanelVerdict as Do, hashIdempotencyInput as Dp, StdioMcpServerSpec as Dr, IsolatedCheckOptions as Ds, InteractiveWorkerResult as Dt, workerSteerRequestFile as Du, AttachWorkerOptions as E, SuperviseOptionsForDispatch as Ea, isPreSpawnExecutorFailure as Ec, AwaitWakeInput as Ed, McpServer as Ef, loopUntil as Ei, ReentryContinuity as El, WatchTraceOptions as Em, chatWorkerSeam as En, PanelSpec as Eo, SubmitOutput as Ep, StdioMcpConnection as Er, IsolatedCheckBoxEvidence as Es, InteractiveWorkerOptions as Et, workerSteerAcknowledgementsDir as Eu, closingWorkerNote as F, runAgentRounds as Fa, createInMemoryRunContext as Fc, DownMessageDeliveryAttempt as Fd, DelegateHandlerOptions as Ff, buildSteerContext as Fi, collectDelivered as Fl, SqlRunStoreOptions as Fm, supervisorInstructions as Fn, SteerContext as Fo, DelegateResearchResult as Fp, SandboxRunAbortError as Fr, PursuitVersions as Fs, GraphEdge as Ft, completionAuthorizes as Fu, WorkspaceCommit as G, InProcessPromptCtx as Ga, DriveHarness as Gc, QuestionDecision as Gd, CoderReviewer as Gf, BenchmarkLift as Gi, CoordinationDeliveryEvidence as Gl, SpawnForest as Gm, StructuralRolloutPolicy as Gn, WidenSpec as Go, DelegationProfile as Gp, S3PrivateCasStore as Gr, RUN_FORK_CORRELATION_KEYS as Gs, PromptHandle as Gt, PairwiseOptions as Gu, GitWorkspaceOptions as H, localSandboxClient as Ha, CoordinationBinding as Hc, ManagerReentryState as Hd, eventToSnapshot as Hf, sanitizeMcpToolSchema as Hi, serveCoordinationMcp as Hl, FileSpawnJournal as Hm, RepairStop as Hn, Widen as Ho, DelegationHistoryArgs as Hp, createSandboxLineage as Hr, SupervisedPursuitResult as Hs, defaultEdgeTraversalCap as Ht, Leaderboard as Hu, composeWorkerEvidence as I, SandboxEvidenceContext as Ia, withRunContext as Ic, DownMessageDeliveryOutcome as Id, DelegateResult as If, createScopeAnalyst as Ii, pickBestDelivered as Il, openSqlRunStore as Im, CheckExecChannel as In, TrajectoryNode as Io, DelegateUiAuditArgs as Ip, TurnResult as Ir, SettledPursuitVersion as Is, GraphEdgeCapError as It, deterministicCompletion as Iu, jjWorkspace as J, HarvestCorpusOptions as Ja, ResolveDriveHarness as Jc, QuestionEscalationTarget as Jd, DetachedWinnerSelection as Jf, BenchmarkTaskRow as Ji, FileCoordinationLog as Jl, SpawnForestMissingTree as Jm, canDisplace as Jn, DefinePersonaInput as Jo, DelegationStatus as Jp, reconnectRetainedRun as Jr, PursuitNodeCost as Js, analyzesFindingsReportPrompt as Jt, ScoreOf as Ju, WorkspaceRun as K, InProcessSandboxClientOptions as Ka, DriveHarnessOwnerContext as Kc, QuestionEscalationOutcome as Kd, DelegateRunCtx as Kf, BenchmarkReport as Ki, CoordinationLog as Kl, SpawnForestEvent as Km, StructuralRolloutResult as Kn, WinnerStrategy as Ko, DelegationProgress as Kp, S3PrivateCasStoreOptions as Kr, PursuitObserverDelivery as Ks, PromptRegistry as Kt, PairwiseVerdict as Ku, settledWorkerOut as L, SandboxEvidenceReceipt as La, SupervisorSpanAttributes as Lc, DownMessageEvent as Ld, createDelegateHandler as Lf, registryScopeAnalyst as Li, runFinalizer as Ll, D1DatabaseLike as Lm, CheckOutcome as Ln, TrajectoryReport as Lo, DelegateUiAuditConfig as Lp, openSandboxRun as Lr, VersionJudge as Ls, GraphNode as Lt, sentinelCompletion as Lu, NOTE_MAX_CHARS as M, TerminalDecision as Ma, RunContext as Mc, CoordinationToolsOptions as Md, DELEGATE_TOOL_NAME as Mf, CreateScopeAnalystOptions as Mi, FinalizerSettled as Ml, mapExecutorResult as Mm, assessAuthoredProfile as Mn, ScopeAnalyst as Mo, DelegateFeedbackResult as Mp, OpenSandboxRunOptions as Mr, NextPursuitVersionInput as Ms, AgentGraph as Mt, CompletionEvidence as Mu, VERIFY_TAIL_CHARS as N, defaultSelectWinner as Na, RunContextLease as Nc, DefinedAnalystRecord as Nd, DelegateArgs as Nf, RegistryAnalyzeProjection as Ni, SupervisorFinalizer as Nl, SqlRunLease as Nm, defaultProfileRichnessThresholds as Nn, ScopeAnalyzeInput as No, DelegateResearchArgs as Np, OpenSandboxRunPromptOptions as Nr, PursuitVersionChain as Ns, EdgeDeliveryOutcome as Nt, CompletionPolicy as Nu, WorkerInteractiveProviderSource as O, loopDispatch as Oa, retryPreSpawnRefusals as Oc, ContinuityMode as Od, createInProcessTransport as Of, pipeline as Oi, UNPROVEN_CONTINUITY as Ol, watchTrace as Om, AuthoredProfile as On, Pipeline as Oo, DelegateCodeArgs as Op, connectStdioMcp as Or, IsolatedCheckResult as Os, workerFromInteractiveProvider as Ot, workerSteerRequestsDir as Ou, WorkerEvidenceInput as P, isTerminalDecision as Pa, createFileRunContext as Pc, DownMessageAuthorizationInput as Pd, DelegateError as Pf, assertTraceDerivedFindings as Pi, bestDelivered as Pl, SqlRunOwnershipError as Pm, profileRichnessFinding as Pn, ScopeWidenGate as Po, DelegateResearchConfig as Pp, SandboxRun as Pr, PursuitVersionStop as Ps, EdgeTraversal as Pt, CompletionVerdict as Pu, analyzeTrace as Q, harvestCorpus as Qa, SupervisorAgentTestDeps as Qc, QuestionRecord as Qd, detachedSessionDelegate as Qf, AgenticOptions as Qi, WorkerCancelRequest as Ql, materializeTreeView as Qm, defaultStructuralRolloutPolicy as Qn, PersonaContext as Qo, FeedbackRefersTo as Qp, ClaimRetainedInteractiveControlOptions as Qr, PursuitNodeTiming as Qs, dumbContinuationPassPrompt as Qt, renderLeaderboardMarkdown as Qu, CopyOptions as R, SandboxEvidenceRetentionError as Ra, SupervisorSpanOptions as Rc, EscalateQuestion as Rd, validateDelegateArgs as Rf, observationFromRegistry as Ri, CoordinationAuthentication as Rl, D1StmtLike as Rm, CheckRunContext as Rn, TrajectoryReportFn as Ro, DelegateUiAuditResult as Rp, BranchCapableBox as Rr, VersionVerdict as Rs, GraphResult as Rt, stopSentinel as Ru, failuresAnalyst as S, LoopCampaignDispatchOptions as Sa, ResolvedWorkerSpawnRetry as Sc, AuthoredAnalystDefinition as Sd, SpawnResourceReader as Sf, worktreeCliProfileMaterialization as Sh, InMemoryCorpus as Si, createProgressTracker as Sl, BusStats as Sm, ChatTransportExecutorOptions as Sn, LoopUntilSpec as So, DelegationRunContext as Sp, LocalMcpMaterialization as Sr, declaredCheckDigest as Ss, WorktreePatchArtifact as St, workerControlLogFile as Su, worktreeFanout as T, SuperviseDispatchOptions as Ta, WorkerSpawnRetryPolicy as Tc, AuthorizedDownMessage as Td, resolveSpawnResourcePaths as Tf, flatWidenGate as Ti, sampleFromSettled as Tl, createEventBus as Tm, chatTransportExecutor as Tn, PanelJudge as To, SubmitInput as Tp, McpToolDescriptor as Tr, IsolatedCheckBox as Ts, InteractiveWorkerKeyInput as Tt, workerSteerAcknowledgementFile as Tu, Shell as U, inlineSandboxClient as Ua, CoordinationToolFace as Uc, ManagerWake as Ud, CoderDelegate as Uf, BenchmarkCell as Ui, CoordinationHttpAudit as Ul, InMemoryResultBlobStore as Um, StructuralRolloutConfig as Un, WidenDecision as Uo, DelegationHistoryEntry as Up, AcquireOptions as Ur, supervisePursuit as Us, runGraph as Ut, LeaderboardOptions as Uu, withUntrackedArtifacts as V, LocalSandboxClientOptions as Va, createSupervisorSpanRecorder as Vc, MakeWorkerAgent as Vd, InMemoryFeedbackStore as Vf, createMcpEnvironment as Vi, CoordinationTransportOptions as Vl, FileResultBlobStore as Vm, CheckSourceCtx as Vn, VerifySpec as Vo, DelegationFeedbackSnapshot as Vp, SessionCapableBox as Vr, SupervisePursuitOptions as Vs, TraversalContinuity as Vt, Interval as Vu, Workspace as W, InProcessOnPrompt as Wa, CoordinationVerbs as Wc, Question as Wd, CoderReview as Wf, BenchmarkConfig as Wi, CoordinationHttpOptions as Wl, InMemorySpawnJournal as Wm, StructuralRolloutMessage as Wn, WidenLineage as Wo, DelegationHistoryResult as Wp, acquireSandbox as Wr, PursuitFork as Ws, runGraphWithTestBrain as Wt, LeaderboardRow as Wu, runInWorkspace as X, HarvestFailure as Xa, ResolvedSupervisorProfile as Xc, QuestionOption as Xd, UiAuditorDelegate as Xf, printBenchmarkReport as Xi, RunCancelRequest as Xl, SpawnForestTree as Xm, composeCheckSources as Xn, Outcome as Xo, DelegationStatusResult as Xp, startRetainedRun as Xr, PursuitNodePlatform as Xs, delegatesWorkerBriefPrompt as Xt, pairwiseSignificance as Xu, localShell as Y, HarvestError as Ya, ResolveSupervisorTools as Yc, QuestionLevel as Yd, SettleDetachedCoderTurnOptions as Yf, Environment as Yi, PriorCoordination as Yl, SpawnForestNode as Ym, compareCheckOutcomes as Yn, LoopShape as Yo, DelegationStatusArgs as Yp, recoverRetainedRun as Yr, PursuitNodePlacement as Ys, createPromptRegistry as Yt, leaderboard as Yu, TrajectoryAnalysis as Z, HarvestReport as Za, SupervisorAgentDeps as Zc, QuestionPolicy as Zd, coderTaskFromArgs as Zf, runBenchmark as Zi, RunCancellation as Zl, loadSpawnForest as Zm, defaultExtractCandidate as Zn, Persona as Zo, FeedbackRating as Zp, startRetainedRunInEnvironment as Zr, PursuitNodeProjection as Zs, dumbContinuationFailPrompt as Zt, renderLeaderboardHtml as Zu, boxSurfaceReader as _, depthStrategy as _a, SuperviseRegistryTable as _c, AnalystKind as _d, ResolveSpawnResourcePathsResult as _f, promptOnlyProfileMaterialization as _h, createShapeRegistry as _i, StopDecision as _l, FileDelegationStoreOptions as _m, CodeModeRunner as _n, FanoutOptions as _o, DelegationArgs as _p, AuthoredStrategy as _r, DeclaredCheckPlacement as _s, SupervisorCleanupReceipt as _t, supervisorRunsRoot as _u, SandboxInstance$1 as a, RunAgenticOptions as aa, FileObserverJournal as ac, areaUnderCurve as ad, SuperviseProfileEntry as af, DefineProfileMaterializationContractOptions as ah, profileChatClient as ai, resolveSupervisorProfile as al, DELEGATION_TRACE_MAX_SPANS as am, DispatchUnit as an, observe as ao, createSiblingSandboxExecutor as ap, structuralRollout as ar, DefinedLeaderboard as as, createRootHandle as at, legacySupervisorRunDir as au, AnalystAuthoring as b, sample as ba, superviseWithTestBrain as bc, AnalystToolGroupName as bd, SpawnResourceBytes as bf, sandboxActProfileMaterialization as bh, runPersonified as bi, allWorkersStalled as bl, BusEvent as bm, ChatCompletionsTransport as bn, FlatWidenGate as bo, DelegationResumeDriver as bp, strategyAuthorContract as br, checkProgramDigest as bs, patchDelivered as bt, workerCancellationFile as bu, VerifierEnvironmentOptions as c, StrategyArtifacts as ca, ObserverRecordKind as cc, renderAnytimeTable as cd, WorkerSpawnContext as cf, ProfileMaterializationIssue as ch, assertProfileModelsAllowed as ci, DEFAULT_DEADLINE_WARNING_MS as cl, DelegationTraceSpan as cm, queueOf as cn, CombinatorShape as co, DetachedTurnResumeDriverOptions as cp, EvolutionReport as cr, LeaderboardBenchmarkAdapter as cs, SqlRunContextOptions as ct, readRunCancellation as cu, HarvestSurfaceDiffsOptions as d, StrategyResult as da, AuthorizedSpawn as dc, WaterfallSpan as dd, canonicalFindingEvent as df, controlProfileMaterialization as dh, PrivateCasOffloadReport as di, NoProgressForOptions as dl, composeLoopTraceEmitters as dm, defaultDelegateBudget as dn, CorpusRecord as do, RunDetachedTurnOptions as dp, StrategyTournament as dr, LeaderboardRunContext as ds, ScopeArgs as dt, readWorkerSteerAcknowledgement as du, AgenticSurface as ea, PursuitProjection as ec, renderPairwiseMarkdown as ed, SettledWorker as ef, contentAddress as eh, reconnectRetainedInteractiveRun as ei, SupervisorNodeContextSeed as el, UiAuditLensFilter as em, kernelPromptRegistry as en, ObservationAnalysis as eo, DelegationExecutor as ep, modelAuthoredChecks as er, RunPersonified as es, WorkerToolTraceArtifact as et, WorkerSteerAcknowledgement as eu, SurfaceDiff as f, StrategyShotResult as fa, AuthorizedSpawnContext as fc, createWaterfallCollector as fd, createCoordinationTools as ff, defineProfileMaterializationContract as fh, PrivateCasOptions as fi, PlateauOptions as fl, createDelegationTraceCollector as fm, delegate as fn, EqualKArm as fo, createDetachedTurnResumeDriver as fp, TournamentCell as fr, LeaderboardScenario as fs, createScope as ft, readWorkerSteerRequests as fu, WatchedSurface as g, defineStrategy as ga, SuperviseRegistry as gc, AnalystFindingEvent as gd, questionEscalationTargets as gf, promptModelProfileMaterialization as gh, builtinShapes as gi, ProgressView as gl, FileDelegationStore as gm, CodeModeOptions as gn, Fanout as go, runDetachedTurn as gp, AuthorStrategyOptions as gr, DeclaredCheck as gs, ProvisionedSupervisor as gt, supervisorRunDir as gu, SurfaceReader as h, breadthStrategy as ha, SuperviseOptions as hc, AnalystDefinitionIssue as hd, parseAuthoredAnalystDefinition as hf, promptControlProfileMaterialization as hh, trajectoryReport as hi, ProgressTrackerOptions as hl, DelegationStore as hm, finalizeBestDelivered as hn, EqualKVerdict as ho, parseDetachedSessionRef as hp, strategyTournament as hr, defineLeaderboard as hs, ProvisionSupervisorRequest as ht, safeWorkerFile as hu, SandboxEvent$1 as i, CorpusReadbackOptions as ia, projectPursuit as ic, anytimeReport as id, SpawnRefusalCause as if, CanonicalAgentProfileMaterializationAxis as ih, resolveSandboxClient as ii, assertCoordinationBinding as il, DELEGATION_TRACE_MAX_BYTES as im, DispatchStopReason as in, defaultAnalystInstruction as io, createFleetWorkspaceExecutor as ip, selectBestIndex as ir, ShapeRegistry as is, DEFAULT_MAX_DEPTH as it, cancelWorker as iu, EVIDENCE_MAX_CHARS as j, TERMINAL_DECISIONS as ja, InMemoryRunContextOptions as jc, CoordinationTools as jd, DELEGATE_INPUT_SCHEMA as jf, widen as ji, FinalizeContext as jl, gateOnDeliverable as jm, asAuthoredProfile as jn, RenderCorpusToInstructionsOptions as jo, DelegateFeedbackArgs as jp, OpenSandboxRunBeforeStartContext as jr, NextPursuitVersion as js, createInPlaceCliExecutor as jt, CompletionAnalyst as ju, attachWorker as k, superviseDispatch as ka, withWorkerSpawnRetry as kc, CoordinationEvent as kd, createMcpServer as kf, selectValidWinner as ki, composeReentryTask as kl, DeliverableSpec as km, ProfileRichness as kn, PipelineStage as ko, DelegateCodeConfig as kp, materializeLocalMcp as kr, runIsolatedCheck as ks, WorkerInteractiveAdmission as kt, workerSteersDir as ku, createVerifierEnvironment as l, StrategyCtx as la, observerRecordDigest as lc, WaterfallCollector as ld, WorkerWatchOptions as lf, ValidateProfileMaterializationOptions as lh, PrivateCasArtifactPort as li, ManagerWakePolicy as ll, buildDelegationTraceSpans as lm, rollingDispatch as ln, Corpus as lo, DriveTurnCapableBox as lp, EvolutionStrategy as lr, LeaderboardFlagSpec as ls, createFencedSqlRunContext as lt, readWorkerCancelRequests as lu, SurfaceReadOutcome as m, adaptiveRefine as ma, DeliverableResolutionInput as mc, AnalystAssignmentRecord as md, normalizeAnalyzeOnSettle as mf, profileMaterializationAxes$1 as mh, equalKOnCost as mi, ProgressTracker as ml, DelegationStateCorruptError as mm, driverAgent as mn, EqualKOnCostOptions as mo, formatDetachedSessionRef as mp, runStrategyEvolution as mr, LeaderboardSpec as ms, ProvisionSupervisorConnection as mt, runCancellationFile as mu, AnalystFinding$1 as n, AgenticTool as na, PursuitRunTotals as nc, AnytimeStrategySummary as nd, SpawnPreflightContext as nf, AgentProfileMaterializationAxis as nh, startRetainedInteractiveRun as ni, SupervisorToolDescriptor as nl, delegationProfiles as nm, promptHandle as nn, ObserveInput as no, FleetWorkspaceExecutorOptions as np, resolveEntrySymbol as nr, ShapeBudget as ns, parseWorkerToolTraceArtifact as nt, WriteWorkerSteerOptions as nu, computeFindingId$1 as o, ShotSpec as oa, ObserverJournal as oc, bestSoFar as od, ToolOutcomeEvent as of, KnownAgentProfileMaterializationAxis as oh, profileOptimizerModelCall as oi, supervisorAgent as ol, DelegationTraceCaps as om, RollingDispatchOptions as on, renderReport as oo, DetachedSessionRefParts as op, visibleCheckScore as or, LeaderboardBenchScore as os, createSupervisor as ot, legacySupervisorRunsRoot as ou, SurfaceReadBox as p, SurfaceScore as pa, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as pc, ANALYST_DEFINITION_BOUNDS as pd, downMessageRefusalReasons as pf, fullProfileMaterialization as ph, createPrivateCasArtifactPort as pi, ProgressSample as pl, DelegationPersistenceError as pm, DriverAgentOptions as pn, EqualKOnCost as po, detachedTurnEvents as pp, TournamentRow as pr, LeaderboardScore as ps, settledToIteration as pt, runCancelRequestFile as pu, gitWorkspace as q, inProcessSandboxClient as qa, ObserveSupervisorNodeEvent as qc, QuestionEscalationRecord as qd, DetachedSessionDelegateOptions as qf, BenchmarkStrategySummary as qi, CoordinationOwnerId as ql, SpawnForestInDoubtNode as qm, VisibleCheck as qn, DefinePersona as qo, DelegationResultPayload as qp, createS3PrivateCasStore as qr, PursuitCostProvenance as qs, RegisteredPrompt as qt, ProfileKeyOf as qu, CreateSandboxOptions$1 as r, ArtifactHandle as ra, PursuitStatus as rc, AnytimeTaskCurve as rd, SpawnRefusal as rf, AssertProfileMaterializationOptions as rh, ResolveSandboxClientOptions as ri, SupervisorToolInvocationContext as rl, CappedDelegationTrace as rm, DispatchReport as rn, ObserveOptions as ro, SiblingSandboxExecutorOptions as rp, sandboxCheckRunner as rr, ShapeContext as rs, workerTraceAnalysisStore as rt, cancelRun as ru, makeFinding$1 as s, Strategy as sa, ObserverRecord as sc, plateauLength as sd, WorkerResumeContext as sf, ProfileMaterializationContract as sh, assertModelAllowed as si, supervisorAgentWithTestBrain as sl, DelegationTraceCollector as sm, freeSlots as sn, AssertTraceDerivedFindings as so, DetachedTurn as sp, EvolutionAuthor as sr, LeaderboardBenchTask as ss, FencedSqlRunContext as st, readRunCancelRequest as su, AgentProfile$2 as t, AgenticTask as ta, PursuitRunProjection as tc, AnytimeReport as td, SpawnPreflight as tf, AGENT_PROFILE_MATERIALIZATION_AXES as th, recoverRetainedInteractiveRun as ti, SupervisorProfile as tl, UiAuditorDelegationOutput as tm, naiveContinuationPrompt as tn, ObservationError as to, FleetHandle as tp, officialChecksFromMeta as tr, RunPersonifiedOptions as ts, captureWorkerTraceEvidence as tt, WorkerSteerRequest as tu, BoxSurfaceReaderOptions as u, StrategyMessage as ua, verifyObserverRecords as uc, WaterfallReport as ud, analystToolGroupNames as uf, assertProfileMaterialization as uh, PrivateCasDurableStore as ui, AllWorkersStalledOptions as ul, capDelegationTrace as um, DelegateOptions as un, CorpusFilter as uo, DriveTurnTick as up, StrategyEvolutionConfig as ur, LeaderboardIterationInfo as us, SUBTREE_RESULT_LIMIT as ut, readWorkerCancellation as uu, fsSurfaceReader as v, refine as va, SuperviseTestOptions as vc, AnalystLensOutput as vd, ResolvedSpawnResourcePath as vf, promptResourceProfileMaterialization as vh, registerShape as vi, StopRule as vl, InMemoryDelegationStore as vm, codeModeSupervisorTools as vn, FanoutSynthesis as vo, DelegationRecord as vp, assertStrategyContract as vr, DeclaredCheckStateCapture as vs, provisionSupervisor as vt, supervisorWorkersDir as vu, WorktreeFanoutOptions as w, LoopOptionsForDispatch as wa, WorkerSpawnRetryHooks as wc, AuthorizeDownMessage as wd, hostDirectoryReader as wf, fanout as wi, plateau as wl, PublishOptions as wm, ChatWorkerSeamOptions as wn, Panel as wo, DelegationTaskQueueOptions as wp, McpSpawnFault as wr, readDeclaredCheck as ws, InteractiveWorkerEnvironment as wt, workerInboxFileFromEventDir as wu, analystsFromRegistry as x, sampleThenRefine as xa, workerFromBackend as xc, AnalyzeOnSettleRoute as xd, SpawnResourceRead as xf, validateProfileMaterialization as xh, FileCorpus as xi, anyOf as xl, BusRecord as xm, ChatSessionStore as xn, LoopUntil as xo, DelegationResumeTick as xp, strategyAuthorSystemPrompt as xr, declaredCheckDeliverable as xs, WorktreeCliExecutorOptions as xt, workerCancellationsDir as xu, harvestSurfaceDiffs as y, runAgentic as ya, supervise as yc, AnalystRegistry$1 as yd, SPAWN_RESOURCE_PATH_MAX_BYTES as yf, renderProfileMaterializationIssues as yh, definePersona as yi, allOf as yl, CoderOutput as ym, unsafeInProcessRunner as yn, FanoutWinnerSelector as yo, DelegationResumeContext as yp, authorStrategy as yr, assertDeclaredCheck as ys, PatchDeliverableOptions as yt, workerCancelRequestsFile as yu, UntrackedCopyStats as z, SandboxEvidenceRetentionPort as za, SupervisorSpanOutcome as zc, EventAcknowledgement as zd, FeedbackEvent as zf, McpEndpoint as zi, CoordinationMcpHandle as zl, SqlAdapter as zm, CheckRunner as zn, TrajectoryReportOptions as zo, DelegateUiAuditRoute as zp, SandboxLineage as zr, assertPursuitVersions as zs, RunGraphOptions as zt, AxisScoresOf as zu };
+//# sourceMappingURL=index-DflDZq_I.d.ts.map