@tangle-network/agent-runtime 0.338.0 → 0.340.0

package/dist/{types-CrNWif8-.d.ts → types-DZ6L0Bv3.d.ts}

@@ -1,11 +1,11 @@
-import { l as RuntimeHooks, o as RuntimeHookEvent, r as RuntimeDecisionPoint } from "./runtime-hooks-Bj6wJHlH.js";
-import { P as AgentCandidateOutputArtifactPort, g as AgentCandidateArtifactPort, l as AgentCandidateWorkspaceArchiveLimits, n as AgentCandidateWorkspaceTree } from "./workspace-streams-BZZds1Fw.js";
-import { s as ProfileMaterializationContract } from "./profile-materialization-BnoEf1co.js";
-import { n as AnalystRegistryLike } from "./types-zWfqDjeL.js";
-import { AgentCandidateArtifactRef, AgentCandidateWorkspaceManifestMaterial, AgentCandidateWorkspaceSnapshotEvidence, AgentExactRunControlRef, AgentInteractiveSession, AgentInteractiveSessionControlClaim, AgentInteractiveSessionPromptAcknowledgement, AgentInteractiveSessionPromptCommand, AgentInteractiveSessionRef, AgentInteractiveSessionStart, AgentInteractiveSessionStatus, AgentNativeContextContinuationOptions, AgentNativeContextContinuationResult, AgentProfile, AgentProfile as AgentProfile$2, AgentProfile as AgentProfile$3, AgentProfileDiff, AgentProfileMcpServer, AgentProfilePrompt, AgentProfileSecurityPolicy, AgentSessionStatus, AgentTurnResult, ChildTaskEvent, ContextTransferReceipt, ContextTransferRequest, HarnessType, InputPart, InteractionAcknowledgement, InteractionRequest, InteractionResponseCommand, NativeContextBoundaryProof, NativeContextContinuationRequest, NativeContextContinuationTurn, ReasoningEffort, RequestedInteractions, RuntimeEventEnvelope, Sha256Digest, StreamEvent, TokenUsage, WorkspaceCheckpointRef, WorkspaceCheckpointRequest } from "@tangle-network/agent-interface";
+import { l as RuntimeHooks, o as RuntimeHookEvent, r as RuntimeDecisionPoint } from "./runtime-hooks-nsqxSUFL.js";
+import { N as AgentCandidateOutputArtifactPort, g as AgentCandidateArtifactPort, l as AgentCandidateWorkspaceArchiveLimits, n as AgentCandidateWorkspaceTree } from "./workspace-streams-BiS4ABah.js";
+import { a as ProfileMaterializationContract } from "./profile-materialization-bPm0gGLO.js";
+import { n as AnalystRegistryLike } from "./types-Cwrea-bU.js";
+import { AgentCandidateArtifactRef, AgentCandidateWorkspaceManifestMaterial, AgentCandidateWorkspaceSnapshotEvidence, AgentExactRunControlRef, AgentInteractiveSession, AgentInteractiveSessionControlClaim, AgentInteractiveSessionPromptAcknowledgement, AgentInteractiveSessionPromptCommand, AgentInteractiveSessionRef, AgentInteractiveSessionStart, AgentNativeContextContinuationOptions, AgentNativeContextContinuationResult, AgentProfile, AgentProfile as AgentProfile$2, AgentProfile as AgentProfile$3, AgentProfileDiff, AgentProfileMcpServer, AgentProfilePrompt, AgentProfileSecurityPolicy, AgentSessionStatus, AgentTurnResult, ChildTaskEvent, ContextTransferReceipt, ContextTransferRequest, HarnessType, InputPart, InteractionAcknowledgement, InteractionRequest, InteractionResponseCommand, NativeContextBoundaryProof, NativeContextContinuationRequest, NativeContextContinuationTurn, ReasoningEffort, RequestedInteractions, RuntimeEventEnvelope, Sha256Digest, StreamEvent, TokenUsage, WorkspaceCheckpointRef, WorkspaceCheckpointRequest } from "@tangle-network/agent-interface";
 import { AgentEvalError, AgentEvalError as AgentEvalError$1, AgentEvalErrorCode, AgentProfile as AgentProfile$1, AnalystFinding, AnalystFinding as AnalystFinding$1, AnalystFinding as AnalystFinding$2, AnalystRunInputs, ChatClient, ConfigError, ControlBudget, ControlDecision, ControlEvalResult, ControlRunResult, ControlStep, CustomTokenPricing, DataAcquisitionPlan, DefaultVerdict, DefaultVerdict as DefaultVerdict$1, DefaultVerdict as DefaultVerdict$2, DetectorSignal, HarnessType as HarnessType$1, JudgeError, KnowledgeReadinessReport, KnowledgeRequirement, MaximumCharge, NotFoundError, PairedPromotionDecision, ProposalFinding, RankTestMethod, RegistryRunOpts, RunRecord, StreamingDetector, ToolSpan, TraceAnalysisEngine, TraceAnalysisStore, TraceStore, UserQuestion, ValidationError, buildTrajectory, computeFindingId as computeFindingId$1, makeFinding as makeFinding$1 } from "@tangle-network/agent-eval";
 import { AgentRunOutcome } from "@tangle-network/sandbox/runtime";
-import { BackendType, BranchOptions, CreateRequestOptions, CreateSandboxOptions, CreateSandboxOptions as CreateSandboxOptions$1, Process, PromptOptions, Sandbox, SandboxEvent, SandboxEvent as SandboxEvent$1, SandboxInstance, SandboxInstance as SandboxInstance$1, SandboxResources } from "@tangle-network/sandbox";
+import { BackendType, CreateRequestOptions, CreateSandboxOptions, CreateSandboxOptions as CreateSandboxOptions$1, PromptOptions, SandboxEvent, SandboxEvent as SandboxEvent$1, SandboxInstance, SandboxInstance as SandboxInstance$1, SandboxResources } from "@tangle-network/sandbox";
 import { watch } from "node:fs";
 import { ChildProcess } from "node:child_process";
 import { HarnessId, WorkspacePlanReceipt } from "@tangle-network/agent-profile-materialize";
@@ -14,7 +14,7 @@ import { AnalystRegistry, AnalystRunInputs as AnalystRunInputs$1, AnalystRunResu
 import { DispatchFn, ExternalOptimizerModelCall, JudgeConfig, NodeEstimate, ProfileDispatchFn, RunProfileMatrixOptions, RunProfileMatrixResult, Scenario, SearchAllocator, SearchAudit, SearchClaim, SearchClaimVerification, SearchCloseReason, SearchHistoryReceipt, SearchNodeStatus, SearchPolicy, SearchSplit, SearchStateView } from "@tangle-network/agent-eval/campaign";
 import { EvaluationClaim, SealedExperiment } from "@tangle-network/agent-eval/experiment";
 import { stuckLoopView, toolWasteView } from "@tangle-network/agent-eval/pipelines";
-import { AgentEnvironment, AgentEnvironment as AgentEnvironment$1, AgentEnvironmentCapabilities, AgentEnvironmentCapabilities as AgentEnvironmentCapabilities$1, AgentEnvironmentEvent, AgentEnvironmentEvent as AgentEnvironmentEvent$1, AgentEnvironmentProvider, AgentEnvironmentProvider as AgentEnvironmentProvider$1, AgentEnvironmentQuery, AgentEnvironmentStatus, AgentEnvironmentSummary, AgentProfileRef, AgentSession, AgentSessionRef, AgentSessionStatus as AgentSessionStatus$1, AgentTurnInput, AgentTurnInput as AgentTurnInput$1, AgentTurnResult as AgentTurnResult$1, AgentTurnResult as AgentTurnResult$2, CheckpointRef, CheckpointRequest, CreateAgentEnvironmentInput, CreateAgentEnvironmentInput as CreateAgentEnvironmentInput$1, ExecRequest, ExecResult, ForkRequest, PlacementInfo, ResourceRequest, WorkspaceRequest } from "@tangle-network/agent-interface/environment-provider";
+import { AgentEnvironment, AgentEnvironment as AgentEnvironment$1, AgentEnvironmentCapabilities, AgentEnvironmentCapabilities as AgentEnvironmentCapabilities$1, AgentEnvironmentEvent, AgentEnvironmentEvent as AgentEnvironmentEvent$1, AgentEnvironmentProvider, AgentEnvironmentProvider as AgentEnvironmentProvider$1, AgentEnvironmentQuery, AgentEnvironmentStatus, AgentEnvironmentSummary, AgentSession, AgentSessionRef, AgentSessionStatus as AgentSessionStatus$1, AgentTurnInput, AgentTurnInput as AgentTurnInput$1, AgentTurnResult as AgentTurnResult$1, AgentTurnResult as AgentTurnResult$2, CheckpointRef, CheckpointRequest, CreateAgentEnvironmentInput, CreateAgentEnvironmentInput as CreateAgentEnvironmentInput$1, ExecRequest, ExecResult, ForkRequest, PlacementInfo, ResourceRequest, WorkspaceRequest } from "@tangle-network/agent-interface/environment-provider";
 import { CodemodeExecuteOptions, CodemodeJsonSchema, CodemodeResult, CodemodeSandboxOptions } from "@earendil-works/pi-codemode";
 //#region src/runtime/retained-run-types.d.ts
 /** Cursor plus runtime sequence needed to continue one ordered replay. @stable */
@@ -1891,9 +1891,6 @@ interface TraceSource {
   /** The full set of tool spans for the run (SETTLE / batch). Always available. */
   collect(): Promise<ToolSpan[]>;
 }
-/** Decode a part with a specific harness's adapter when known, else try every registered adapter
- *  (the composite — robust to mixed/unknown streams). Never throws. */
-declare function decodeToolPart(part: unknown, harness?: HarnessType): ToolStepInput | undefined;
 /** A push source for OWNED tool loops (router-tools / cli-bridge tool dispatch): the loop calls
  *  `record(step)` for each tool call; it becomes a span, fan-out to live subscribers + buffered for
  *  `collect`. */
@@ -1909,23 +1906,6 @@ declare function createPushTraceSource(opts?: {
 interface SessionMessageLike {
   readonly parts?: ReadonlyArray<unknown>;
 }
-/** The minimal box surface this needs: list a session's messages (incl. mid-turn partials). */
-interface SessionTraceBox {
-  messages(opts: {
-    sessionId: string;
-  }): Promise<ReadonlyArray<SessionMessageLike>>;
-}
-/** The SANDBOX / fleet trace source: read a box session's message parts and decode the harness's tool
- *  calls into spans. `collect` (settle) is the solid path — `box.messages({sessionId})` → parts → spans;
- *  black-box harnesses aren't mid-step interruptible, so online steering is the owned-loop's job and a
- *  live `subscribe` is opt-in (pass `subscribeParts` from `streamPrompt` when the harness streams parts). */
-declare function sandboxSessionTraceSource(box: SessionTraceBox, sessionId: string, opts?: {
-  /** The box's harness (e.g. 'opencode', 'claude-code') → selects its decoder adapter. */
-  harness?: HarnessType;
-  subscribeParts?: (onPart: (part: unknown) => void) => () => void;
-  runId?: string;
-  now?: () => number;
-}): TraceSource;
 //#endregion
 //#region src/runtime/supervise/contracts/executor-port.d.ts
 /**
@@ -2545,108 +2525,6 @@ declare class BackendTransportError extends AgentEvalError {
     providerDispatch?: 'not_started';
   });
 }
-/**
- *
- * A runtime-run lifecycle method was called in an order the state machine does
- * not allow: `persist()` before `complete()`, `complete()` twice, etc.
- *
- * @stable
- */
-declare class RuntimeRunStateError extends AgentEvalError {
-  constructor(message: string, options?: {
-    cause?: unknown;
-  });
-}
-/**
- *
- * The dynamic-loop planner returned an unusable topology move — the LLM emitted
- * no parseable envelope, an unknown `kind`, or a structurally-invalid move
- * (e.g. a fanout with zero tasks). This is a structural failure of the
- * agent-authored topology, not a config mistake: the planner ran but its output
- * cannot drive the kernel. Carries `validation` so cross-package handlers can
- * pattern-match without importing the runtime. Fail loud — never substitute a
- * default move, or the loop silently runs a topology nobody chose.
- *
- * @stable
- */
-declare class PlannerError extends AgentEvalError {
-  constructor(message: string, options?: {
-    cause?: unknown;
-  });
-}
-/**
- *
- * The caller's `onAdmission` durability hook rejected, so a retained run's
- * admission record is not durable. For a pre-create intent, no provider work
- * has started. For a later record, provider state may already be live and the
- * environment remains available for recovery. Carries `capture_integrity`
- * because the required recovery record was not written.
- *
- * @stable
- */
-declare abstract class RetainedAdmissionError<TAdmission extends RetainedRunAdmission | RetainedInteractiveAdmission> extends AgentEvalError {
-  readonly phase: TAdmission['phase'];
-  /** The exact record the hook failed to persist, for direct recovery. */
-  readonly admission: TAdmission;
-  constructor(admission: TAdmission, options?: {
-    cause?: unknown;
-  });
-}
-/** The caller could not persist one detached-run recovery record. @stable */
-declare class RetainedRunAdmissionError extends RetainedAdmissionError<RetainedRunAdmission> {}
-/** The caller could not persist one exact interactive-process recovery record. @stable */
-declare class RetainedInteractiveAdmissionError extends RetainedAdmissionError<RetainedInteractiveAdmission> {}
-/**
- * A provider returned a valid interactive reference that does not bind to the
- * exact start request, or returned data that could not be parsed as one.
- *
- * The requested start and any valid provider reference are detached snapshots.
- * Malformed provider data is never copied into the error, so the error remains
- * safe to persist while the environment remains available for orphan cleanup.
- *
- * @stable
- */
-declare class RetainedInteractiveBindingError extends AgentEvalError {
-  /** The exact native-process start request sent to the provider. */
-  readonly requested: AgentInteractiveSessionStart;
-  /** The valid provider data, when the provider returned a parseable value. */
-  readonly returned: {
-    readonly ref?: AgentInteractiveSessionRef;
-    readonly status?: AgentInteractiveSessionStatus;
-  };
-  constructor(requested: AgentInteractiveSessionStart, returned: RetainedInteractiveBindingError['returned'], options?: {
-    cause?: unknown;
-  });
-}
-/**
- *
- * A retained dispatch answered with coordinates that do not bind to the
- * identity the runtime requested, or failed exact verification. The
- * environment-phase admission is already durable at this point, so its
- * coordinates plus the provider reference carried here are the manual
- * recovery path. The environment is intentionally kept. Carries
- * `backend_integrity` because the provider violated its dispatch contract.
- *
- * @stable
- */
-declare class RetainedRunDispatchBindingError extends AgentEvalError {
-  /** The coordinates the runtime sent with the dispatch. */
-  readonly requested: {
-    readonly provider: string;
-    readonly environmentId: string;
-    readonly sessionId: string;
-    readonly executionId: string;
-  };
-  /** The loose reference the provider actually returned, for triage. */
-  readonly returned: {
-    readonly id?: string;
-    readonly provider?: string;
-    readonly controlRef?: unknown;
-  };
-  constructor(requested: RetainedRunDispatchBindingError['requested'], returned: RetainedRunDispatchBindingError['returned'], options?: {
-    cause?: unknown;
-  });
-}
 //#endregion
 //#region src/redact.d.ts
 /**
@@ -2671,13 +2549,6 @@ type Redactor = (value: unknown) => unknown;
  * on customer input and never mutates it.
  */
 declare function defaultRedactor(value: unknown): unknown;
-/**
- * Resolve the redactor a client uses. A caller-supplied hook handles
- * domain-specific values first, then the built-in scrubber still removes
- * credentials and personal data. Returning `false` is the explicit opt-out for
- * already-reviewed public values.
- */
-declare function resolveRedactor(redact: Redactor | false | undefined): Redactor;
 //#endregion
 //#region src/durable/content-address.d.ts
 /** Stable content address shared by result and trace artifacts. */
@@ -2863,27 +2734,6 @@ interface SqlAdapter {
   /** Execute a read statement (SELECT). Returns rows as plain objects. */
   query<TRow = Record<string, unknown>>(sql: string, params?: readonly unknown[]): Promise<TRow[]>;
 }
-/**
- * Adapt a Cloudflare D1 binding to the SqlAdapter shape. Lives here so D1
- * consumers don't have to write the wrapper themselves; the runtime never
- * imports `@cloudflare/workers-types` directly (peer-style typing).
- */
-declare function d1ToSqlAdapter(db: D1DatabaseLike): SqlAdapter;
-/**
- * Structural type matching the surface of `D1Database` we depend on, so the
- * SDK never imports `@cloudflare/workers-types`. Consumers pass their real
- * `D1Database` from `env.DB` and TS structural compatibility lines it up.
- */
-interface D1DatabaseLike {
-  prepare(sql: string): D1StmtLike;
-}
-interface D1StmtLike {
-  bind(...params: unknown[]): D1StmtLike;
-  run(): Promise<unknown>;
-  all<TRow = unknown>(): Promise<{
-    results?: TRow[];
-  }>;
-}
 //#endregion
 //#region src/durable/sql-run-store.d.ts
 /** @internal The SQL run context owns the payload schema; this store owns publication. */
@@ -2923,6 +2773,184 @@ declare function openSqlRunStore<Payload>(db: SqlAdapter, runId: string, options
   acquire(signal?: AbortSignal): Promise<SqlRunLease<Payload>>;
 }>;
 //#endregion
+//#region src/mcp/codex-execution-policy.d.ts
+/** Isolation settings asserted before a reproducible Codex run is allowed to start. */
+interface CodexExecutionPolicy {
+  sessionPersistence: 'ephemeral';
+  userConfig: false;
+  rules: false;
+  projectInstructions: false;
+  skillInstructions: false;
+  appInstructions: false;
+  toolSuggestions: false;
+  multiAgentInstructions: false;
+  sandbox: 'workspace-write';
+  permissionProfile: 'agent_runtime_reproducible';
+  approvalPolicy: 'never';
+  shellNetwork: false;
+  webSearch: false;
+  serviceTier: 'default';
+  shellEnvironment: 'core-filtered';
+  loginShell: false;
+  credentialsReadable: false;
+  hostHomeReadable: false;
+  procEnvironment: 'private-sanitized';
+  sensitiveEnvironmentNamesVisible: false;
+  parentRepoRead: false;
+  gitMetadata: false;
+  temporaryDirectory: 'workspace-private';
+  stagedExecutable: 'static-elf-read-only';
+  callerReadDeniedPaths: 'enforced';
+  containerSockets: false;
+}
+//#endregion
+//#region src/mcp/codex-token-usage.d.ts
+/**
+ * Exact aggregate usage emitted by Codex's terminal `turn.completed` JSONL event.
+ *
+ * `cachedInputTokens` is a part of `inputTokens` and `reasoningOutputTokens` is a part of
+ * `outputTokens`; neither adds to the total it describes. `cacheWriteInputTokens` is optional
+ * because the codex CLI reports it and a provider-normalized capture omits it, and an absent
+ * counter must stay absent rather than become a zero that claims no cache write was measured.
+ */
+interface CodexTokenUsage {
+  inputTokens: number;
+  cachedInputTokens: number;
+  outputTokens: number;
+  reasoningOutputTokens: number;
+  cacheWriteInputTokens?: number;
+}
+//#endregion
+//#region src/mcp/local-harness-invocation.d.ts
+/**
+ * Local coding harness available inside the sandbox — a narrowing of the shared `HarnessType`
+ * vocabulary, NOT a private spelling of it. The harness id is `claude-code`; `claude` is the
+ * EXECUTABLE name and lives only in the `command` field below. Keeping one vocabulary is what
+ * lets a `LocalHarness` be handed straight to the profile materializer and the capability table
+ * with no translation step.
+ */
+type LocalHarness = Extract<HarnessType, 'claude-code' | 'codex' | 'opencode' | 'pi'>;
+/** Every local harness, in table order — the one list `AGENT_RUNTIME_LOCAL_HARNESSES` and any
+ *  other harness enumeration reads, so adding a row above is the only edit a new harness needs. */
+declare const LOCAL_HARNESSES: ReadonlyArray<LocalHarness>;
+//#endregion
+//#region src/mcp/local-harness-process.d.ts
+/** @experimental */
+interface RunLocalHarnessOptions {
+  harness: LocalHarness;
+  /** Working directory for the subprocess (typically a worktree path). */
+  cwd: string;
+  /** Prompt forwarded as the harness CLI's task argument. */
+  taskPrompt: string;
+  /**
+   * Pre-built command + args (e.g. from `harnessInvocation` so the full authored
+   * `AgentProfile` — systemPrompt + model — reaches the harness). When set it OVERRIDES the
+   * default prompt-only `buildArgs(taskPrompt)` path; `command` defaults to the harness's
+   * default binary when only `args` is supplied. When absent the legacy prompt-only shape
+   * is used unchanged.
+   */
+  invocation?: {
+    command?: string;
+    args: ReadonlyArray<string>;
+  };
+  /** Allow autonomous edits without an interactive approval gate, using whichever bypass argv the
+   *  harness declares. Use only when `cwd` is an isolated candidate worktree. */
+  dangerouslySkipPermissions?: boolean;
+  /** Isolate Codex from ambient configuration/instructions and require JSONL token usage.
+   *  The invocation should come from `harnessInvocation(..., { codexReproducible: true })`. */
+  codexReproducible?: boolean;
+  /** Absolute host paths that reproducible Codex must not read. The normalized set is compiled
+   *  into the controlled permission profile and its digest is returned in execution evidence. */
+  codexReadDeniedPaths?: ReadonlyArray<string>;
+  /** Optional wall-clock kill deadline (ms). Omit it for no timer. A positive value sends
+   *  SIGTERM on expiry. */
+  timeoutMs?: number;
+  /** Newest stdout/stderr bytes retained per stream. Default 64 MiB. */
+  maxOutputBytes?: number;
+  /** Caller cancellation. SIGTERM is sent on abort. */
+  signal?: AbortSignal;
+  /** Override env (defaults to inheriting from the parent). */
+  env?: NodeJS.ProcessEnv;
+  /**
+   * Test seam — inject a custom spawner so unit tests can mock the
+   * subprocess without touching the OS. Defaults to node's `child_process.spawn`.
+   */
+  spawn?: (command: string, args: ReadonlyArray<string>, opts: {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    stdio: 'pipe';
+    detached: boolean;
+  }) => ChildProcess;
+  /** Test seam for locating the native Codex executable before it is staged in the worktree. */
+  resolveCodexExecutable?: (command: string, env: NodeJS.ProcessEnv) => Promise<string>;
+}
+/** @experimental */
+interface LocalHarnessResult {
+  /** OS exit code. `null` when killed before exit. */
+  exitCode: number | null;
+  /** Concatenated stdout. */
+  stdout: string;
+  /** Concatenated stderr. */
+  stderr: string;
+  /** Set when the process exited via signal (timeout / abort). */
+  killedBySignal: NodeJS.Signals | null;
+  /** Wall-clock duration ms (spawn → exit). */
+  durationMs: number;
+  /** Set when timeoutMs elapsed before exit. */
+  timedOut: boolean;
+  /**
+   * Set when the caller's AbortSignal fired before this result settled.
+   * Optional so injected runners and stored results from older releases remain valid.
+   */
+  aborted?: boolean;
+  /** Present for a reproducible Codex run; parsed from the real terminal JSONL event. */
+  usage?: CodexTokenUsage;
+  /** Present for reproducible Codex runs; generated and checked before model execution. */
+  evidence?: CodexExecutionEvidence;
+}
+/**
+ * Spawn a local coding harness CLI as a subprocess + collect its output.
+ *
+ * NOT responsible for parsing the harness's output or extracting a diff —
+ * the in-process executor's `streamPrompt` orchestrates `git diff` against
+ * the worktree after this resolves. This function is intentionally narrow:
+ * spawn, wait, capture, return.
+ *
+ * Fails loud — throws when:
+ *   - `cwd` doesn't exist (subprocess emits ENOENT; surfaced as Error)
+ *   - the harness binary is not on PATH (ENOENT)
+ *   - the caller signal was already aborted before process launch
+ *
+ * Does NOT throw when:
+ *   - the subprocess exits non-zero (`result.exitCode` carries the code)
+ *   - a non-reproducible subprocess is aborted / timed out (`result.aborted` /
+ *     `result.timedOut` carries the reason even when a TERM-aware child exits zero)
+ *
+ * Reproducible Codex additionally requires a terminal usage event. If cancellation
+ * prevents that event, this rejects with `CodexExecutionDiagnosticError` instead of
+ * returning an incomplete reproducibility receipt.
+ *
+ * @experimental
+ */
+declare function runLocalHarness(options: RunLocalHarnessOptions): Promise<LocalHarnessResult>;
+//#endregion
+//#region src/mcp/codex-execution-evidence.d.ts
+/** Zero-model-call evidence for the exact Codex process about to run. */
+interface CodexExecutionEvidence {
+  cliVersion: string;
+  executableSha256: string;
+  /** SHA-256 of the exact composed prompt argument proved present in the rendered prompt. */
+  requestedPromptSha256: string;
+  effectivePromptSha256: string;
+  nonPromptArgsSha256: string;
+  controlledConfigSha256: string;
+  /** Sorted normalized paths compiled into the permission profile. */
+  readDeniedPaths: string[];
+  readDeniedPathsSha256: string;
+  readDeniedPathCount: number;
+  policy: CodexExecutionPolicy;
+}
+//#endregion
 //#region src/mcp/tools/coordination-analysts.d.ts
 /**
  * What one analyst lens may return.
@@ -2952,7 +2980,7 @@ interface AnalystKind {
 declare const analystToolGroupNames: readonly ["all", "discovery", "discoveryAndRead", "discoveryAndSearch", "targeted", "singleTrace"];
 type AnalystToolGroupName = (typeof analystToolGroupNames)[number];
 /** Bounds on the recursive investigation a defined analyst may run. Each field is optional and is
- *  clamped to {@link ANALYST_DEFINITION_BOUNDS}; omitted fields take the engine's own default. */
+ *  clamped to `ANALYST_DEFINITION_BOUNDS`; omitted fields take the engine's own default. */
 interface AuthoredAnalystLimits {
   readonly maxIterations?: number;
   readonly maxLlmCalls?: number;
@@ -2991,35 +3019,6 @@ interface AuthoredAnalystDefinition {
   /** Minimum distinct evidence citations per finding. Default 1. */
   readonly minimumEvidenceCitations?: number;
 }
-/** Every bound `define_analyst` enforces before a definition reaches a registry.
- *
- *  MOTIVE, stated as numbers, because a fence whose motive cannot be stated is over-engineering:
- *  a defined lens spends real model calls from the run's own account on every settle it is routed
- *  over, and its `instructions` are re-sent on every one of them. So the two fields that multiply
- *  — `instructions` bytes and `maxLlmCalls` — are the ones with hard ceilings, and the ceilings are
- *  twice agent-eval's own defaults (`maxIterations` 12, `maxLlmCalls` 8, `maxToolCalls` 48,
- *  `maxOutputChars` 10_000): enough headroom for a deeper question than the shipped lenses ask,
- *  not enough for one definition to become the dominant cost of a run. */
-declare const ANALYST_DEFINITION_BOUNDS: Readonly<{
-  idPattern: RegExp;
-  maxDescriptionChars: 300;
-  maxAreaChars: 64;
-  maxQuestionChars: 1000;
-  maxInstructionsChars: 20000;
-  maxModelChars: 128;
-  maxIterations: 24;
-  maxLlmCalls: 16;
-  maxToolCalls: 96;
-  maxOutputChars: 20000;
-  maxEvidenceCitations: 10;
-  /** Lenses ONE manager may define, counting those it defined in a PRIOR process of a durable run.
-   *  This bounds MENU GROWTH, not spend: a definition costs nothing until `run_analyst` is called,
-   *  so the failure it stops is a manager that keeps re-authoring a lens instead of running one —
-   *  each definition adds a line every later `list_analysts` re-reads. Eight is more than the five
-   *  calibrated lenses agent-eval ships. Per-run analyst SPEND is bounded by the conserved pool the
-   *  engine draws from, not here. */
-  maxDefinitionsPerManager: 8;
-}>;
 /** What the coordination layer records when a definition is admitted: the exact accepted bytes, the
  *  kind the registry returned, and a digest over the definition so a finding can be traced back to
  *  the words that produced it. */
@@ -3051,7 +3050,7 @@ interface AnalystRegistry$1 {
    * run started. Present = `define_analyst` is mounted; absent = the menu is fixed (the status quo).
    *
    * The coordination layer validates and bounds the definition first (see
-   * {@link ANALYST_DEFINITION_BOUNDS}) and refuses a duplicate id, so an implementation receives
+   * `ANALYST_DEFINITION_BOUNDS`) and refuses a duplicate id, so an implementation receives
    * only well-formed, in-bounds definitions. It returns the {@link AnalystKind} the lens is now
    * reachable as; `run_analyst` must resolve that id immediately afterwards. THROWING is the
    * refusal channel — an unavailable model seat, a policy that forbids authored lenses — and the
@@ -3071,15 +3070,6 @@ interface AnalystFindingEvent {
    *  digesting subscribers (the coordination-event id) never throw on analyst-shaped data. */
   readonly findings?: unknown;
 }
-/** Producer-side cleanliness for the `finding` event. The findings payload is arbitrary analyst
- *  output, the digest a subscriber computes (RFC 8785) throws on ANY `undefined` value — nested
- *  included — and a throwing subscriber leaves the event invisible to EVERY subscriber. The
- *  producer, not the digest, owns keeping the event canonical: an `undefined` payload is stripped
- *  to key-absence, everything else is JSON round-tripped (nested `undefined` object values drop,
- *  `undefined` array slots become `null`), and a payload JSON cannot represent at all (cycle,
- *  BigInt, bare function) becomes a record OF that fact — degraded findings beat a vanished
- *  event. */
-declare function canonicalFindingEvent(finding: AnalystFindingEvent): AnalystFindingEvent;
 /**
  * One analyst-on-settle ROUTE: which lens runs (`kind`), over WHICH settled workers (`over`),
  * delivered to WHOM (`to`), wrapped in WHAT standing instruction (`directive`). The generalized
@@ -3143,26 +3133,6 @@ interface AnalystAssignmentRecord {
   readonly directive?: string;
   readonly to?: string;
 }
-/** One rejected field of an authored analyst definition: which field, and what is wrong with it. */
-interface AnalystDefinitionIssue {
-  readonly path: string;
-  readonly message: string;
-}
-/**
- * Validate and BOUND one `define_analyst` argument.
- *
- * Every reason is collected, never short-circuited: a manager re-authoring from a partial list of
- * complaints spends a turn per complaint. Numeric limits are CLAMPED rather than rejected — asking
- * for 200 tool calls is a mis-estimate, not a malformed definition, and the accepted value is
- * returned so the manager reads the ceiling it actually got.
- */
-declare function parseAuthoredAnalystDefinition(raw: unknown): {
-  definition: AuthoredAnalystDefinition;
-} | {
-  issues: ReadonlyArray<AnalystDefinitionIssue>;
-};
-/** Normalize the two spellings of an analyst-on-settle entry to the route form. */
-declare function normalizeAnalyzeOnSettle(entry: string | AnalyzeOnSettleRoute): AnalyzeOnSettleRoute;
 //#endregion
 //#region src/runtime/supervise/detector-monitor.d.ts
 interface WatchTraceOptions {
@@ -3474,7 +3444,7 @@ type MapItemFailurePolicy = 'all-or-refuse' | 'settled-subset';
  * is the item's task — at most `concurrency` at a time. Once every item settled it starts `join`
  * with the ordered results. Items and the join go through the same admission a `spawn_worker` call
  * takes (pre-flight, budget reservation from the conserved pool, `makeWorkerAgent`), carrying the
- * runtime-authored {@link WorkerSpawnContext.map} marker, so no manager turn is spent on them.
+ * runtime-authored `WorkerSpawnContext.map` marker, so no manager turn is spent on them.
  *
  * Every step publishes a `map` event. Item settlements are recorded but not queued, so the
  * manager is woken by the join's settlement, or by a `map` event when the map was refused or its
@@ -3536,15 +3506,6 @@ interface MapTraversalEvent {
 }
 //#endregion
 //#region src/mcp/tools/coordination-messages.d.ts
-/**
- * Why one parent→child delivery did not land, in the words the MANAGER needs.
- *
- * `DownMessageDeliveryOutcome` is the machine code; this is the sentence beside it. A code alone
- * left the manager to guess whether to retry, spawn, or give up — `already-settled` and
- * `scope-stopped` look alike and need opposite moves. Every refusal a coordination verb returns
- * carries a sentence like these, because the manager cannot see the state that produced it.
- */
-declare const downMessageRefusalReasons: Readonly<Record<DownMessageDeliveryOutcome, string>>;
 /** How a spawn CONTINUES a node's prior work: `'fresh'` starts a brand-new session (the default,
  *  and the only pre-continuity behavior); `'resume'` re-attaches to the node's most recent
  *  SETTLED worker — a NEW live worker is spawned whose spawn context carries the prior worker's
@@ -4118,261 +4079,7 @@ interface ToolOutcomeEvent {
   readonly elapsedMs: number;
 }
 //#endregion
-//#region src/mcp/codex-execution-policy.d.ts
-/** Isolation settings asserted before a reproducible Codex run is allowed to start. */
-interface CodexExecutionPolicy {
-  sessionPersistence: 'ephemeral';
-  userConfig: false;
-  rules: false;
-  projectInstructions: false;
-  skillInstructions: false;
-  appInstructions: false;
-  toolSuggestions: false;
-  multiAgentInstructions: false;
-  sandbox: 'workspace-write';
-  permissionProfile: 'agent_runtime_reproducible';
-  approvalPolicy: 'never';
-  shellNetwork: false;
-  webSearch: false;
-  serviceTier: 'default';
-  shellEnvironment: 'core-filtered';
-  loginShell: false;
-  credentialsReadable: false;
-  hostHomeReadable: false;
-  procEnvironment: 'private-sanitized';
-  sensitiveEnvironmentNamesVisible: false;
-  parentRepoRead: false;
-  gitMetadata: false;
-  temporaryDirectory: 'workspace-private';
-  stagedExecutable: 'static-elf-read-only';
-  callerReadDeniedPaths: 'enforced';
-  containerSockets: false;
-}
-//#endregion
-//#region src/mcp/codex-token-usage.d.ts
-/**
- * Exact aggregate usage emitted by Codex's terminal `turn.completed` JSONL event.
- *
- * `cachedInputTokens` is a part of `inputTokens` and `reasoningOutputTokens` is a part of
- * `outputTokens`; neither adds to the total it describes. `cacheWriteInputTokens` is optional
- * because the codex CLI reports it and a provider-normalized capture omits it, and an absent
- * counter must stay absent rather than become a zero that claims no cache write was measured.
- */
-interface CodexTokenUsage {
-  inputTokens: number;
-  cachedInputTokens: number;
-  outputTokens: number;
-  reasoningOutputTokens: number;
-  cacheWriteInputTokens?: number;
-}
-/**
- * Parse and validate the one terminal usage event emitted by `codex exec --json`.
- *
- * The JSONL framing is this surface's own; the usage RECORD is read by `parseCodexUsageRecord`,
- * the one codex usage reader the sandbox decoder also calls, so both surfaces hold the same field
- * policy and the same two cross-field invariants.
- */
-declare function parseCodexTokenUsage(stdout: string): CodexTokenUsage;
-//#endregion
-//#region src/mcp/local-harness-invocation.d.ts
-/**
- * Local coding harness available inside the sandbox — a narrowing of the shared `HarnessType`
- * vocabulary, NOT a private spelling of it. The harness id is `claude-code`; `claude` is the
- * EXECUTABLE name and lives only in the `command` field below. Keeping one vocabulary is what
- * lets a `LocalHarness` be handed straight to the profile materializer and the capability table
- * with no translation step.
- */
-type LocalHarness = Extract<HarnessType, 'claude-code' | 'codex' | 'opencode' | 'pi'>;
-/** Every local harness, in table order — the one list `AGENT_RUNTIME_LOCAL_HARNESSES` and any
- *  other harness enumeration reads, so adding a row above is the only edit a new harness needs. */
-declare const LOCAL_HARNESSES: ReadonlyArray<LocalHarness>;
-/** The harness a caller gets when it expresses no preference. A composition-root default, not a
- *  capability claim: one constant so the several entry points cannot drift apart. */
-declare const DEFAULT_LOCAL_HARNESS: LocalHarness;
-/** The CLI binary a harness id runs. The two are NOT the same string (`claude-code` runs `claude`),
- *  so anything spawning a harness — a version probe, a login check — reads it from here rather than
- *  passing the harness id as a command. */
-declare function localHarnessExecutable(harness: LocalHarness): string;
-/**
- * Whether the harness's native control can express this reasoning effort. Admission checks read
- * this so a profile the invocation would later refuse is rejected BEFORE any workspace state is
- * created, against the same table that emits the argv.
- */
-declare function harnessSupportsReasoningEffort(harness: LocalHarness, reasoningEffort: ReasoningEffort): boolean;
-//#endregion
-//#region src/mcp/codex-execution-evidence.d.ts
-/** Zero-model-call evidence for the exact Codex process about to run. */
-interface CodexExecutionEvidence {
-  cliVersion: string;
-  executableSha256: string;
-  /** SHA-256 of the exact composed prompt argument proved present in the rendered prompt. */
-  requestedPromptSha256: string;
-  effectivePromptSha256: string;
-  nonPromptArgsSha256: string;
-  controlledConfigSha256: string;
-  /** Sorted normalized paths compiled into the permission profile. */
-  readDeniedPaths: string[];
-  readDeniedPathsSha256: string;
-  readDeniedPathCount: number;
-  policy: CodexExecutionPolicy;
-}
-//#endregion
-//#region src/mcp/local-harness-process.d.ts
-/** @experimental */
-interface RunLocalHarnessOptions {
-  harness: LocalHarness;
-  /** Working directory for the subprocess (typically a worktree path). */
-  cwd: string;
-  /** Prompt forwarded as the harness CLI's task argument. */
-  taskPrompt: string;
-  /**
-   * Pre-built command + args (e.g. from `harnessInvocation` so the full authored
-   * `AgentProfile` — systemPrompt + model — reaches the harness). When set it OVERRIDES the
-   * default prompt-only `buildArgs(taskPrompt)` path; `command` defaults to the harness's
-   * default binary when only `args` is supplied. When absent the legacy prompt-only shape
-   * is used unchanged.
-   */
-  invocation?: {
-    command?: string;
-    args: ReadonlyArray<string>;
-  };
-  /** Allow autonomous edits without an interactive approval gate, using whichever bypass argv the
-   *  harness declares. Use only when `cwd` is an isolated candidate worktree. */
-  dangerouslySkipPermissions?: boolean;
-  /** Isolate Codex from ambient configuration/instructions and require JSONL token usage.
-   *  The invocation should come from `harnessInvocation(..., { codexReproducible: true })`. */
-  codexReproducible?: boolean;
-  /** Absolute host paths that reproducible Codex must not read. The normalized set is compiled
-   *  into the controlled permission profile and its digest is returned in execution evidence. */
-  codexReadDeniedPaths?: ReadonlyArray<string>;
-  /** Optional wall-clock kill deadline (ms). Omit it for no timer. A positive value sends
-   *  SIGTERM on expiry. */
-  timeoutMs?: number;
-  /** Newest stdout/stderr bytes retained per stream. Default 64 MiB. */
-  maxOutputBytes?: number;
-  /** Caller cancellation. SIGTERM is sent on abort. */
-  signal?: AbortSignal;
-  /** Override env (defaults to inheriting from the parent). */
-  env?: NodeJS.ProcessEnv;
-  /**
-   * Test seam — inject a custom spawner so unit tests can mock the
-   * subprocess without touching the OS. Defaults to node's `child_process.spawn`.
-   */
-  spawn?: (command: string, args: ReadonlyArray<string>, opts: {
-    cwd: string;
-    env: NodeJS.ProcessEnv;
-    stdio: 'pipe';
-    detached: boolean;
-  }) => ChildProcess;
-  /** Test seam for locating the native Codex executable before it is staged in the worktree. */
-  resolveCodexExecutable?: (command: string, env: NodeJS.ProcessEnv) => Promise<string>;
-}
-/** @experimental */
-interface LocalHarnessResult {
-  /** OS exit code. `null` when killed before exit. */
-  exitCode: number | null;
-  /** Concatenated stdout. */
-  stdout: string;
-  /** Concatenated stderr. */
-  stderr: string;
-  /** Set when the process exited via signal (timeout / abort). */
-  killedBySignal: NodeJS.Signals | null;
-  /** Wall-clock duration ms (spawn → exit). */
-  durationMs: number;
-  /** Set when timeoutMs elapsed before exit. */
-  timedOut: boolean;
-  /**
-   * Set when the caller's AbortSignal fired before this result settled.
-   * Optional so injected runners and stored results from older releases remain valid.
-   */
-  aborted?: boolean;
-  /** Present for a reproducible Codex run; parsed from the real terminal JSONL event. */
-  usage?: CodexTokenUsage;
-  /** Present for reproducible Codex runs; generated and checked before model execution. */
-  evidence?: CodexExecutionEvidence;
-}
-/**
- * Spawn a local coding harness CLI as a subprocess + collect its output.
- *
- * NOT responsible for parsing the harness's output or extracting a diff —
- * the in-process executor's `streamPrompt` orchestrates `git diff` against
- * the worktree after this resolves. This function is intentionally narrow:
- * spawn, wait, capture, return.
- *
- * Fails loud — throws when:
- *   - `cwd` doesn't exist (subprocess emits ENOENT; surfaced as Error)
- *   - the harness binary is not on PATH (ENOENT)
- *   - the caller signal was already aborted before process launch
- *
- * Does NOT throw when:
- *   - the subprocess exits non-zero (`result.exitCode` carries the code)
- *   - a non-reproducible subprocess is aborted / timed out (`result.aborted` /
- *     `result.timedOut` carries the reason even when a TERM-aware child exits zero)
- *
- * Reproducible Codex additionally requires a terminal usage event. If cancellation
- * prevents that event, this rejects with `CodexExecutionDiagnosticError` instead of
- * returning an incomplete reproducibility receipt.
- *
- * @experimental
- */
-declare function runLocalHarness(options: RunLocalHarnessOptions): Promise<LocalHarnessResult>;
-//#endregion
 //#region src/mcp/worktree.d.ts
-/** @experimental */
-interface WorktreeHandle {
-  /** Absolute path to the worktree directory. */
-  path: string;
-  /** SHA the worktree was created at. */
-  baseSha: string;
-  /** Branch name created for this worktree (typically `delegate/<runId>`). */
-  branch: string;
-}
-/** @experimental */
-interface CreateWorktreeOptions {
-  /** Absolute path to the main git checkout. */
-  repoRoot: string;
-  /** Unique id for the worktree path + branch. Use the delegation run id. */
-  runId: string;
-  /** Parent directory the worktree lives under. Defaults to `.agent-worktrees`. */
-  variantsDir?: string;
-  /** Override the base ref (default `HEAD`). */
-  baseRef?: string;
-  /** Test seam — inject a custom git runner. */
-  runGit?: GitRunner;
-}
-/** @experimental */
-interface DiffOptions {
-  /** Worktree to diff. */
-  worktree: WorktreeHandle;
-  /** What to compare against. Default `worktree.baseSha`. */
-  baseRef?: string;
-  /**
-   * Repository-relative input paths to omit from the captured worker patch.
-   * Paths are passed to Git with literal exclusion magic, so profile-provided
-   * `*`, `?`, `[` and `:` characters can never expand into broader pathspecs.
-   */
-  excludePaths?: ReadonlyArray<string>;
-  /** Test seam. */
-  runGit?: GitRunner;
-}
-/** @experimental */
-interface DiffResult {
-  patch: string;
-  stats: {
-    filesChanged: number;
-    insertions: number;
-    deletions: number;
-  };
-}
-/** @experimental */
-interface RemoveWorktreeOptions {
-  worktree: WorktreeHandle;
-  repoRoot: string;
-  /** Force removal even if dirty (default true; the loser of a fanout has uncommitted changes). */
-  force?: boolean;
-  /** Test seam. */
-  runGit?: GitRunner;
-}
 /** Pluggable git runner (sync) — replaceable in tests. */
 type GitRunner = (args: ReadonlyArray<string>, opts: {
   cwd: string;
@@ -4381,16 +4088,6 @@ type GitRunner = (args: ReadonlyArray<string>, opts: {
   stderr: string;
   exitCode: number;
 };
-/** Checkout a fresh git worktree for a delegation run on a new branch under `variantsDir`. @experimental */
-declare function createWorktree(options: CreateWorktreeOptions): Promise<WorktreeHandle>;
-/** Stage worker changes and return the diff + shortstat, excluding declared input paths. @experimental */
-declare function captureWorktreeDiff(options: DiffOptions): Promise<DiffResult>;
-/**
- * Remove a git worktree and delete its branch. Already-removed paths are harmless; every other
- * Git failure rejects so callers cannot report a worktree as destroyed when cleanup failed.
- * @experimental
- */
-declare function removeWorktree(options: RemoveWorktreeOptions): Promise<void>;
 //#endregion
 //#region src/mcp/worktree-harness.d.ts
 /** Outcome of one verification command run in the worktree (test or typecheck). */
@@ -4551,10 +4248,6 @@ interface SanitizedKnowledgeReadinessReport {
 }
 /** Strip PII and large blobs from a `KnowledgeReadinessReport` for safe telemetry emission. @stable */
 declare function sanitizeKnowledgeReadinessReport(report: KnowledgeReadinessReport, options?: RuntimeTelemetryOptions): SanitizedKnowledgeReadinessReport;
-/** Reduce an `AgentRuntimeEvent` to a PII-safe, serializable plain object for telemetry. @stable */
-declare function sanitizeAgentRuntimeEvent<TState, TAction, TActionResult, TEval extends ControlEvalResult>(event: AgentRuntimeEvent<TState, TAction, TActionResult, TEval>, options?: RuntimeTelemetryOptions): Record<string, unknown>;
-/** Reduce a `RuntimeStreamEvent` to a PII-safe, serializable plain object for telemetry. @stable */
-declare function sanitizeRuntimeStreamEvent(event: RuntimeStreamEvent, options?: RuntimeTelemetryOptions): Record<string, unknown>;
 /** @stable */
 interface RuntimeEventCollector<TState = unknown, TAction = unknown, TActionResult = unknown, TEval extends ControlEvalResult = ControlEvalResult> {
   onEvent: (event: AgentRuntimeEvent<TState, TAction, TActionResult, TEval>) => void;
@@ -4672,26 +4365,6 @@ interface OtelAttribute {
     boolValue?: boolean;
   };
 }
-/**
- * Create an exporter that APPENDS spans to a local OpenInference-JSONL file, one complete span per
- * line, instead of posting them to a collector.
- *
- * Why this exists beside {@link createOtelExporter}: that one needs an OTLP endpoint, so a run on a
- * laptop, in CI, or inside a sandbox with no collector emits nothing and its per-turn shape is
- * simply lost. The journal records the TREE (who spawned whom, what settled, what it spent); it
- * does not record what happened inside a turn. A run whose tree is readable but whose turns are not
- * is exactly the state that made an observability gap invisible until someone went looking.
- *
- * The line shape is the one `@tangle-network/traces` reads (`spans.otlp.jsonl`) and is a standard
- * OpenInference representation, so the same file feeds any OpenInference tool with no conversion:
- * snake_case identity fields, ISO-8601 times, `parent_span_id` empty at the root, and attributes as
- * a plain object rather than OTLP's key/value array.
- *
- * Appends synchronously per span so a killed process keeps every span it had already finished —
- * matching the spawn journal's durability posture, since a trace that only survives a clean exit is
- * useless for the runs you most want to look at.
- */
-declare function createOpenInferenceFileExporter(filePath: string): OtelExporter;
 /**
  * Create an OTLP/HTTP exporter. Returns undefined when no endpoint is configured.
  *
@@ -4699,7 +4372,7 @@ declare function createOpenInferenceFileExporter(filePath: string): OtelExporter
  * `maxQueueSize`. Every span ends in exactly one of `written` or `dropped`: a non-2xx response, a
  * network error, a timeout, an OTLP `partialSuccess.rejectedSpans` count and a full queue each count
  * as drops and set `lastError`. Nothing here throws into the caller's run; `flush()` reports the
- * loss, the same rule {@link createOpenInferenceFileExporter} follows.
+ * loss, the same rule `createOpenInferenceFileExporter` follows.
  */
 declare function createOtelExporter(config?: OtelExportConfig): OtelExporter | undefined;
 /**
@@ -4711,31 +4384,6 @@ declare function loopEventToOtelSpan(event: {
   timestamp: number;
   payload: object;
 }, traceId: string, parentSpanId?: string): OtelSpan;
-interface RuntimeEventOtelOptions extends RuntimeTelemetryOptions {
-  /** Final customer redactor applied after the schema-aware runtime sanitizer. */
-  redact?: (value: unknown) => unknown;
-}
-/** Convert normalized runtime events into lossless, redacted child spans. */
-declare function buildRuntimeEventOtelSpans(events: ReadonlyArray<RuntimeStreamEvent>, traceId: string, parentSpanId?: string, options?: RuntimeEventOtelOptions): OtelSpan[];
-/**
- * Sink-neutral node in a reconstructed loop span tree. The root node's
- * `parentSpanId` is `undefined` — sinks decide how to parent it (the OTEL
- * mapper attaches the inherited delegation span; the delegation journal
- * leaves it as the tree root).
- */
-interface LoopSpanNode {
-  spanId: string;
-  parentSpanId?: string;
-  /** `'loop'` | `'loop.round'` | `'loop.iteration'`. */
-  name: string;
-  /** Topology level: loop root, plan round, or iteration branch. */
-  kind: 'loop' | 'round' | 'branch';
-  startMs: number;
-  endMs: number;
-  attrs: Record<string, string | number | boolean>;
-  /** True when the iteration carried an error — maps to OTEL status code 2. */
-  error: boolean;
-}
 /**
  * Build a nested, real-duration OTLP span tree for ONE loop run from its full
  * ordered `LoopTraceEvent` stream. Unlike `loopEventToOtelSpan` (one flat,
@@ -4758,27 +4406,6 @@ declare function buildLoopOtelSpans(events: ReadonlyArray<{
   timestamp: number;
   payload: object;
 }>, traceId: string, rootParentSpanId?: string, redact?: (value: unknown) => unknown): OtelSpan[];
-/**
- * Sink-neutral core behind {@link buildLoopOtelSpans}: reconstruct the
- * loop → round → branch span tree from one run's ordered `LoopTraceEvent`
- * stream. Consumed by the OTEL mapper above and by the MCP delegation
- * journal's compact trace tee — one topology reconstruction, two sinks.
- * Tolerates partial streams (a run that never reached `loop.ended` closes
- * at the last observed event's timestamp).
- */
-declare function buildLoopSpanNodes(events: ReadonlyArray<{
-  kind: string;
-  runId: string;
-  timestamp: number;
-  payload: object;
-}>, redact?: (value: unknown) => unknown): LoopSpanNode[];
-/**
- * Convert a flat record into the OTLP attribute list. Non-finite numbers are DROPPED (an OTLP
- * `doubleValue` of `NaN`/`Infinity` is not representable), integers ride as `intValue`. Exported so
- * a producer that mints its own `OtelSpan` (the supervisor span recorder) builds attributes exactly
- * the way every span in this file does, rather than re-deriving the encoding.
- */
-declare function toOtelAttributes(record: Record<string, string | number | boolean>): OtelAttribute[];
 /**
  * Map a caller-supplied span id onto the 16-hex OTLP encoding. An id that is already a valid W3C
  * span id passes through UNCHANGED — that is what lets an inherited `PARENT_SPAN_ID`/`TRACEPARENT`
@@ -4796,10 +4423,6 @@ declare function padSpanId(id: string): string;
  *  UUID-form, preserving the pre-strict-W3C wire id), everything else is derived with
  *  `deriveHexId(id, 16)` so every process derives the SAME wire id for the same run. */
 declare function padTraceId(id: string): string;
-/** Mint a fresh 16-hex-character OTLP span id. Exported so a producer that must know a span's id
- *  BEFORE the span closes (a node opened at spawn and parented by its children) uses this one
- *  generator instead of a second copy of it. */
-declare function generateSpanId(): string;
 //#endregion
 //#region src/runtime/sandbox-evidence-retention.d.ts
 /** One durable capture before a Sandbox box is removed. */
@@ -4838,13 +4461,6 @@ interface SandboxEvidenceReceipt {
   readonly coverageComplete: boolean;
   readonly incompleteReason?: string;
 }
-/** A failed capture keeps the live source handle available for an explicit retry. */
-declare class SandboxEvidenceRetentionError extends Error {
-  readonly box: SandboxInstance;
-  constructor(box: SandboxInstance, cause: unknown);
-}
-/** Capture, verify, durably record, then destroy. A failure leaves the source intact. */
-declare function captureBeforeDestroy(port: SandboxEvidenceRetentionPort, context: SandboxEvidenceContext, destroy: () => Promise<void>): Promise<SandboxEvidenceReceipt>;
 //#endregion
 //#region src/runtime/agent-rounds.d.ts
 /** @stable */
@@ -5232,8 +4848,6 @@ interface RunCodeModeOptions extends CodeModeOptions {
   /** An explicit snapshot from the caller's existing state owner. */
   readonly store?: CodeModeStore;
 }
-/** Render the same tool descriptors that are executed, including their result schemas. */
-declare function describeCodeModeTools(tools: ReadonlyArray<CodeModeTool>, query?: string): Promise<string>;
 /**
  * Execute a JS async-function body against Runtime capabilities. The upstream
  * QuickJS/WASM worker is the boundary; there is no node:vm or unsafe fallback.
@@ -5615,8 +5229,6 @@ interface CoderTask {
   /** Default 400. Hard cap; the gate hard-fails when exceeded. */
   maxDiffLines?: number;
 }
-/** Render a `CoderTask` into the per-task instruction handed to the coder profile. @experimental */
-declare function coderTaskToPrompt(task: CoderTask): string;
 //#endregion
 //#region src/mcp/detached-coder.d.ts
 /** @experimental The structured coder result the sandbox-session path decodes + gates. */
@@ -5664,21 +5276,6 @@ interface DelegationStore {
   /** Delete the named records — the retention-cap eviction path. */
   remove(taskIds: readonly string[]): Promise<void>;
 }
-/**
- * The persisted delegation state exists but cannot be parsed into
- * records. Fail loud: silently starting empty over a corrupt journal
- * would erase delegation history and re-run idempotent work. Opt into
- * recovery explicitly via `FileDelegationStoreOptions.recoverCorrupt`
- * (the bin maps `AGENT_RUNTIME_DELEGATION_STATE_RECOVER=1` onto it),
- * which archives the corrupt file and starts fresh.
- *
- * @stable
- */
-declare class DelegationStateCorruptError extends AgentEvalError$1 {
-  constructor(message: string, options?: {
-    cause?: unknown;
-  });
-}
 /**
  * A delegation-store read or write failed (filesystem error, store
  * called before `loadAll`, ...). Once the queue observes one, it stops
@@ -5692,14 +5289,6 @@ declare class DelegationPersistenceError extends AgentEvalError$1 {
     cause?: unknown;
   });
 }
-/** In-memory `DelegationStore` — suitable for single-process use and tests. @stable */
-declare class InMemoryDelegationStore implements DelegationStore {
-  private readonly records;
-  loadAll(): Promise<DelegationRecord[]>;
-  upsert(record: DelegationRecord): Promise<void>;
-  lookupIdempotencyKey(key: string): Promise<string | undefined>;
-  remove(taskIds: readonly string[]): Promise<void>;
-}
 /** @stable */
 interface FileDelegationStoreOptions {
   /** Absolute path of the JSON state file. Parent directories are created on first write. */
@@ -5763,64 +5352,11 @@ interface DelegationTraceSpan {
   endMs: number;
   meta?: Record<string, string | number | boolean>;
 }
-/** Default cap on spans retained per delegation record. @experimental */
-declare const DELEGATION_TRACE_MAX_SPANS = 512;
-/** Default cap on the serialized trace payload per record, in bytes. @experimental */
-declare const DELEGATION_TRACE_MAX_BYTES: number;
-/** @experimental */
-interface DelegationTraceCaps {
-  /** Default {@link DELEGATION_TRACE_MAX_SPANS}. */
-  maxSpans?: number;
-  /** Default {@link DELEGATION_TRACE_MAX_BYTES}. Approximate — measured as the
-   *  sum of per-span `JSON.stringify` lengths. */
-  maxBytes?: number;
-}
-/** @experimental */
-interface CappedDelegationTrace {
-  trace: DelegationTraceSpan[];
-  /** True when oldest spans were dropped to honor the caps. */
-  truncated: boolean;
-}
 /**
- * Derive the compact span tree for ONE loop run from its buffered
- * `LoopTraceEvent` stream. Same reconstruction as the OTEL exporter
- * ({@link buildLoopSpanNodes}); tolerates partial streams.
- *
- * @experimental
- */
-declare function buildDelegationTraceSpans(events: ReadonlyArray<LoopTraceEvent>): DelegationTraceSpan[];
-/**
- * Enforce the trace caps over an ordered (oldest-first) span list. Drops the
- * OLDEST spans first and reports `truncated: true` when anything was dropped;
- * the newest span always survives, so a non-empty input never caps to empty.
- * Dropping a parent may orphan surviving children's `parentSpanId` references
- * — acceptable for the flat journal shape; consumers treat unresolved parents
- * as roots.
- *
- * @experimental
- */
-declare function capDelegationTrace(spans: ReadonlyArray<DelegationTraceSpan>, caps?: DelegationTraceCaps): CappedDelegationTrace;
-/**
- * Per-delegation trace collector. Buffers `LoopTraceEvent`s per runId
- * (mirroring the OTEL emitter's buffering) and hands the derived compact
- * spans to `onSpans` when a run reaches `loop.ended`. `settle()` drains runs
- * that never ended — a hard-aborted loop still leaves its partial tree in the
- * journal, unlike the OTEL path which drops it.
- *
- * @experimental
- */
-interface DelegationTraceCollector {
-  emitter: LoopTraceEmitter;
-  /** Flush buffered events of runs that never reached `loop.ended`. */
-  settle(): void;
-}
-/** Build a `DelegationTraceCollector` that buffers loop-trace events and converts them to spans on settle. @experimental */
-declare function createDelegationTraceCollector(onSpans: (spans: DelegationTraceSpan[]) => void): DelegationTraceCollector;
-/**
- * Fan one `LoopTraceEvent` stream into several emitters — e.g. the
- * process-wide OTEL exporter AND the per-delegation journal collector.
- * `undefined` entries are skipped; returns `undefined` when nothing is left
- * so callers keep the kernel's "no emitter, no events" fast path.
+ * Fan one `LoopTraceEvent` stream into several emitters — e.g. the
+ * process-wide OTEL exporter AND the per-delegation journal collector.
+ * `undefined` entries are skipped; returns `undefined` when nothing is left
+ * so callers keep the kernel's "no emitter, no events" fast path.
  *
  * @experimental
  */
@@ -5855,29 +5391,6 @@ declare function createPropagatingTraceEmitter(ctx: TraceContext): {
   exporter: OtelExporter | undefined;
   context: TraceContext;
 };
-/**
- * Build env vars to pass to a child subprocess so it inherits the current trace context.
- *
- * Writes BOTH conventions (see the module doc): `TRACEPARENT` carries the W3C-hex ids — mapped
- * through the exporter's own `padTraceId`/`padSpanId` (dashed hex passes through dash-stripped, a
- * human id is derived through the contract's `deriveHexId`), the SAME normalization every emitted
- * span uses, so both spellings and the parent's own spans all name ONE trace — and the legacy
- * pair carries the caller's ids verbatim. `TRACEPARENT` needs a parent span id by grammar; when
- * the context has none, the legacy pair still propagates the trace id alone.
- */
-declare function traceContextToEnv(ctx: TraceContext): Record<string, string>;
-/**
- * Merge a spawned child's environment from lowest to highest precedence — ambient env, the
- * recorder's stamped trace env, the caller's own overrides — while keeping the ONE cross-key
- * invariant a plain spread cannot: `TRACEPARENT` and the legacy pair must name the SAME trace.
- * A caller override that declares `TRACE_ID` / `PARENT_SPAN_ID` without its own `TRACEPARENT`
- * would otherwise keep the recorder's W3C wire — the child would join the caller's trace on the
- * legacy pair and the RECORDER's on the standard one. The dual-write is performed on the
- * caller's behalf: the merged `TRACEPARENT` is rebuilt from the merged legacy pair through the
- * same {@link traceContextToEnv} derivation (`deriveHexId` for human ids), or dropped when no
- * parent span id survives the merge (the W3C grammar requires one).
- */
-declare function mergeTraceEnv(ambient: Record<string, string | undefined>, traceEnv: Record<string, string>, overrides?: Record<string, string>): Record<string, string | undefined>;
 //#endregion
 //#region src/profiles/researcher.d.ts
 /** Source families a researcher profile may prefer for a task. One owner: the delegation
@@ -5998,51 +5511,6 @@ declare function researcherProfile(options: ResearcherProfileOptions & {
   validator: Validator<ResearchOutput>;
   agentRunSpec: AgentRunSpec<ResearchTask>;
 };
-/** @experimental */
-interface MultiHarnessResearcherFanoutOptions {
-  /** Exact execution profiles, one per parallel researcher. */
-  profiles: ReadonlyArray<AgentProfile>;
-  /** Default citation density floor for the shared validator. */
-  citationDensityMin?: number;
-  /** Optional task — narrows the validator's namespace check. */
-  task?: ResearchTask;
-}
-/**
- * Build a fanout topology over multiple harnesses. The kernel round-robins
- * `agentRuns` across the N parallel iterations and the `FanoutVote` driver
- * picks the highest-scoring valid output.
- *
- * @experimental
- */
-declare function multiHarnessResearcherFanout(options: MultiHarnessResearcherFanoutOptions): {
-  agentRuns: AgentRunSpec<ResearchTask>[];
-  output: OutputAdapter<ResearchOutput>;
-  validator: Validator<ResearchOutput>;
-  driver: Driver<ResearchTask, ResearchOutput, 'done'>;
-};
-/**
- * Build a validator that closes over a specific `ResearchTask`'s constraints.
- *
- * Checks in order:
- *   1. Items must be non-empty.
- *   2. Every item carries `evidence.length >= 1`.
- *   3. Every item + proposedWrite is scoped to `task.knowledgeNamespace`
- *      (hard-fail on any namespace mismatch — defence in depth for the
- *      multi-tenant invariant).
- *   4. Citation density (citations with quote / items) >= floor.
- *
- * Aggregate score:
- *   0.4 · citation_density
- * + 0.2 · source_diversity (distinct sources / max(items, 1))
- * + 0.2 · recency_match (mean fraction within `recencyWindow`)
- * + 0.2 · (1 − gaps/maxGaps), maxGaps = max(items, 1)
- *
- * @experimental
- */
-declare function createResearcherValidator(task: ResearchTask, config?: {
-  citationDensityMin?: number;
-  namespaceCheck?: boolean;
-}): Validator<ResearchOutput>;
 //#endregion
 //#region src/profiles/ui-auditor/substrate.d.ts
 /**
@@ -6065,8 +5533,6 @@ declare function createResearcherValidator(task: ResearchTask, config?: {
  * under a generic label.
  */
 type UiLens = 'consistency' | 'hierarchy' | 'layout' | 'ux-flow' | 'duplication' | 'accessibility' | 'responsive' | 'states' | 'content' | 'interaction' | 'performance-perceived' | 'other';
-/** Frozen tuple of lenses for validation + iteration. */
-declare const UI_LENSES: readonly UiLens[];
 /**
  * Severity scale.
  *   - `critical` — blocks a core task or is an accessibility blocker.
@@ -6075,8 +5541,6 @@ declare const UI_LENSES: readonly UiLens[];
  *   - `low`      — nitpick worth fixing eventually.
  */
 type UiFindingSeverity = 'low' | 'med' | 'high' | 'critical';
-/** Frozen severity tuple, ordered worst → least bad for sort/report. */
-declare const UI_FINDING_SEVERITIES: readonly UiFindingSeverity[];
 /** Pointer to a screenshot referenced by a finding (workspace-relative path). */
 interface UiFindingScreenshot {
   path: string;
@@ -6166,12 +5630,6 @@ interface DelegateCodeArgs {
   namespace?: string;
 }
 /** @experimental */
-interface DelegateCodeResult {
-  taskId: string;
-  /** Best-effort hint — coder loops can take minutes-to-hours. */
-  estimatedDurationMs?: number;
-}
-/** @experimental */
 interface DelegateResearchConfig {
   recencyWindow?: {
     since?: string;
@@ -6190,11 +5648,6 @@ interface DelegateResearchArgs {
   config?: DelegateResearchConfig;
 }
 /** @experimental */
-interface DelegateResearchResult {
-  taskId: string;
-  estimatedDurationMs?: number;
-}
-/** @experimental */
 interface FeedbackRefersTo {
   kind: 'delegation' | 'artifact' | 'outcome';
   /** For `'delegation'`, this is the taskId. */
@@ -6217,22 +5670,6 @@ interface DelegateFeedbackArgs {
   namespace?: string;
 }
 /** @experimental */
-interface DelegateFeedbackResult {
-  recorded: true;
-  id: string;
-}
-/** @experimental */
-interface DelegationStatusArgs {
-  taskId: string;
-  /**
-   * Return the delegation's compact loop-trace span tree alongside the
-   * status. Default false — status polls stay light; opt in when you need
-   * the topology (which iterations ran, where they were placed, what each
-   * cost) rather than just the state machine.
-   */
-  includeTrace?: boolean;
-}
-/** @experimental */
 interface DelegationProgress {
   iteration: number;
   phase: string;
@@ -6317,11 +5754,6 @@ interface DelegateUiAuditArgs {
   namespace?: string;
   config?: DelegateUiAuditConfig;
 }
-/** @experimental */
-interface DelegateUiAuditResult {
-  taskId: string;
-  estimatedDurationMs?: number;
-}
 /**
  * Provider-neutral research output carried over the MCP boundary. The MCP
  * layer accepts this structural shape instead of coupling its wire contract to
@@ -6395,10 +5827,6 @@ interface DelegationHistoryEntry {
   /** Inherited trace identity recorded at submit — join key into the caller's trace. */
   traceId?: string;
 }
-/** @experimental */
-interface DelegationHistoryResult {
-  delegations: DelegationHistoryEntry[];
-}
 //#endregion
 //#region src/mcp/task-queue.d.ts
 /** Arguments accepted by the durable delegation queue. @stable */
@@ -6675,73 +6103,8 @@ declare class DelegationTaskQueue {
   private failPersistence;
   private enforceRetention;
 }
-/**
- * Best-effort stable hash for use as `idempotencyKey`. Not cryptographic;
- * collisions only affect dedupe, never correctness.
- *
- * @stable
- */
-declare function hashIdempotencyInput(value: unknown): string;
 //#endregion
 //#region src/mcp/detached-turn.d.ts
-/**
- * Structural mirror of the sandbox SDK's `TurnDriveResult` (>= 0.6).
- * Discriminated on `state`; `failed` is terminal and deterministic per the
- * SDK contract — re-invoking with the same ids returns the same outcome.
- *
- * @experimental
- */
-type DriveTurnTick = {
-  state: 'completed';
-  text: string;
-  result: Record<string, unknown>;
-} | {
-  state: 'running';
-  startedAt?: Date;
-  elapsedMs?: number;
-} | {
-  state: 'failed';
-  error: string;
-};
-/**
- * The box surface detached turns need. `SandboxInstance`
- * (`@tangle-network/sandbox` >= 0.6) satisfies it structurally; tests pass
- * in-memory fakes. `_sessionCancel` is the SDK's remote-cancellation surface —
- * optional here because older SDKs / fakes may not expose it; when present it
- * is invoked on abort so the remote run actually stops.
- *
- * @experimental
- */
-interface DriveTurnCapableBox {
-  driveTurn(message: string, opts: {
-    sessionId: string;
-    turnId?: string;
-    wallCapMs?: number;
-  }): Promise<DriveTurnTick>;
-  _sessionCancel?(id: string): Promise<void>;
-}
-/**
- * Decoded `DelegationRecord.detachedSessionRef`. `sandboxId` is absent between
- * submit and box acquisition — a record restored in that window is not
- * resumable (there is no box to resume on) and the resume driver fails it
- * loud rather than dispatching onto a guessed box.
- *
- * @experimental
- */
-interface DetachedSessionRefParts {
-  sessionId: string;
-  sandboxId?: string;
-}
-/**
- * Encode ref parts into the JSON-safe string stored on the record:
- * `session=<id>` before the box exists, `sandbox=<id>;session=<id>` once
- * bound. Ids must not contain the `;`/`=` delimiters.
- *
- * @experimental
- */
-declare function formatDetachedSessionRef(parts: DetachedSessionRefParts): string;
-/** Parse a `detachedSessionRef` string back to parts; throws `ValidationError` on malformed input. @experimental */
-declare function parseDetachedSessionRef(raw: string): DetachedSessionRefParts;
 /** @experimental The terminal payload of a finished detached turn. */
 interface DetachedTurn {
   /** Final assistant text. */
@@ -6749,15 +6112,6 @@ interface DetachedTurn {
   /** The SDK's cached AgentExecutionResult-shape record for the turn. */
   result: Record<string, unknown>;
 }
-/**
- * Synthesize the terminal event array a detached turn settles through. Shaped
- * so the existing event-stream output adapters (coder, researcher) parse it:
- * `data.result` for adapters that read a structured terminal record, `data.text`
- * for adapters that scan assistant text for the fenced result block.
- *
- * @experimental
- */
-declare function detachedTurnEvents(sessionId: string, turn: DetachedTurn): SandboxEvent[];
 /** @experimental */
 interface RunDetachedTurnOptions {
   /** Sandbox client used to acquire the box (the delegate's executor client). */
@@ -6804,55 +6158,6 @@ interface RunDetachedTurnOptions {
  * @experimental
  */
 declare function runDetachedTurn(options: RunDetachedTurnOptions): Promise<DetachedTurn>;
-/** @experimental */
-interface DetachedTurnResumeDriverOptions {
-  /**
-   * Resolve the live box owning a detached session. The bin wires this to the
-   * sandbox client's `get(sandboxId)`; throw when the box no longer exists —
-   * a thrown tick settles the record as failed, which is the truth.
-   */
-  resolveSandbox(sandboxId: string): Promise<DriveTurnCapableBox>;
-  /**
-   * Rebuild the turn prompt from the persisted record. Only consumed by
-   * `driveTurn`'s dispatch leg — i.e. when the previous process died after
-   * binding the box but before the session was dispatched. Must reproduce the
-   * prompt the delegate would have sent.
-   */
-  buildMessage(record: DelegationRecord): string;
-  /**
-   * Map a completed turn onto the delegation's typed output payload (parse +
-   * validate per profile). Throw when the resumed result does not pass the
-   * profile's gate — the queue settles the record as failed with that error.
-   */
-  settleOutput(turn: DetachedTurn, record: DelegationRecord, ctx: {
-    signal: AbortSignal;
-  }): Promise<DelegationResultPayload['output']> | DelegationResultPayload['output'];
-  /** Delay between `running` ticks (ms). Default 5000. */
-  intervalMs?: number;
-  /** Wall-clock cap forwarded to `driveTurn` on every tick. */
-  wallCapMs?: number;
-}
-/**
- * Build the `driveTurn`-backed {@link DelegationResumeDriver}. Each `tick()`
- * is one settle/poll/dispatch pass:
- *
- *   - ref without a sandbox binding → `failed` (`DetachedSessionUnboundError`):
- *     the previous process died before a box existed; there is nothing to resume.
- *   - `driveTurn` `completed` → `settleOutput` → `completed` tick.
- *   - `running` → progress via `ctx.report`, `running` tick (queue re-ticks
- *     after `intervalMs`).
- *   - `failed` → `failed` tick (`DetachedTurnFailedError`) — terminal per the
- *     SDK's deterministic-failure contract.
- *
- * Abort: the queue stops ticking once `cancel()` flips the record, so remote
- * cancellation is hooked onto `ctx.signal` (once per task) and fires
- * `_sessionCancel` when the SDK surface exposes it. The driver never deletes
- * boxes — it cannot know whether `sandboxId` is a disposable sibling or a
- * fleet machine, and destroying a fleet machine would be unrecoverable.
- *
- * @experimental
- */
-declare function createDetachedTurnResumeDriver(options: DetachedTurnResumeDriverOptions): DelegationResumeDriver;
 //#endregion
 //#region src/mcp/executor.d.ts
 /** @experimental */
@@ -7061,40 +6366,6 @@ interface DetachedSessionDelegateOptions {
  * @experimental
  */
 declare function detachedSessionDelegate(options: DetachedSessionDelegateOptions): CoderDelegate;
-/**
- * Canonical `DelegateCodeArgs` → `CoderTask` mapping — the single source for
- * the delegate's live dispatch AND the resume driver's settle/message
- * rebuilding, so a resumed record reproduces exactly the task the original
- * process dispatched.
- *
- * @experimental
- */
-declare function coderTaskFromArgs(args: DelegateCodeArgs): CoderTask;
-/** @experimental */
-interface SettleDetachedCoderTurnOptions {
-  task: CoderTask;
-  /** Session id of the detached turn — used as the synthesized event id. */
-  sessionId: string;
-  signal: AbortSignal;
-  /** Same gate as the streaming path: an unapproved candidate cannot win. */
-  reviewer?: CoderReviewer;
-}
-/**
- * Settle a completed detached coder turn through the same gate the streaming
- * path applies: parse the terminal payload with the coder output adapter,
- * run the mechanical validator (tests/typecheck/forbidden/diff/no-op/secrets),
- * then the optional reviewer. Throws when nothing survives — a resumed or
- * detached run must not return an unvalidated patch.
- *
- * SCOPE NOTE (detached/resume): the detached `driveTurn`-tick + cross-restart resume path is
- * bound to the `runAgentRounds` + sandbox-session substrate. The recursive `Scope`/worktree-CLI leaf has
- * journal→replay but no driveTurn-over-a-detached-sandbox-session equivalent yet, so resume is NOT
- * advertised on the generic `worktreeFanout` path. This helper (with `coderTaskFromArgs` and
- * `createDetachedTurnResumeDriver`) stays as the resume seam `bin.ts` wires for in-flight records.
- *
- * @experimental
- */
-declare function settleDetachedCoderTurn(turn: DetachedTurn, options: SettleDetachedCoderTurnOptions): Promise<CoderOutput>;
 //#endregion
 //#region src/mcp/feedback-store.d.ts
 /** @stable */
@@ -7119,22 +6390,6 @@ interface FeedbackStore {
     refersToRef?: string;
   }): Promise<FeedbackEvent[]>;
 }
-/** In-memory `FeedbackStore` — suitable for single-process use and tests. @stable */
-declare class InMemoryFeedbackStore implements FeedbackStore {
-  private readonly events;
-  put(event: FeedbackEvent): Promise<void>;
-  list(filter?: {
-    namespace?: string;
-    refersToRef?: string;
-  }): Promise<FeedbackEvent[]>;
-}
-/**
- * Project a `FeedbackEvent` down to the snapshot shape carried on
- * `delegation_history` entries.
- *
- * @stable
- */
-declare function eventToSnapshot(event: FeedbackEvent): DelegationFeedbackSnapshot;
 //#endregion
 //#region src/runtime/tool-loop.d.ts
 /** Provider-neutral conversation record accepted by a tool-loop brain. */
@@ -7352,32 +6607,6 @@ interface SandboxServedBackend {
   readonly model?: string;
   readonly source?: string;
 }
-/**
- * Read the served execution identity off one Sandbox event.
- *
- * The platform reports `effectiveBackend` on `execution.started` and again on the terminal
- * event (`@tangle-network/sandbox`, `EffectiveBackend`). Absence returns `undefined`
- * and must stay unknown — a request is not a receipt, so nothing here may be inferred from
- * what was asked for.
- */
-declare function sandboxEventServedBackend(event: SandboxEvent): SandboxServedBackend | undefined;
-/**
- * Fail the execution when the platform reports serving a model other than the exact one asked for.
- *
- * Measured motive (agent-runtime#892, live infrastructure 2026-08-17): 6 of 6 boxes whose profile
- * declared `zai-coding-plan/glm-5.2` reported
- * `{"provider":"openai-compat","model":"deepseek/deepseek-v4-flash","source":"environment"}`,
- * while the materialization receipt recorded the declared model as `status: "known"`. Sending
- * `backend.model` makes that substitution unlikely; only reading the report back makes it
- * detectable. A run that cannot say which model produced its evidence must not settle as one
- * that can.
- *
- * Silent when the platform reports no served model: unobserved stays unobserved.
- */
-declare function assertSandboxServedModel(event: SandboxEvent, expected: {
-  readonly provider?: string;
-  readonly model?: string;
-} | undefined): void;
 /**
  * Extract a `RuntimeStreamEvent`-shaped `llm_call` from a sandbox event when
  * the event carries usage/cost data. Returns `undefined` for non-cost events
@@ -7434,9 +6663,6 @@ interface SandboxUsageLedger {
     type: 'llm_call';
   }) | undefined;
 }
-/** A {@link SandboxUsageLedger} for one worker. Pass the worker's harness to decode with that
- *  harness's adapter; omit it to try every registered adapter. */
-declare function createSandboxUsageLedger(harness?: HarnessType): SandboxUsageLedger;
 /**
  * Sum the token usage + USD cost of a sandbox turn's events — the one honest way to meter an
  * `openSandboxRun` cell. Folds a {@link SandboxUsageLedger} over the stream, so it reads usage off
@@ -7548,20 +6774,6 @@ declare function mapSandboxToolEvent(event: SandboxEvent, state: SandboxToolPart
 declare function mapSandboxEvent(event: SandboxEvent, opts?: {
   agentRunName?: string;
 }): RuntimeStreamEvent | undefined;
-/**
- * Project one `SandboxEvent` onto Runtime's executor progress vocabulary: incremental text and
- * reasoning, tool calls and results, and an interaction request. It composes the existing
- * projections ({@link mapSandboxEvent}, {@link mapSandboxToolEvent}, and the canonical Agent
- * Interface decode) so every sandbox-shaped executor publishes live output through one reader.
- * Usage-bearing events project to nothing here — accounting stays on the `tokens`/`cost`
- * channels.
- *
- * Pass one {@link SandboxToolPartState} per turn so a multi-frame tool call yields one call and
- * at most one result.
- *
- * @experimental
- */
-declare function sandboxProgressEvents(event: SandboxEvent, state: SandboxToolPartState): ExecutorProgressEvent[];
 /**
  * What a settled turn produced, as an explicit marker.
  *
@@ -7769,17 +6981,6 @@ interface BridgeModelCredential {
   provider: KeyProvider;
 }
 //#endregion
-//#region src/runtime/supervise/cli-executor-factories.d.ts
-/** Executor factory for a CLI harness that runs in a git worktree of the caller's checkout. */
-declare const cliWorktreeExecutor: ExecutorFactory<unknown>;
-/**
- * The leaf `createInPlaceCliExecutor` as a backend-as-data factory: a supervisor-authored
- * `AgentProfile` driving a local coding CLI in the workspace the caller supplied, so its edits are
- * still there for the next spawn. `budgetExempt` like the other CLI leaves; the authored
- * systemPrompt + model reach the harness via §1.5.
- */
-declare const cliInPlaceExecutor: ExecutorFactory<unknown>;
-//#endregion
 //#region src/runtime/provider-placement.d.ts
 /** Caller-declared execution placement. Matching never changes the authored profile.
  * @experimental */
@@ -7957,41 +7158,6 @@ declare const ROUTER_CLIENT_HEADER = "x-tangle-client";
  * a new record: the row whose `clientName` is `agent-runtime-node/<nodeId>` is that node's spend.
  */
 declare function sharedWorkerClientName(nodeId: string): string;
-/** The Sandbox box surface a shared box uses. The Sandbox SDK's `SandboxInstance` satisfies it. */
-interface SharedBoxHandle {
-  readonly id: string;
-  exec(command: string, options?: {
-    timeoutMs?: number;
-  }): Promise<{
-    exitCode?: number | null;
-    stdout?: string;
-    stderr?: string;
-  }>;
-  readonly fs: {
-    read(path: string): Promise<string>;
-    write(path: string, content: string): Promise<unknown>;
-  };
-  readonly process: {
-    spawnExact(executable: string, args: readonly string[], options?: {
-      cwd?: string;
-      env?: Record<string, string>;
-      timeoutMs?: number;
-    }): Promise<SharedBoxProcess>;
-    list(): Promise<ReadonlyArray<{
-      pid: number;
-      command?: string;
-      cwd?: string;
-    }>>;
-    get(pid: number): Promise<SharedBoxProcess | null>;
-  };
-  delete(): Promise<unknown>;
-}
-/** One process in a shared box, as the Sandbox SDK's process manager returns it. */
-interface SharedBoxProcess extends Pick<Process, 'pid' | 'wait' | 'stdout' | 'stderr'> {
-  kill(signal?: 'SIGTERM' | 'SIGKILL', options?: {
-    tree?: boolean;
-  }): Promise<void>;
-}
 /**
  * Why a shared box cannot carry `profile`, or `undefined` when it can.
  *
@@ -8102,20 +7268,6 @@ interface SharedBoxPlacement {
 declare function sharedBoxPlacement(options: SharedBoxPlacementOptions): SharedBoxPlacement;
 //#endregion
 //#region src/runtime/supervise/inbox.d.ts
-/** The one terminal answer an inbox gives the sender of a message. `messageId` is the wire
- *  `messageId` when the sender named one. `closed` failures come from {@link Inbox.failPending};
- *  a holder that can still reach the recipient another way (a manager's durable lead queue) may
- *  re-route on that cause instead of reporting the failure. */
-type InboxReceipt = {
-  readonly status: 'consumed';
-  readonly messageId: string;
-  readonly attemptId: string;
-} | {
-  readonly status: 'failed';
-  readonly messageId: string;
-  readonly reason: string;
-  readonly cause: 'closed' | 'promoted-attempt-failed';
-};
 /** A message from the run's AUTHORITY — the parent driver. These two kinds carry instruction. */
 interface AuthorityInboxMessage {
   /** The sender's `messageId`, or one minted on arrival. What {@link InboxLease.commit} names. */
@@ -8172,8 +7324,6 @@ interface Inbox {
   /** Render taken messages as ONE operator turn to fold into the worker's conversation. */
   fold(messages: ReadonlyArray<InboxMessage>): string;
 }
-/** Create the worker-side inbox for the down-leg: the driver's `steer_agent` / `answer_question` messages and a sibling's peer mail queue here, and the worker's loop leases them at step boundaries and before settle. */
-declare function createInbox(): Inbox;
 //#endregion
 //#region src/runtime/supervise/sandbox-session.d.ts
 /** Ceiling on continuation turns. Turn 0 is the task; every later turn is a folded steer, so
@@ -8526,33 +7676,6 @@ declare function createExecutor(config: ExecutorConfig): ExecutorFactory<unknown
 declare function createExecutorRegistry(): ExecutorRegistry;
 //#endregion
 //#region src/mcp/tools/delegate.d.ts
-/** MCP tool name for the `delegate` generic-delegation tool. @stable */
-declare const DELEGATE_TOOL_NAME = "delegate";
-/** Human-readable description of the `delegate` MCP tool, injected into the tool manifest. @stable */
-declare const DELEGATE_DESCRIPTION: string;
-/** JSON Schema for `delegate` tool arguments (`intent` + optional trace id). @stable */
-declare const DELEGATE_INPUT_SCHEMA: {
-  readonly type: "object";
-  readonly properties: {
-    readonly intent: {
-      readonly type: "string";
-      readonly description: "What you want accomplished, as an outcome. The supervisor authors the worker.";
-    };
-    readonly runId: {
-      readonly type: "string";
-      readonly description: "Optional trace-correlation id for this delegation.";
-    };
-  };
-  readonly required: readonly ["intent"];
-  readonly additionalProperties: false;
-};
-/** Parsed `delegate` tool arguments. */
-interface DelegateArgs {
-  intent: string;
-  runId?: string;
-}
-/** Parse and validate raw MCP tool input into typed `DelegateArgs`; throws `TypeError` on bad input. @stable */
-declare function validateDelegateArgs(raw: unknown): DelegateArgs;
 /** The synchronous result the `delegate` tool returns to the calling agent: the delivered output (or
  *  the no-winner reason) PLUS the conserved spend of the whole delegation. */
 type DelegateResult = {
@@ -8650,64 +7773,8 @@ interface McpServer {
  * @experimental
  */
 declare function createMcpServer(options?: McpServerOptions): McpServer;
-/**
- * In-process pair of `Readable` + `Writable` streams suitable for driving
- * `server.serve(...)` from a test. Returns the agent-side stream (the
- * client writes to it) and the server-side stream (the test reads from it).
- *
- * @experimental
- */
-declare function createInProcessTransport(): {
-  transport: McpTransport;
-  clientWrite(line: string): void;
-  clientClose(): void;
-  readServer(): Promise<JsonRpcResponse[]>;
-};
 //#endregion
 //#region src/mcp/tools/spawn-resource-paths.d.ts
-/**
- * Inline resources a manager hands a child by PATH instead of by content.
- *
- * The canonical profile schema knows two resource kinds, `inline` (a content string) and `github`.
- * A manager that wants a child to receive a data file therefore had one way to do it: emit the
- * bytes inside its own `spawn` tool call. That is a transcription by a language model, and it does
- * not survive size. Measured 2026-09-12 (discovery-lab `mech-interp-foundations-glm2-b-20260912b`):
- * a 29,144-character base64 payload on the manager's disk reached three children as 15,928
- * characters with 11 substitutions, and a fourth child received the literal placeholder the
- * manager meant to replace. Seven blind-check attempts across two runs delivered no data.
- *
- * `{ kind: 'inline', name, path }` lets the coordination server be the transport: it reads the
- * file from the manager's workspace, fills `content`, and the profile that reaches the schema,
- * the journal, and the provider is an ordinary inline resource. Nothing downstream changes; the
- * model's output stops carrying the bytes.
- *
- * Where the bytes come from is a {@link SpawnResourceReader}, and there are two:
- *  - a HOST DIRECTORY, for a manager whose driver runs on this host (a loopback bridge with a
- *    `cwd`), read through the descriptor-identity checks below;
- *  - the manager's OWN EXECUTION ENVIRONMENT, for a manager inside a provider sandbox, read
- *    through the environment's `read()`. The coordination server cannot see a sandbox filesystem,
- *    but the provider that created the sandbox can, and it is already in hand.
- *
- * The second reader exists because the first one's absence was not a refusal a manager could
- * work around. Measured 2026-09-17 (discovery-lab `mech-interp-foundations-sandbox-a-20260917h`):
- * a sandbox-rooted director, refused by path, fell back to emitting its files as content and got
- * 5 characters wrong in 24,008, destroying 3 of 7 files including its instrument and both
- * drivers. At that rate 20 KB of mounts all arrive intact about 2% of the time, and gzip makes it
- * worse by turning one wrong character into total loss. Four consecutive runs in that lane lost
- * their research children to this. There is no encoding that fixes a transcription channel; the
- * only fix is a channel with no model in it.
- *
- * Fail-closed rules, each with the reason a manager needs to fix its call:
- *  - no reader available → refused (neither a host directory nor an environment with `read`)
- *  - absolute path or `..` escape → refused by both readers; a symlink that resolves outside the
- *    root → refused by the host reader (the environment reader delegates containment to the
- *    provider, which serves only the sandbox's own workspace)
- *  - not a regular file → refused
- *  - over {@link SPAWN_RESOURCE_PATH_MAX_BYTES} → refused naming the bound
- *  - bytes that are not valid UTF-8 → refused; `content` is a string, so binary data is encoded
- *    (base64) by the manager first, exactly as it would be for a content resource
- */
-declare const SPAWN_RESOURCE_PATH_MAX_BYTES: number;
 /** One successful read: the bytes as a string plus the identity the journal records. */
 interface SpawnResourceBytes {
   readonly content: string;
@@ -8729,8 +7796,6 @@ interface SpawnResourceReader {
   readonly describe: string;
   read(path: string): Promise<SpawnResourceRead>;
 }
-/** The host-directory reader: a manager whose workspace is a directory this process can open. */
-declare function hostDirectoryReader(root: string): SpawnResourceReader;
 /**
  * The environment reader: a manager running inside a provider environment whose `read()` serves
  * its own workspace. The provider owns containment — it will not serve a path outside the box —
@@ -8773,9 +7838,6 @@ type ResolveSpawnResourcePathsResult = {
 declare function resolveSpawnResourcePaths(profile: unknown, source: string | SpawnResourceReader | undefined): Promise<ResolveSpawnResourcePathsResult>;
 //#endregion
 //#region src/runtime/supervise/driver-retry.d.ts
-/** The scope's live conserved-pool readout — the retry's real bound. Indexed off `Scope` so this
- *  module tracks the pool's shape rather than restating it. */
-type DriverBudgetReadout = Scope<unknown>['budget'];
 /** Whether the run's declared completion check has passed. `'none'` means the caller declared no
  *  check at all — the retry then reads spend and settlements exactly as it always has. */
 type DriverContractState = 'met' | 'unmet' | 'none';
@@ -8805,30 +7867,6 @@ interface DriverRetryPolicy extends UnavailablePausePolicy {
    *  Platform restart. */
   readonly transientOutageMs?: number;
 }
-/** The comparable mark used to decide whether an attempt moved the run TOWARD ITS DELIVERABLE.
- *  While a declared check is unmet, spend and settlements are not progress on their own; see this
- *  file's header for the measurement that made that the rule. */
-interface DriverProgressMark {
-  /** Monotone total of POOL spend since the first reading, in tokens — the driver's own metered
-   *  turns AND any child settlement, because the conserved pool is shared. Deliberately not
-   *  driver-only: a child that settled during the attempt is progress by any reading, and the
-   *  coarser signal can only bias toward rescuing a run, never toward abandoning one. */
-  readonly poolTokensSpent: number;
-  /** Monotone count of settled children. */
-  readonly settledCount: number;
-  /** Whether an accepted deliverable exists — a submission that PASSED the completion check. */
-  readonly submitted: boolean;
-  /** The completion check's verdict right now. Omit (or `'none'`) when the caller declares no
-   *  check: the retry then reads spend and settlements exactly as it did before this field
-   *  existed, so a caller with no contract is unaffected. */
-  readonly contract?: DriverContractState;
-  /** Monotone count of settled children that PASSED the completion check. A child that ran and
-   *  settled without delivering does not count here, which is the whole point. */
-  readonly deliveredCount?: number;
-  /** The best composite any check read has scored so far. A rise is progress: the director moved
-   *  the outside check even though it has not passed. */
-  readonly composite?: number;
-}
 /** Why the loop is entering the driver again. Absent on the first attempt only.
  *
  *  An `unmet-contract` re-entry carries Runtime's continuation note. A `driver-failure` re-entry
@@ -8841,6 +7879,12 @@ type DriverReentry = {
   readonly steer: string;
   /** 1-based: which continuation this is. */
   readonly continuation: number;
+  /** Present when the barren streak had reached `maxBarren` and the loop paused before this
+   *  re-entry: the re-entered drives in a row that delivered nothing, and the pause. */
+  readonly barren?: {
+    readonly streak: number;
+    readonly pausedMs: number;
+  };
 } | {
   readonly reason: 'driver-failure';
   /** The failure that ended the previous drive, as recorded. */
@@ -8877,13 +7921,6 @@ type DriverReentry = {
 };
 //#endregion
 //#region src/runtime/supervise/continuation.d.ts
-/** Read a check function's return value into a verdict. Anything but `true` or a passing verdict
- *  is a failure: a check fails closed. */
-declare function checkVerdictOf(outcome: unknown): CheckVerdict;
-/** Items that fail in `verdict`: every item below 1, or the named items of its FAIL lines. */
-declare function failedItems(verdict: CheckVerdict): ReadonlyArray<string>;
-/** Items that pass in `verdict`. */
-declare function passedItems(verdict: CheckVerdict): ReadonlyArray<string>;
 /** One time the check ran inside the run, whatever started it. */
 interface CheckRead {
   /** 1-based count of check reads in this manager, the unavailable ones included. */
@@ -8904,17 +7941,20 @@ interface CheckRead {
  *
  * Required for an external manager with a check: Runtime supplies no default, because a retry
  * default in source is a research decision the record must make. There is no re-prompt count.
- * The loop re-enters until the check passes or a bound ends it: this deadline, the budget,
- * `maxBarren` turns in a row without progress, or cancellation. A tool `report_blocked` shows
+ * The loop re-enters until the check passes or a bound ends it: this deadline, the budget, or
+ * cancellation. After `maxBarren` turns in a row without progress, each further continuation
+ * waits a barren pause first (5 minutes, doubling to 60) and is journaled `barren-pause`; a
+ * barren streak never ends the run. A tool `report_blocked` shows
  * really failed is recorded and the loop goes on: a blocked tool is not a terminal condition.
  * Progress means the check's best composite rose, an accepted result, or a worker that delivered.
  */
 interface ContinuationPolicy {
   /** No re-entry starts at or after this instant: epoch ms, or an ISO 8601 time. */
   readonly deadline: number | string;
-  /** Re-entered turns in a row that may end without progress before the run ends. Minimum 1.
-   *  The evidence for 2: repair loses most of its effect within two or three attempts, and a
-   *  fresh start at the same budget scored higher (Debugging Decay Index). */
+  /** Re-entered turns in a row that may end without progress before each further continuation
+   *  waits a barren pause. Minimum 1. The evidence for 2: repair loses most of its effect within
+   *  two or three attempts, and a fresh start at the same budget scored higher (Debugging Decay
+   *  Index). */
   readonly maxBarren: number;
   /** Every instruction word of the note. */
   readonly profile: ContinuationProfile;
@@ -8962,7 +8002,7 @@ declare function admitContinuationPolicy(policy: ContinuationPolicy, context: st
 /**
  * Every instruction word of the note. Runtime supplies the facts and their order; this data
  * supplies the words, so the note can be improved (by a person, reflection, or GEPA) without a code
- * change. Templates may name the facts in {@link CONTINUATION_FACTS} as `{name}`.
+ * change. Templates may name the facts in `CONTINUATION_FACTS` as `{name}`.
  */
 interface ContinuationProfile {
   /** Recorded with every note, so each continuation names the words it carried. */
@@ -8994,8 +8034,6 @@ interface ContinuationProfile {
    *  chain's `'review-of-best'`. It may name `{version}`, `{path}` and `{score}`. */
   readonly review?: string;
 }
-/** The facts a profile template may name. */
-declare const CONTINUATION_FACTS: readonly ["composite", "threshold", "failed", "total", "reads", "owed", "settled", "delivered", "continuation"];
 /** What the question panel reads for one continuation. */
 interface ContinuationPanelInput {
   /** 1-based continuation number. */
@@ -9058,59 +8096,6 @@ type ContinuationAppend = (context: {
   readonly heading: string;
   readonly text: string;
 } | undefined>;
-/** A finding that reached the note, with the continuation that admitted it. */
-interface AdmittedFinding extends PanelFinding {
-  readonly admittedAt: number;
-  /** Set once every item the finding named passes. */
-  readonly resolvedAt?: number;
-}
-/** Findings reach the note only when every citation resolves, at least two distinct spans are
- *  cited, and the independent verifier agreed. The best method in Who&When found the failing step
- *  14.2% of the time, so an unverified finding is noise with a citation. */
-declare function admitFinding(finding: PanelFinding): boolean;
-/**
- * Rank the admitted findings by how many failed items they explain, drop repeats, and keep them
- * within the note's cap. Earlier findings stay as they were written (ACE: itemized additions keep
- * detail that repeated rewrites lose); a finding whose items all pass now is marked resolved.
- */
-declare function distillFindings(prior: ReadonlyArray<AdmittedFinding>, proposed: ReadonlyArray<PanelFinding>, failing: ReadonlySet<string>, continuation: number): ReadonlyArray<AdmittedFinding>;
-/** Expand the profile's question templates over the failed items and the settled workers. */
-declare function expandQuestions(templates: ReadonlyArray<string>, failing: ReadonlyArray<string>, workers: ReadonlyArray<{
-  readonly id: string;
-  readonly label: string;
-}>): ReadonlyArray<string>;
-/** The facts one note is written from. */
-interface ContinuationNoteInput {
-  readonly profile: ContinuationProfile;
-  /** 1-based. */
-  readonly continuation: number;
-  /** The verdict this turn ended on; absent when no result has reached the check. */
-  readonly verdict?: CheckVerdict;
-  /** The verdict the previous note reported, for what changed. */
-  readonly previous?: CheckVerdict;
-  /** Check reads so far, the unavailable ones included. */
-  readonly reads: number;
-  /** `verbatim` only when the policy and the check both allow the FAIL lines. */
-  readonly failures: 'verbatim' | 'off';
-  readonly findings?: ReadonlyArray<AdmittedFinding>;
-  readonly bar?: {
-    readonly best?: ContinuationPolicy['best'];
-    readonly reference?: string;
-  };
-  readonly appended?: ReadonlyArray<{
-    readonly heading: string;
-    readonly text: string;
-  }>;
-  /** What the run owes, from the check's description. */
-  readonly owed?: string;
-  readonly progress: DriverProgressMark;
-  /** Whether `read_continuation` is served to this manager. */
-  readonly canReadMore: boolean;
-  /** Whether submit_result is served to this manager. Absent means unavailable. */
-  readonly canSubmitResult?: boolean;
-  /** Whether the check's score comes from cases the director cannot see. */
-  readonly sealed?: boolean;
-}
 /** One continuation as the settle record carries it (`DriverContinuationRecord.continuations`). */
 interface ContinuationEntry {
   /** 1-based. */
@@ -9147,19 +8132,6 @@ interface VerdictSummary {
   readonly failed?: number;
   readonly total?: number;
 }
-/** The readout a continuation is composed from. */
-interface ContinuationContext {
-  /** The attempt that just completed, 1-based. */
-  readonly attempt: number;
-  /** Continuations this run has already sent. */
-  readonly continuations: number;
-  /** The mark read after the completed drive. */
-  readonly progress: DriverProgressMark;
-  readonly budget: DriverBudgetReadout;
-  /** Re-entered drives in a row, this one included, that ended without progress. */
-  readonly barrenReentries: number;
-  readonly signal: AbortSignal;
-}
 //#endregion
 //#region src/runtime/supervise/coordination-log.d.ts
 /** Stable identity of the supervisor that owns one coordination stream. High-level supervision
@@ -9450,53 +8422,10 @@ interface FinalizeContext {
 }
 /** The finalization seam: ledger in, output (or `undefined` = nothing deliverable) out. */
 type SupervisorFinalizer = (ctx: FinalizeContext) => Promise<unknown | undefined> | unknown | undefined;
-/** The single argmax both the default finalizer and `finalizeBestDelivered` share: highest
- *  score wins, missing scores count 0, ties keep the earliest ledger entry. */
-declare function pickBestDelivered<T extends {
-  readonly score?: number;
-}>(delivered: ReadonlyArray<T>): T | undefined;
 /** Keep-best under the completion oracle — the DEFAULT finalizer and the exact behavior every
  *  existing caller had: the highest-scoring delivered child's output, `undefined` when nothing
  *  delivered (or the best delivered child carries no artifact). */
 declare const bestDelivered: SupervisorFinalizer;
-/**
- * Every verified distinct output, highest score first — the shape for competing hypotheses, a
- * Pareto front, or a recorded evaluator split (three judges 2:1 → both outputs survive, with
- * provenance, instead of the minority report being erased). Distinct by `outRef` (content
- * address), so identical outputs collapse to one entry. `undefined` when nothing delivered —
- * an empty collection is a no-winner, not a winner wrapping `[]`.
- */
-declare const collectDelivered: SupervisorFinalizer;
-/**
- * Run a finalizer over a settled-worker ledger under the delivered-only invariant: filter the
- * ledger to structurally delivered children, materialize their outputs, and hand the finalizer a
- * blob reader that throws on any ref outside that set. This is the one call site both driver arms
- * (the in-process tool-loop and the MCP-mounted harness) finalize through. When a parent declares
- * a deliverable, its candidate must also pass that check: children may have narrower assignments.
- * The default selects the highest-scoring child that passes the parent's check; custom finalizers
- * assemble their candidate before the check. A rejection leaves the parent incomplete; a thrown
- * oracle surfaces a validation error. Neither changes child validity.
- */
-declare function runFinalizer(finalizer: SupervisorFinalizer, args: {
-  readonly settled: ReadonlyArray<FinalizerSettled>;
-  readonly blobs: ResultBlobStore;
-  readonly tree: TreeView;
-  readonly budget: Scope<unknown>['budget'];
-  readonly deliverable?: DeliverableSpec;
-}): Promise<unknown | undefined>;
-/** Keep-best finalize under the completion-oracle: return the highest-scoring DELIVERED child's
- *  output (settled `done` AND `valid` — its deliverable check passed). Returns undefined when no
- *  child delivered — an honest "the driver produced nothing", never a high-scoring result that
- *  ran without passing its check (Foreman's 0/18 lesson). `valid` is the single delivery signal,
- *  matching `defaultSelectWinner`'s valid-first rule; the oracle just doesn't fall back to an
- *  unchecked best-effort. The same argmax as the `bestDelivered` finalizer (`pickBestDelivered`);
- *  this direct form serves callers that hold a bare ledger + blob store. */
-declare function finalizeBestDelivered(settled: ReadonlyArray<{
-  status: string;
-  score?: number;
-  valid?: boolean;
-  outRef?: string;
-}>, blobs: ResultBlobStore): Promise<unknown>;
 //#endregion
 //#region src/runtime/supervise/reentry.d.ts
 /** What the next drive continues, as the drive harness can prove it before the turn starts. */
@@ -9581,10 +8510,6 @@ interface RunCancellation {
   /** The runtime's explanation of how it arrived at `effect`. */
   readonly detail?: string;
 }
-/** The run-scoped cancel request file of one run — one {@link RunCancelRequest}. */
-declare function runCancelRequestFile(eventDir: string): string;
-/** The run-scoped acknowledgement file of one run — one {@link RunCancellation}. */
-declare function runCancellationFile(eventDir: string): string;
 /** Read the run-scoped cancel request, or `undefined` when none was written. */
 declare function readRunCancelRequest(eventDir: string): RunCancelRequest | undefined;
 /**
@@ -9619,18 +8544,6 @@ declare function cancelRun(eventDir: string, operationId: string, options?: {
 }): RunCancellation;
 //#endregion
 //#region src/runtime/supervise/stop-rules.d.ts
-/** One settled unit of work, reduced to what a stop rule reads. `objective` is the run's own
- *  quality signal (a verdict score, a test pass-rate, a judge rating); `undefined` = this
- *  settlement produced no measurable objective (it failed, or nothing scored it). */
-interface ProgressSample {
-  readonly id: string;
-  /** Epoch ms the settlement was observed. */
-  readonly at: number;
-  readonly objective?: number;
-  /** True when the settlement passed its deliverable check — a scored-but-undelivered result is
-   *  not progress. */
-  readonly delivered: boolean;
-}
 /** The read-model a `StopRule` decides from — the run's progress, not its budget. */
 interface ProgressView {
   readonly now: number;
@@ -9667,42 +8580,6 @@ type StopDecision = {
 /** Evaluated from the progress feed, never from the budget. Pure and synchronous: it is called on
  *  the driver's hot path, once per turn. */
 type StopRule = (view: ProgressView) => StopDecision;
-/** Accumulates settlements and materializes a `ProgressView`. Idempotent by settlement id, so a
- *  caller may re-push its whole roster every turn (the driver does exactly that) without
- *  double-counting or moving a recorded timestamp. */
-interface ProgressTracker {
-  /** Record a settlement. A second call with the same `id` is ignored. Returns true when it was
-   *  new. */
-  record(sample: ProgressSample): boolean;
-  /** Materialize the view. Pass the live `Scope` to include the worker feed and tree shape. */
-  view(scope?: Scope<unknown>, opts?: {
-    readonly stallAfterMs?: number;
-  }): ProgressView;
-  /** Evaluate a rule against the current view. */
-  evaluate(rule: StopRule, scope?: Scope<unknown>, opts?: {
-    readonly stallAfterMs?: number;
-  }): StopDecision;
-  /** The samples recorded so far, in order. */
-  samples(): ReadonlyArray<ProgressSample>;
-}
-interface ProgressTrackerOptions {
-  /** Clock for `view().now`. Defaults to `Date.now`. */
-  readonly now?: () => number;
-  /** Treat a settlement that did NOT pass its deliverable check as having no objective. Default
-   *  true — "scored 0.9 but never delivered" is not progress, and counting it as progress is the
-   *  exact way a plateau rule gets talked out of firing. */
-  readonly requireDelivered?: boolean;
-  /** How much the best-so-far must rise for a settlement to count as an IMPROVEMENT. Default 0
-   *  (any strict rise counts). Raise it to ignore score noise. */
-  readonly minImprovement?: number;
-}
-/** Build the settled-work ledger a `StopRule` decides from: record each settlement (idempotent by
- *  id) and materialize a `ProgressView` combining the best-so-far curve with the live worker feed. */
-declare function createProgressTracker(opts?: ProgressTrackerOptions): ProgressTracker;
-/** Build a `ProgressSample` from a scope settlement. The objective is the verdict score and
- *  `delivered` is the verdict's `valid` — the SAME single delivery signal `finalizeBestDelivered`
- *  and `defaultSelectWinner` use, so "progress" and "winner" cannot disagree. */
-declare function sampleFromSettled(settled: Settled<unknown>, at: number): ProgressSample;
 interface NoProgressForOptions {
   /** Stop when this many ms have passed since the last SETTLEMENT. Omit to not bound on time. */
   readonly ms?: number;
@@ -9759,24 +8636,10 @@ interface AllWorkersStalledOptions {
 declare function allWorkersStalled(opts?: AllWorkersStalledOptions): StopRule;
 /** Stop when ANY rule stops — the ordinary composition (each rule is a separate reason to end). */
 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/supervisor-agent-profile.d.ts
 /** A supervisor is an exact canonical AgentProfile; no looser model/prompt shape exists. */
 type SupervisorProfile = AgentProfile;
-/** The exact profile fields consumed by supervisor materialization. */
-interface ResolvedSupervisorProfile {
-  readonly name: string;
-  readonly harness: string | null;
-  readonly modelId: string;
-  readonly systemPrompt?: string;
-}
-/**
- * Reduce one canonical executable profile to the scalars the two brain arms consume.
- */
-declare function resolveSupervisorProfile(profile: SupervisorProfile): ResolvedSupervisorProfile;
-/** Listener, authenticated remote endpoint, and bounded request policy for one manager. */
 //#endregion
 //#region src/runtime/supervise/wake.d.ts
 /** How Runtime wakes a manager that ended its turn with work open. */
@@ -9788,8 +8651,6 @@ interface ManagerWakePolicy {
   /** 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-contracts.d.ts
 type CoordinationBinding = CoordinationTransportOptions;
@@ -9927,8 +8788,8 @@ interface DriveHarness {
     };
     /** Call once per model event the harness streams: text, reasoning, or a tool call or result.
      *  On a run this process took over after a restart, the driver counts no drive toward its
-     *  no-progress bound until the first call, so a harness that never calls it leaves that run
-     *  bounded only by the continuation deadline, the run's deadline and its budget. */
+     *  barren streak until the first call, so a harness that never calls it is never paused for
+     *  a barren streak on that run. */
     readonly onModelEvent?: () => void;
   }): Promise<void>;
   /** Optional live inbox for the manager session this adapter currently drives. Return `false`
@@ -10096,7 +8957,7 @@ interface SupervisorAgentDeps {
   readonly finalizer?: SupervisorFinalizer;
   /** Where the coordination MCP binds (external arm). Omit = an ephemeral loopback port, which is
    *  unreachable from an off-host harness. A non-loopback host fails closed — see
-   *  {@link runtime.assertCoordinationBinding}. */
+   *  `assertCoordinationBinding`. */
   readonly coordination?: CoordinationBinding;
   /** OPT-IN async gate run before every spawn mints an assignment or reserves budget — the one
    *  pre-journal point that may ask the backend a question (does this bridge route the child's
@@ -10146,10 +9007,6 @@ interface SupervisorAgentTestDeps extends SupervisorAgentDeps {
   readonly brain: ToolLoopChat;
 }
 //#endregion
-//#region src/runtime/supervise/supervisor-router-config.d.ts
-/** Validate a manager's coordination authentication and request limits before execution. */
-declare function assertCoordinationBinding(binding: CoordinationBinding | undefined): void;
-//#endregion
 //#region src/runtime/supervise/supervisor-agent.d.ts
 /** Build a supervisor `Agent` from its profile: the brain resolves from `profile.harness`
  * (backend-as-data), the same resolution rule as every worker. */
@@ -10253,17 +9110,38 @@ declare class GraphRouteError extends Error {
 /** Default per-edge traversal cap — the cyclic-graph backstop when an edge names none. */
 declare const defaultEdgeTraversalCap = 32;
 //#endregion
-//#region src/runtime/supervise/budget.d.ts
+//#region src/runtime/supervise/root-stream.d.ts
+/** One line of `root-stream.jsonl`. */
+type RootStreamRecord = {
+  /** 1-based position in the file, continuing across drive attempts and across processes. */
+  readonly seq: number;
+  /** ISO instant the line was appended, from the run's own clock. */
+  readonly at: string;
+  /** The 1-based drive attempt of the root that produced it: a driver retry or re-prompt
+   *  re-enters the harness and continues the same file with the next attempt number. */
+  readonly attempt: number;
+} & ({
+  readonly event: ExecutorProgressEvent;
+} | {
+  /** The event could not be written as JSON; its kind and the reason stand in so the gap
+   *  is recorded in the file itself instead of silently narrowing the stream. */
+  readonly dropped: {
+    readonly kind: ExecutorProgressEvent['kind'];
+    readonly reason: string;
+  };
+});
 /**
- * A reconciliation whose spend the pool cannot verify. It is thrown after the reservation has
- * settled. `budgetViolation` carries any measured overspend on the same settlement, so a child
- * that fails closed on the fault still records how far its known channels exceeded the
- * reservation.
+ * The receipt for the root stream a run directory holds, recomputed from the file's bytes, or
+ * `undefined` when the directory holds none. This is what a run that never settled — a root that
+ * died mid-turn — gets on its failure record, and it equals what `close()` returned for a run
+ * that did.
  */
-declare class BudgetReconcileFault extends Error {
-  readonly budgetViolation?: BudgetViolation;
-  constructor(message: string, budgetViolation?: BudgetViolation);
-}
+declare function readRootStreamReceipt(runDir: string): Promise<RootStreamReceipt | undefined>;
+/** Every committed line of the root stream, in order, or `undefined` when there is no file. A
+ *  torn final line from a process that died mid-write is not a record and is left out. */
+declare function readRootStream(runDir: string): Promise<RootStreamRecord[] | undefined>;
+//#endregion
+//#region src/runtime/supervise/budget.d.ts
 /** Opaque, single-use reservation handle returned by `reserve` and consumed by
  *  `reconcile`. Carries the reserved ceilings so reconciliation needs no lookup. */
 interface ReservationTicket {
@@ -10365,15 +9243,6 @@ interface ReserveOptions {
   /** Leave this much of each channel free after the reservation. */
   readonly keep?: ReservationFloor;
 }
-/**
- * A waiting reservation that can never be granted: every open reservation settled and the free
- * balance still cannot cover it. `shortfalls` are the channels that did not fit at that moment.
- */
-declare class ReservationWaitRefused extends Error {
-  readonly reason: "budget-exhausted";
-  readonly shortfalls: readonly ReservationShortfall[];
-  constructor(shortfalls: readonly ReservationShortfall[]);
-}
 /** Why a reservation was refused. `budget-exhausted` means the pool ran out of a channel it
  * budgets; `usd-unbudgeted` means the root declared no dollar ceiling, so a dollar request is
  * unsatisfiable at any amount and the fix is to budget the root, not to ask for less. */
@@ -10412,7 +9281,7 @@ interface BudgetPool {
    *
    * With `wait`, a request the free balance cannot cover now, but could once the open reservations
    * return, is admitted as a WAITING ticket: `granted` resolves when the pool reserves it, and
-   * rejects with {@link ReservationWaitRefused} once nothing open could return enough. A waiting
+   * rejects with `ReservationWaitRefused` once nothing open could return enough. A waiting
    * ticket reserves nothing; reconciling it withdraws it. While any ticket waits, a new waiting
    * request queues behind it even when it would fit, so the order of asking is the order of grant.
    */
@@ -10485,7 +9354,7 @@ declare function createBudgetPool(root: Budget, runStartedAtMs: number, restore?
 //#region src/runtime/supervise/deadline.d.ts
 /**
  * What a steerable child's own time box does: a check-in, not a kill. At the child's deadline its
- * lead's scope delivers {@link DEADLINE_CHECK_IN_MESSAGE} to the child's inbox and keeps it
+ * lead's scope delivers `DEADLINE_CHECK_IN_MESSAGE` to the child's inbox and keeps it
  * running; the child is stopped (reason `child deadline exceeded`) only once it then makes no
  * progress for `idleMs`. The run's own deadline, the budgets and cancellation still stop it at once.
  * `false` restores the hard kill at the time box. A child that exposes no inbox cannot be told,
@@ -10499,277 +9368,14 @@ declare function createBudgetPool(root: Budget, runStartedAtMs: number, restore?
 type DeadlineCheckIn = false | {
   readonly idleMs?: number;
 };
-/** How long a checked-in child may go without progress before it is stopped: 30 min. */
-declare const DEFAULT_CHECK_IN_IDLE_MS: number;
-/** The check-in a child receives at its own time box. */
-declare const DEADLINE_CHECK_IN_MESSAGE: string;
-//#endregion
-//#region src/runtime/supervise/worker-events.d.ts
-/** Live observation is bounded and process-local. A reconnect explicitly reports expired history. */
-interface WorkerEventCursor {
-  readonly epoch: string;
-  readonly next: number;
-}
-interface WorkerEventEntry {
-  readonly sequence: number;
-  readonly at: number;
-  readonly event: unknown;
-  readonly omitted?: 'event-too-large' | 'event-not-serializable';
-}
-type WorkerEventPage = {
-  readonly status: 'unavailable';
-  readonly reason: 'unknown-worker' | 'not-captured';
-} | {
-  readonly status: 'available';
-  readonly entries: readonly WorkerEventEntry[];
-  readonly cursor: WorkerEventCursor;
-  readonly reset: boolean;
-  readonly historyExpired: boolean;
-  readonly remaining: number;
-};
-//#endregion
-//#region src/runtime/supervise/worker-slots.d.ts
-/**
- * Worker slots: the one bound on how many spawned agents work at the same time.
- *
- * Every scope of a supervised tree draws from one allocator. A host that runs several trees in one
- * process can pass the same allocator to each of them, and the bound then holds across all of them.
- *
- * A spawn past the bound is never refused. It keeps its reserved budget slice and waits in a queue,
- * and it starts when a slot frees. The queue releases the deepest spawn first and then the oldest,
- * so a subtree that is already paid for finishes before the tree grows wider.
- *
- * A slot counts a working agent: a spawned agent that runs with no running child of its own. A
- * manager whose children are all running is waiting on them, so its first running child takes over
- * the manager's slot and the manager takes it back when its last running child ends. This makes
- * nested waits deadlock-free: a manager can always run one child on its own slot, so a queued subtree
- * always keeps a path to completion, whatever the bound and however deep the tree.
- *
- * The bound therefore limits working agents, not environments. The environments alive at one time
- * can exceed it by the number of managers that have a running child. The conserved budget pool and
- * the deadline bound the total work; this allocator only bounds how much of it runs at once.
- *
- * @experimental
- */
-/** A fleet-wide bound on concurrently working agents, with a queue for the spawns past it. */
-interface WorkerSlots {
-  /** The bound on working agents, or `undefined` when only the budget bounds concurrency. */
-  readonly max: number | undefined;
-  /** Working agents that hold a slot now. */
-  readonly working: number;
-  /** Spawns that hold a budget slice and wait for a slot. */
-  readonly queued: number;
-}
-/**
- * One held or awaited slot. `ready` resolves when the slot is granted; `granted` reads whether it
- * has been. `release` returns the slot, or withdraws a request that is still queued, and is
- * idempotent.
- */
-interface SlotPermit {
-  readonly ready: Promise<void>;
-  readonly granted: boolean;
-  release(): void;
-}
-/**
- * Create a worker-slot allocator. `max` omitted, `0`, or negative leaves concurrency bounded by the
- * budget alone, and every spawn starts at once. Pass the returned allocator as `workerSlots` to each
- * run that should share one bound.
- */
-declare function createWorkerSlots(max?: number): WorkerSlots;
 //#endregion
 //#region src/runtime/supervise/worker-trace.d.ts
-/**
- * Seam key the `Scope` seeds a {@link TraceContext} under on each child's `ExecutorContext.seams`.
- * Single-sourced here so the scope and every backend agree on it without a circular import — the
- * same arrangement `nestedScopeSeamKey` uses.
- */
-declare const workerTraceSeamKey = "worker-trace";
 /**
  * Resolve the trace context a worker spawned BY `spawningNodeId` should inherit. `undefined` means
  * this run records no spans, so nothing is stamped. Supplied by
  * `SupervisorSpanRecorder.workerTrace` and threaded to the scope as `SupervisorOpts.workerTrace`.
  */
 type WorkerTraceResolver = (spawningNodeId: string) => TraceContext | undefined;
-/**
- * What the two readers below need off an `ExecutorContext` — its seam bag, and nothing else.
- * Structural (not an `ExecutorContext` import) so this module stays free of the keystone type
- * surface, and exported because it is part of a public signature.
- */
-interface WorkerTraceSeamCarrier {
-  readonly seams: Readonly<Record<string, unknown>>;
-}
-/**
- * Read the inherited trace context off an `ExecutorContext`, or `undefined` when the run records no
- * spans. Fails CLOSED on a malformed seam value (returns `undefined`) rather than stamping a
- * half-formed id that would produce an unjoinable orphan span downstream.
- */
-declare function readWorkerTraceContext(ctx: WorkerTraceSeamCarrier): TraceContext | undefined;
-/**
- * The trace env to merge into a worker's environment — `TRACEPARENT` plus the legacy
- * `TRACE_ID` / `PARENT_SPAN_ID` pair (dual-written for one release) — EMPTY when the run
- * records no spans, which is what keeps the untraced path byte-identical. Merge it BELOW the
- * caller's own seam env so a deliberately-set id wins (see the precedence note above).
- */
-declare function workerTraceEnv(ctx: WorkerTraceSeamCarrier): Record<string, string>;
-/**
- * The trace request headers for a worker dispatched over the cli-bridge HTTP transport — W3C
- * `traceparent` plus the legacy `x-trace-id` / `x-parent-span-id` pair the bridge also reads —
- * EMPTY when the run records no spans, which keeps the untraced request byte-identical. Derived
- * from the same dual-write the env channel uses ({@link workerTraceEnv}), so the header and env
- * spellings can never name different traces. `traceparent` is present only when a parent span id
- * exists (the W3C grammar requires one); the legacy pair still carries a lone trace id.
- */
-declare function workerTraceHeaders(ctx: WorkerTraceSeamCarrier): Record<string, string>;
-//#endregion
-//#region src/runtime/supervise/scope-contract.d.ts
-/** Construction args for `createScope`. The supervisor threads the shared pool, journal,
- *  blob store, and executor registry through; `depth`/`maxDepth` pair the runtime
- *  recursion ceiling with the conserved pool (R3). */
-interface ScopeArgs {
-  /** This scope's owning node id — children get `${parentId}:s${seq}` ids. */
-  readonly parentId: NodeId;
-  /** Journal/blob root key the supervisor `beginTree`'d. */
-  readonly root: NodeId;
-  /** The reservation pool for this scope: the root total or one nested allocated partition. */
-  readonly pool: BudgetPool;
-  /** Append-only spawn journal; this scope writes `spawned` + `settled` records. */
-  readonly journal: SpawnJournal;
-  /** Content-addressed result store backing `outRef` rehydration. */
-  readonly blobs: ResultBlobStore;
-  /** The open executor resolver (BYO → router/inline → registered harness factory). */
-  readonly executors: ExecutorRegistry;
-  /** Per-spawn executor-construction seams (sandbox client, router config, cli bin). */
-  readonly seams: Readonly<Record<string, unknown>>;
-  /** This scope's recursion depth (root = 0). */
-  readonly depth: number;
-  /** Runtime recursion-depth ceiling — a spawn past it fails closed `depth-exceeded`. */
-  readonly maxDepth?: number;
-  /** The allocator that bounds concurrently working agents across this scope, every nested scope,
-   *  and every other tree that shares it. Absent means no bound: only the budget limits concurrency. */
-  readonly workerSlots?: WorkerSlots;
-  /** @internal The slot this scope's own manager holds in its parent scope. A nested scope's first
-   *  running child works on it while the manager waits. Absent on a root scope. */
-  readonly slotOwner?: SlotPermit;
-  /** Optional policy that keeps part of each manager's budget for its own inference. */
-  readonly reservationPolicy?: RecursiveReservationPolicy;
-  /** The budget from which this scope's owner-share floor is derived. */
-  readonly ownerBudget?: Budget;
-  /** What a steerable child's own time box does: a check-in by default (`deadline.ts`
-   *  `DeadlineCheckIn`); `false` stops the child at its time box. Nested scopes inherit it. */
-  readonly deadlineCheckIn?: DeadlineCheckIn;
-  /** How long a keyed leaf whose turn ended over its budget keeps its environment for a same-key
-   *  re-spawn to continue (ms). Default {@link DEFAULT_BUDGET_STOP_HOLD_MS}; `0` keeps none.
-   *  Nested scopes inherit it. */
-  readonly budgetStopHoldMs?: number;
-  /** Abort signal for this scope; an abort cascades into every live child's executor. */
-  readonly signal: AbortSignal;
-  /** Injected clock — keeps the journal `at` timestamp deterministic in tests. */
-  readonly now?: () => number;
-  /** Lifecycle stream sink. `spawn` emits `agent.spawn`, `next` emits `agent.child` — the
-   *  SAME stream `runAgentRounds`/`tool-loop` feed, so the recursive tree is ONE observable stream
-   *  (the topology viewer reads it). Undefined ⇒ the journal stays the only record. */
-  readonly hooks?: RuntimeHooks;
-  /**
-   * Trace context to hand down to each spawned worker (`SupervisorOpts.workerTrace`). Called with
-   * THIS scope's own `parentId` — the node doing the spawning — and the resolved context is seeded
-   * onto each child's `ExecutorContext` under `workerTraceSeamKey`. Absent (the untraced default)
-   * ⇒ no seam is seeded and no worker environment is touched.
-   */
-  readonly workerTrace?: WorkerTraceResolver;
-  /**
-   * Present when this run RECORDS spans but the worker backend has NO channel to carry the trace
-   * context (`WORKER_TRACE_PROPAGATION[backend] === false` — cli-worktree has no env
-   * channel; router / router-tools / provider have no worker process). Each spawn then journals a
-   * `trace-unpropagated` event naming the severed hop, so a child whose trace shows up as a
-   * disconnected root is a recorded fact rather than a silent stranger. Absent ⇒ either the run
-   * is untraced or the backend propagates; nothing is journaled.
-   */
-  readonly workerTraceUnpropagated?: {
-    readonly backend: string;
-    readonly reason: 'no-env-channel' | 'no-worker-process' | 'caller-omitted';
-  };
-  /** Durable run directory that receives exact worker interactive bindings. */
-  readonly interactiveBindingDir?: string;
-  /** @internal Trusted root-adapter publication channel. It is never exposed as a Scope method. */
-  readonly ownerMaterialization?: {
-    readonly runtime: NodeSnapshot['runtime'];
-    readonly authoredProfile?: unknown;
-    readonly attemptId: string;
-    readonly prior?: ProfileMaterializationReceipt;
-    readonly journalRoot?: NodeId;
-    readonly nodeId?: NodeId;
-    readonly requiredKnown?: boolean;
-    readonly onReceipt?: (materialization: ProfileMaterializationReceipt, binding: ExecutionBindingReceipt) => void;
-  };
-  /**
-   * Resume seam — set ONLY by the supervisor when `SupervisorOpts.resume` is on AND a non-empty
-   * journal tree exists for this root. It carries the replayed committed work (so `scope.resume`
-   * exposes it to a resume-aware `act`) and the recorded ordinal/cursor maxima the new counters
-   * continue past, so a freshly-spawned child never reuses a journaled `seq`. Absent ⇒ fresh run.
-   */
-  readonly resumeFrom?: {
-    /** @internal Executor adoption plans validated by the supervisor's recovery preparation. */
-    readonly recoveries?: readonly RetainedChildRecovery[];
-    readonly events?: readonly SpawnEvent[];
-    readonly settled: ReadonlyArray<Settled<unknown>>;
-    readonly view: TreeView;
-    /** Highest `spawned` ordinal already journaled; new spawns start at `+1`. */
-    readonly maxSpawnOrdinal: number;
-    /** Highest cursor `seq` already journaled; new settlements start at `+1`. */
-    readonly maxCursorSeq: number;
-    /** 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). */
-    readonly priorSpend: {
-      readonly childWork: Spend;
-      readonly driverInference: Spend;
-    };
-  };
-}
-//#endregion
-//#region src/runtime/supervise/scope-capabilities.d.ts
-/** How many of a manager's direct children its summary lists; the counts always cover all. */
-declare const SUBTREE_RESULT_LIMIT = 8;
-/** Ten minutes: a manager that is alive decides within a turn or two; one that crashed, or a host
- *  that restarted, must not leave a paid environment running until a retire pass finds it. */
-declare const DEFAULT_BUDGET_STOP_HOLD_MS = 600000;
-//#endregion
-//#region src/runtime/supervise/scope-construction.d.ts
-/** Create the reactive `Scope` a driver's `Agent.act` runs inside: spawn children on an atomically reserved conserved budget, settle via the `next()` cursor, journal for replay. */
-declare function createScope<Out>(args: ScopeArgs): Scope<Out>;
-//#endregion
-//#region src/runtime/supervise/scope-observation.d.ts
-/**
- * The step-8 merge-boundary adapter (M4): rehydrate a `Settled.done` into the kernel's
- * `Iteration` shape so `defaultSelectWinner` stays single-sourced — the supervisor selects
- * across settled children with the SAME argmax the loop kernel uses, not a forked copy.
- *
- * `index` is the cursor `seq` (the recorded, replay-stable order); `output`/`verdict`/
- * `tokenUsage`/`costUsd` are read straight off the settlement (already rehydrated from the
- * `outRef` blob by `next()`). Events are empty — a settled child is an opaque leaf result,
- * not a sandbox event stream — and the timing/cost fields project its conserved `Spend`.
- * Fail loud on a `down` settlement: only a `done` child is an iteration.
- */
-declare function settledToIteration<Out>(settled: Settled<Out>): Iteration<unknown, Out>;
-//#endregion
-//#region src/runtime/supervise/supervisor-root-handle.d.ts
-/**
- * Mint a `RootHandle` plus its supervisor-private control. The handle is the substrate a
- * chat/pi-viz client attaches to (Q2): `view()` reads the live tree, `signal()` delivers
- * an out-of-band message, `abort()` cascades. Before `run` binds it (and after `run`
- * unbinds it) the handle is fail-loud: a client that talks to a handle that is not
- * driving a live run gets a typed error, never a silent no-op.
- */
-declare function createRootHandle<Out>(): SteerableRootHandle<Out>;
-//#endregion
-//#region src/runtime/supervise/supervisor-run.d.ts
-/** The default recursion-depth ceiling. The conserved pool is what bounds a tree's depth: every
- *  level draws its slice from the level above, so a tree ends when its slices run out. This
- *  ceiling only stops a runaway recursion that keeps spawning tiny slices, so it sits well above
- *  any depth a budget can usefully pay for. */
-declare const DEFAULT_MAX_DEPTH = 16;
-/** Create a supervisor that owns one recursive agent execution tree. */
-declare function createSupervisor<Task, Out>(): Supervisor<Task, Out>;
 //#endregion
 //#region src/runtime/supervise/otel-spans.d.ts
 /** OTLP span attribute values. Exported because `SupervisorSpanOptions.attributes` is public and
@@ -11107,6 +9713,55 @@ declare function retryPreSpawnRefusals<Out>(inner: Executor<Out>, policy: Resolv
   worker?: string;
 }): Executor<Out>;
 //#endregion
+//#region src/runtime/supervise/worker-slots.d.ts
+/**
+ * Worker slots: the one bound on how many spawned agents work at the same time.
+ *
+ * Every scope of a supervised tree draws from one allocator. A host that runs several trees in one
+ * process can pass the same allocator to each of them, and the bound then holds across all of them.
+ *
+ * A spawn past the bound is never refused. It keeps its reserved budget slice and waits in a queue,
+ * and it starts when a slot frees. The queue releases the deepest spawn first and then the oldest,
+ * so a subtree that is already paid for finishes before the tree grows wider.
+ *
+ * A slot counts a working agent: a spawned agent that runs with no running child of its own. A
+ * manager whose children are all running is waiting on them, so its first running child takes over
+ * the manager's slot and the manager takes it back when its last running child ends. This makes
+ * nested waits deadlock-free: a manager can always run one child on its own slot, so a queued subtree
+ * always keeps a path to completion, whatever the bound and however deep the tree.
+ *
+ * The bound therefore limits working agents, not environments. The environments alive at one time
+ * can exceed it by the number of managers that have a running child. The conserved budget pool and
+ * the deadline bound the total work; this allocator only bounds how much of it runs at once.
+ *
+ * @experimental
+ */
+/** A fleet-wide bound on concurrently working agents, with a queue for the spawns past it. */
+interface WorkerSlots {
+  /** The bound on working agents, or `undefined` when only the budget bounds concurrency. */
+  readonly max: number | undefined;
+  /** Working agents that hold a slot now. */
+  readonly working: number;
+  /** Spawns that hold a budget slice and wait for a slot. */
+  readonly queued: number;
+}
+/**
+ * One held or awaited slot. `ready` resolves when the slot is granted; `granted` reads whether it
+ * has been. `release` returns the slot, or withdraws a request that is still queued, and is
+ * idempotent.
+ */
+interface SlotPermit {
+  readonly ready: Promise<void>;
+  readonly granted: boolean;
+  release(): void;
+}
+/**
+ * Create a worker-slot allocator. `max` omitted, `0`, or negative leaves concurrency bounded by the
+ * budget alone, and every spawn starts at once. Pass the returned allocator as `workerSlots` to each
+ * run that should share one bound.
+ */
+declare function createWorkerSlots(max?: number): WorkerSlots;
+//#endregion
 //#region src/runtime/supervise/supervise-options.d.ts
 interface SuperviseOptions {
   /** Whole-run persistence and ownership. SQL contexts are acquired before replay and compute. */
@@ -11329,8 +9984,9 @@ interface SuperviseOptions {
    *
    * A continuation is the retry path, not a second loop: same scope, same coordination server,
    * same live children, and the same budget, deadline, and abort bounds. There is no count: the
-   * loop ends when the check passes, at this deadline, on the budget, after `maxBarren` turns in
-   * a row without progress, or on cancellation. A turn that ends, a blocked tool, and a lost
+   * loop ends when the check passes, at this deadline, on the budget, or on cancellation. After
+   * `maxBarren` turns in a row without progress, each further continuation waits a barren pause
+   * first, journaled `barren-pause`. A turn that ends, a blocked tool, and a lost
    * stream are segment boundaries, never the end of the run. Runtime writes the note from the check's verdict (`src/runtime/supervise/continuation.ts`); the
    * profile owns its words, and `append` may add a section but never replace one.
    *
@@ -11635,11 +10291,6 @@ interface SuperviseTestOptions extends SuperviseOptions {
   readonly brain: ToolLoopChat;
 }
 //#endregion
-//#region src/runtime/supervise/supervise-profile-admission.d.ts
-/** 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;
-//#endregion
 //#region src/runtime/supervise/supervise-worker-backend.d.ts
 /**
  * Build the worker seam from a backend (WHERE workers run) + an optional completion oracle (the
@@ -11928,14 +10579,17 @@ type GraphEdge =
  * root decides the order, the branch, the repair loop or the stop. On each usable settle of
  * `from` its outgoing routes edges are tried in declaration order and the first whose `when`
  * holds fires; an edge without `when` is the default branch and comes last. A node target is
- * spawned with `{ from: { node, result }, evidence: { [id]: latest usable result } }` and the
- * directive appended to its pinned instructions; `{ stop }` ends the run with no winner and
+ * spawned with `{ from: { node, result }, evidence: { [id]: latest usable result } }` (a join's
+ * target with `{ from: { nodes }, evidence }`, see below) and the directive appended to its pinned instructions; `{ stop }` ends the run with no winner and
  * `GraphResult.stopped`; `{ finish }` makes this settle part of the run's output.
  *
  * A fork lists two or more nodes in `to`: one traversal spawns each of them at once, each under
  * its own key `route:<edge id>#<traversal>:<node>`. A join lists two or more nodes in `from`: it
- * fires once every member has settled usably since it last fired, and the target's evidence
- * holds each member's latest result. A join carries no `when`, and it is the only routes edge
+ * fires once every member has settled usably since it last fired, and the target's task is
+ * `{ from: { nodes: <members in declared order> }, evidence }` with each member's latest result
+ * in `evidence`, so it does not depend on which member settled last and a resumed run derives the
+ * same task. A routes edge that spawns a node with a settled worker in this flow (a back edge)
+ * names that node's latest settled worker as the spawn's `successorOf`. A join carries no `when`, and it is the only routes edge
  * leaving each of its members. A route into a node that still has a running worker throws
  * {@link GraphRouteError} with reason `target-live`: converging branches use a join.
  */
@@ -12209,8 +10863,6 @@ declare class FileObserverJournal implements ObserverJournal {
   private readExistingUnsafe;
   private assertComplete;
 }
-/** Verify identity, monotonic sequence, payload shape, and the complete digest chain. */
-declare function verifyObserverRecords(records: readonly ObserverRecord[], pursuitId?: string): readonly ObserverRecord[];
 /** Compute the canonical SHA-256 digest for an unsigned observer record. */
 declare function observerRecordDigest(record: Omit<ObserverRecord, 'digest'>): string;
 //#endregion
@@ -13404,9 +12056,6 @@ interface PipelineStage<Task, StepIn, StepOut> {
    *  Fail loud (return a `blocked`) when the child produced nothing usable for the next stage. */
   collect(settled: Settled<Outcome<StepOut>>): Outcome<StepOut>;
 }
-/** `pipeline(stages)` — build the sequential combinator from an ordered stage list. The first
- *  stage's `StepIn` is the root `Task`; the last stage's `StepOut` is the deliverable `D`. */
-type Pipeline = <Task, D>(stages: ReadonlyArray<PipelineStage<Task, unknown, unknown>>) => CombinatorShape<Task, D>;
 /**
  * `fanout(items, { synthesize? })` — N children spawned in one round (one per item, bounded by
  * the conserved pool's fail-closed admission), drained via `scope.next()`, then optionally a
@@ -13475,8 +12124,6 @@ interface FanoutSynthesis<D> {
   synthesisTask(gathered: ReadonlyArray<Settled<Outcome<D>>>, ctx: ShapeContext<D>): unknown;
   collect(settled: Settled<Outcome<D>>): Outcome<D>;
 }
-/** `fanout(items, opts)` — build the fanout combinator over a static item list. */
-type Fanout = <Task, Item, D>(items: ReadonlyArray<Item>, opts: FanoutOptions<Item, D>) => CombinatorShape<Task, D>;
 /**
  * `loopUntil({ until, step })` — iterative deepening inside the conserved pool: spawn one `step`
  * child per round, ask `until` whether the accumulated state satisfies the goal, and stop when it
@@ -13507,8 +12154,6 @@ interface LoopUntilState<State> {
   readonly round: number;
   readonly value: State;
 }
-/** `loopUntil(spec)` — build the iterative-deepening combinator. `seed` is the initial state. */
-type LoopUntil = <Task, State, D>(seed: State, spec: LoopUntilSpec<Task, State, D>) => CombinatorShape<Task, D>;
 /**
  * `panel(judges)` — M judges over ONE artifact, merged WRITE-ONLY (selector≠judge taken to its
  * limit). The combinator spawns the M judge children over the same input artifact, drains their
@@ -13637,10 +12282,6 @@ interface WidenLineage<D> {
 }
 /** `widen(spec)` — build the streaming progressive-widening combinator. */
 type Widen = <Task, Seed, D>(spec: WidenSpec<Seed, D>) => CombinatorShape<Task, D>;
-/** The flat default `ScopeWidenGate` factory contract — never widens, keeping the R2 firewall
- *  conflict dormant. Exported so a gate run can pass it explicitly and a test can assert the
- *  default is flat. */
-type FlatWidenGate = <D>() => ScopeWidenGate<D>;
 /**
  * The reactive analyst seam — the PORT of the round-synchronous driver's `analyze` hook
  * (dynamic.ts) onto the reactive `Scope`. The old driver wired the analyst at round
@@ -13781,9 +12422,6 @@ interface RenderCorpusToInstructionsOptions {
   /** Optional cap on rendered lines (most-confident first), independent of the query `limit`. */
   readonly maxLines?: number;
 }
-/** `renderCorpusToInstructions(opts)` — the flywheel read-back projection. Async (queries the
- *  durable corpus); returns a fresh `AgentProfile` with the accreted facts merged in. */
-type RenderCorpusToInstructions = (opts: RenderCorpusToInstructionsOptions) => Promise<AgentProfile$3>;
 /**
  * One node in the reconstructed trajectory tree — a driver OR a leaf, with its OWN spend and the
  * spend ROLLED UP over its subtree. Reconstructed from the `SpawnJournal` (structure + per-node
@@ -13831,8 +12469,6 @@ interface TrajectoryReportOptions {
   /** Rehydrate each `done` node's `output` from the blob store. Off by default (cost-only report). */
   readonly withOutputs?: boolean;
 }
-/** `trajectoryReport(...)` — the tree+cost reconstructor. Async (reads journal + optionally blobs). */
-type TrajectoryReportFn = (journal: SpawnJournal, blobs: ResultBlobStore, root: NodeId, options?: TrajectoryReportOptions) => Promise<TrajectoryReport>;
 /**
  * One arm of an equal-k comparison — a labeled trajectory (a `TrajectoryReport` is one arm's whole
  * run). The arm's conserved COST is `report.total` (tokens + usd), which the sandbox executor
@@ -13880,8 +12516,6 @@ interface EqualKOnCostOptions {
    *  the impl (e.g. 0.05). A tighter tolerance = a stricter equal-compute claim. */
   readonly tolerance?: number;
 }
-/** `equalKOnCost(arms, opts)` — the cross-arm equal-compute check on conserved cost. */
-type EqualKOnCost = (arms: ReadonlyArray<EqualKArm>, options?: EqualKOnCostOptions) => EqualKVerdict;
 //#endregion
 //#region src/runtime/observe.d.ts
 interface ObserveInput {
@@ -14450,8 +13084,6 @@ declare function defaultSelectWinner<Task, Output>(iterations: Iteration<Task, O
 declare const TERMINAL_DECISIONS: readonly ["stop", "pick-winner", "fail", "done"];
 /** One of the kernel's terminal decision values. @stable */
 type TerminalDecision = (typeof TERMINAL_DECISIONS)[number];
-/** True when the kernel stops the loop for this decision value. @stable */
-declare function isTerminalDecision(decision: unknown): decision is TerminalDecision;
 //#endregion
 //#region src/runtime/local-sandbox-client.d.ts
 interface LocalSandboxClientOptions {
@@ -14471,12 +13103,6 @@ interface LocalSandboxClientOptions {
    * different per-create profile and provides no host isolation. */
   profileSecurityPolicy?: AgentProfileSecurityPolicy;
 }
-/** A same-host `SandboxClient` adapter with no process isolation. Local MCP is
- * refused unless the caller explicitly supplies a policy that allows it.
- *
- * There is no box, so a per-prompt `backend` or `model` override is refused rather than dropped;
- * other per-prompt options (`timeoutMs`, `context`) are accepted and ignored. */
-declare function localSandboxClient(opts: LocalSandboxClientOptions): SandboxClient;
 //#endregion
 //#region src/runtime/loop-dispatch.d.ts
 /** runAgentRounds options minus the `ctx` (loopDispatch builds the ctx). */
@@ -14960,19 +13586,6 @@ declare function definePersona<D = unknown>(input: DefinePersonaInput<D>): Perso
  */
 declare function runPersonified<Task, D>(options: RunPersonifiedOptions<Task, D>): Promise<SupervisedResult<Outcome<D>>>;
 //#endregion
-//#region src/runtime/personify/registry.d.ts
-/**
- * Build a fresh open `ShapeRegistry`. A factory is stored type-erased and re-cast on resolve — the
- * caller asserts the `<Task, D>` it expects, exactly as the executor registry stores its factories.
- */
-declare function createShapeRegistry(): ShapeRegistry;
-/** The default registry `runPersonified` resolves a shape name against. Empty by construction —
- *  a caller registers its own composed shapes; the engine ships no domain shape. */
-declare const builtinShapes: ShapeRegistry;
-/** Register a composed shape on the default `builtinShapes` registry — the one-call extension
- *  point a caller invokes so its shape is resolvable by name with zero edits to the engine. */
-declare function registerShape<Task, D>(name: string, factory: LoopShape<Task, D>): void;
-//#endregion
 //#region src/runtime/personify/trajectory.d.ts
 /**
  * Reconstruct the whole spawn tree for `root` with per-node + rolled-up `Spend`. Reads the
@@ -15076,144 +13689,18 @@ interface PrivateCasArtifactPort extends AgentCandidateOutputArtifactPort {
  * Bytes are written to the host first. With a durable store, every object is also copied off the
  * host as it is written, and `localBudgetBytes` bounds what the host keeps: an object's local copy
  * is deleted only after its durable receipt exists, and reads fall back to the durable store.
- */
-declare function createPrivateCasArtifactPort(root: string, namespace: string, options?: PrivateCasOptions): PrivateCasArtifactPort;
-//#endregion
-//#region src/runtime/stream-agent-turn.d.ts
-/**
- * The execution substrate one turn runs on — a closed discriminated union over
- * the three stream surfaces the runtime already owns.
- *
- * @stable
- */
-type AgentTurnBackend = {
-  /** A Runtime-owned executor factory materialized from this exact canonical profile. */
-  kind: 'executor';
-  factory: ExecutorFactory<unknown>;
-  /** Exact canonical identity materialized by the executor. */
-  profile: AgentProfile;
-  /** Model label stamped on cost-only `llm_call` events. Default `'agent'`. */
-  agentRunName?: string;
-};
-/** @stable */
-interface StreamAgentTurnOptions {
-  /** Caller-initiated cancellation. Terminates the stream with `final.status: 'aborted'`. */
-  signal?: AbortSignal;
-  /**
-   * Wall-clock deadline for the whole turn in ms. An expired deadline aborts
-   * the backend and terminates the stream with `final.status: 'failed'`
-   * (a blown deadline is a turn failure, not a caller cancellation).
-   */
-  timeoutMs?: number;
-  /** Stable logical paid-call id, forwarded as the provider idempotency key and retained in evidence. */
-  callId?: string;
-  /** Caller trace tag retained in evidence and forwarded when the transport supports it. */
-  correlationId?: string;
-  /**
-   * Opt-in tool-part projection for box and executor backends: sandbox tool
-   * parts additionally surface in-stream as
-   * `tool_call` / `tool_result` events (`mapSandboxToolEvent`), so a consumer
-   * rendering tool activity needs no bespoke sandbox-event parser. Default
-   * off — the stream vocabulary existing consumers see is unchanged. No-op
-   * for the `chat` kind (its backend emits `RuntimeStreamEvent`s directly,
-   * tool events included when the backend produces them).
-   */
-  preserveToolParts?: boolean;
-  /**
-   * Raw-event tap for box-kind backends: called (and awaited) with every
-   * unmapped `SandboxEvent` BEFORE it is projected, so a consumer can read
-   * parts the chat-UX projection drops (part ids, step markers, custom
-   * backend events) without forking the mapper. Purely observational — it
-   * cannot alter the mapped stream. Never called for the `chat` kind, which
-   * has no sandbox events.
-   */
-  onRawEvent?: (event: SandboxEvent) => void | Promise<void>;
-}
-/**
- * Metered usage of one turn, summed over every cost-bearing event the backend
- * emitted. `input`/`output` are token counts and are accompanied by
- * `tokensKnown: false` when the backend did not report them. `costUsd`/`model`
- * are present only when the backend actually reported them.
- *
- * @stable
- */
-interface AgentTurnUsage {
-  input: number;
-  output: number;
-  /** Present when a real turn ran but the provider did not report token usage. */
-  tokensKnown?: false;
-  costUsd?: number;
-  /** Present when Runtime could not prove the full dollar amount. */
-  usdKnown?: false;
-  /** Separately-labelled local/catalog estimate; never billed spend. */
-  estimatedCostUsd?: number;
-  /** Provider-reported prompt-cache fields; absent fields remain unknown. */
-  promptCache?: Readonly<Record<string, number | string>>;
-  /** Provider-reported reasoning-token subset of output, when available. */
-  reasoningTokens?: number;
-  model?: string;
-}
-/**
- * A drained turn: the terminal summary plus every event the stream yielded.
- * `status`/`error` mirror the terminal `final` event so a failed or aborted
- * turn stays inspectable without re-scanning `events`.
- *
- * @stable
- */
-interface CollectedAgentTurn {
-  finalText: string;
-  /** Exact terminal artifact output from a Runtime-owned executor. */
-  output?: unknown;
-  usage: AgentTurnUsage;
-  /** Exact underlying transport calls when the Runtime-owned executor reports them. */
-  transportAttempts?: number;
-  toolCalls: Array<{
-    id?: string;
-    name: string;
-    arguments: string;
-  }>;
-  events: RuntimeStreamEvent[];
-  status: AgentTaskStatus;
-  error?: BackendErrorDetail;
-  /** Public Sandbox outcome, when the turn ran through a Sandbox stream or executor. */
-  sandboxOutcome?: AgentRunOutcome;
-}
-/**
- * Run ONE agent turn on any backend kind and stream its events. Yields the
- * `RuntimeStreamEvent` vocabulary incrementally and always ends with a `final`
- * event carrying the turn's text and usage (`metadata.tokenUsage`,
- * `metadata.costUsd?`, `metadata.model?`) — on success, failure, abort, and
- * timeout alike. The generator never throws; failures surface in-band as
- * `backend_error` + `final` with a typed `error` detail.
- *
- * @stable
- */
-declare function streamAgentTurn(backend: AgentTurnBackend, input: AgentTurnInput, opts?: StreamAgentTurnOptions): AsyncGenerator<RuntimeStreamEvent>;
-/**
- * Drain a `streamAgentTurn` stream (or any `RuntimeStreamEvent` stream that
- * honors its terminal contract) into the turn summary plus the full event
- * list. Fail-loud: throws when the stream ends without a terminal `final`
- * event — a stream that violates the contract must not read as an empty turn.
  *
- * @stable
- */
-declare function collectAgentTurn(stream: AsyncIterable<RuntimeStreamEvent>): Promise<CollectedAgentTurn>;
-//#endregion
-//#region src/runtime/supervise/model-policy.d.ts
-/**
- * Throw a `ConfigError` when `allowed` is set, `model` is defined, and `model` is not a
- * member of `allowed`. No-op when `allowed` is unset (the unrestricted default) or when
- * `model` is undefined (nothing was configured to check).
+ * An object's name is published only after its bytes are synced, and that order is what makes a
+ * name trustworthy. A put whose digest already exists links nothing: it re-reads the existing
+ * object and refuses on a mismatch, and no later put replaces that file. So a deferred-sync mode
+ * that published names before one batch sync would, after a crash, leave a torn object under its
+ * valid name, and every later put of that digest would fail. Any batching must keep the order:
+ * write under temporary names, sync, publish the names, sync again (discovery-lab
+ * runner/evidence-store.mjs commits receipts this way). On drew-gtr-pro's USB SMR disk on
+ * 2026-10-21 these per-object fsyncs, 545 ms each on the 16 SYNC_THREADS, set a store's rate at
+ * about 26 files/s.
  */
-declare function assertModelAllowed(model: string | undefined, allowed: readonly string[] | undefined): void;
-/** Check every canonical model-bearing field in a complete profile, including the models a
- * backend may select for cheap work, named subagents, or modes.
- *
- * Every compared value is a bare model id. The composed `harness/provider/model` wire id
- * (`profileBridgeWireModel`) is neither built nor compared here, so this admits any route that
- * declares an allowed id, and a qualified entry in `allowed` matches nothing. Route pinning
- * belongs to `SuperviseOptions.authorizeSpawn`. */
-declare function assertProfileModelsAllowed(profile: AgentProfile, allowed: readonly string[] | undefined): void;
+declare function createPrivateCasArtifactPort(root: string, namespace: string, options?: PrivateCasOptions): PrivateCasArtifactPort;
 //#endregion
 //#region src/runtime/profile-chat-client.d.ts
 /** Profile-exact adapter for packages that consume agent-eval's ChatClient contract.
@@ -15518,22 +14005,6 @@ declare function createSandboxLineage(client: SandboxClient, options?: {
   beforeDelete?: (box: SandboxInstance) => Promise<void>;
   onAcquire?: (box: SandboxInstance, profile: AgentProfile) => void;
 }): SandboxLineage;
-/** 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 box's optional session accessor. The real
- * `SandboxInstance` exposes `session(id).status()`; the loop reads it optionally
- * so `continue` can assert session liveness without requiring it of the test
- * fakes. `status()` resolves `null` when the id is unknown to the sandbox.
- * @experimental
- */
-interface SessionCapableBox {
-  session?: (id: string) => {
-    status: () => Promise<unknown | null>;
-  };
-}
 //#endregion
 //#region src/runtime/sandbox-run.d.ts
 /**
@@ -15752,51 +14223,171 @@ interface TournamentRow {
   rep: number;
   cells: Record<string, TournamentCell>;
 }
-/** Every settled cell of one split, by task and strategy. Strategies measured on different
- * tasks have unpaired means; compare them with the paired `selection` estimates. */
-interface StrategyTournament {
-  split: SearchSplit;
-  rows: TournamentRow[];
-  perStrategy: Record<string, {
-    cells: number;
-    scored: number;
-    score: number | null;
-    usd: number;
-    usdKnown: boolean;
+/** Every settled cell of one split, by task and strategy. Strategies measured on different
+ * tasks have unpaired means; compare them with the paired `selection` estimates. */
+interface StrategyTournament {
+  split: SearchSplit;
+  rows: TournamentRow[];
+  perStrategy: Record<string, {
+    cells: number;
+    scored: number;
+    score: number | null;
+    usd: number;
+    usdKnown: boolean;
+  }>;
+}
+interface EvolutionReport {
+  searchId: string;
+  /** The search ledger: the only record and checkpoint. */
+  ledger: string;
+  closeReason: SearchCloseReason;
+  /** Root first, in registration order. */
+  strategies: EvolutionStrategy[];
+  /** The strategy the search keeps: the claim's selection, else the root. */
+  selected: EvolutionStrategy;
+  claim: SearchClaim;
+  claimVerification: SearchClaimVerification;
+  /** `ship` only when the claim shipped, re-derives from the ledger, every cost is known, and
+   * the shipped finalist's test lower bound is above zero. */
+  decision: 'ship' | 'hold';
+  reason: string;
+  tournament: Record<SearchSplit, StrategyTournament>;
+  /** Known dollars, proven floors of unknown ones, and how many cells and operations (an
+   * authoring an interrupted process lost, for example) have an unknown cost. */
+  spend: {
+    knownUsd: number;
+    floorUsd: number;
+    unknownCostCells: number;
+    unknownCostOperations: number;
+  };
+}
+/** Evolve a strategy on the search kernel and claim once on the sealed test split. */
+declare function runStrategyEvolution(cfg: StrategyEvolutionConfig): Promise<EvolutionReport>;
+/**
+ * The tournament on one split, projected from the ledger: each settled cell's final attempt,
+ * by task and repeat, keyed by strategy name. `names` maps node ids to report names.
+ */
+declare function strategyTournament(state: SearchStateView, split: SearchSplit, names: ReadonlyMap<string, string>): StrategyTournament;
+//#endregion
+//#region src/runtime/stream-agent-turn.d.ts
+/**
+ * The execution substrate one turn runs on — a closed discriminated union over
+ * the three stream surfaces the runtime already owns.
+ *
+ * @stable
+ */
+type AgentTurnBackend = {
+  /** A Runtime-owned executor factory materialized from this exact canonical profile. */
+  kind: 'executor';
+  factory: ExecutorFactory<unknown>;
+  /** Exact canonical identity materialized by the executor. */
+  profile: AgentProfile;
+  /** Model label stamped on cost-only `llm_call` events. Default `'agent'`. */
+  agentRunName?: string;
+};
+/** @stable */
+interface StreamAgentTurnOptions {
+  /** Caller-initiated cancellation. Terminates the stream with `final.status: 'aborted'`. */
+  signal?: AbortSignal;
+  /**
+   * Wall-clock deadline for the whole turn in ms. An expired deadline aborts
+   * the backend and terminates the stream with `final.status: 'failed'`
+   * (a blown deadline is a turn failure, not a caller cancellation).
+   */
+  timeoutMs?: number;
+  /** Stable logical paid-call id, forwarded as the provider idempotency key and retained in evidence. */
+  callId?: string;
+  /** Caller trace tag retained in evidence and forwarded when the transport supports it. */
+  correlationId?: string;
+  /**
+   * Opt-in tool-part projection for box and executor backends: sandbox tool
+   * parts additionally surface in-stream as
+   * `tool_call` / `tool_result` events (`mapSandboxToolEvent`), so a consumer
+   * rendering tool activity needs no bespoke sandbox-event parser. Default
+   * off — the stream vocabulary existing consumers see is unchanged. No-op
+   * for the `chat` kind (its backend emits `RuntimeStreamEvent`s directly,
+   * tool events included when the backend produces them).
+   */
+  preserveToolParts?: boolean;
+  /**
+   * Raw-event tap for box-kind backends: called (and awaited) with every
+   * unmapped `SandboxEvent` BEFORE it is projected, so a consumer can read
+   * parts the chat-UX projection drops (part ids, step markers, custom
+   * backend events) without forking the mapper. Purely observational — it
+   * cannot alter the mapped stream. Never called for the `chat` kind, which
+   * has no sandbox events.
+   */
+  onRawEvent?: (event: SandboxEvent) => void | Promise<void>;
+}
+/**
+ * Metered usage of one turn, summed over every cost-bearing event the backend
+ * emitted. `input`/`output` are token counts and are accompanied by
+ * `tokensKnown: false` when the backend did not report them. `costUsd`/`model`
+ * are present only when the backend actually reported them.
+ *
+ * @stable
+ */
+interface AgentTurnUsage {
+  input: number;
+  output: number;
+  /** Present when a real turn ran but the provider did not report token usage. */
+  tokensKnown?: false;
+  costUsd?: number;
+  /** Present when Runtime could not prove the full dollar amount. */
+  usdKnown?: false;
+  /** Separately-labelled local/catalog estimate; never billed spend. */
+  estimatedCostUsd?: number;
+  /** Provider-reported prompt-cache fields; absent fields remain unknown. */
+  promptCache?: Readonly<Record<string, number | string>>;
+  /** Provider-reported reasoning-token subset of output, when available. */
+  reasoningTokens?: number;
+  model?: string;
+}
+/**
+ * A drained turn: the terminal summary plus every event the stream yielded.
+ * `status`/`error` mirror the terminal `final` event so a failed or aborted
+ * turn stays inspectable without re-scanning `events`.
+ *
+ * @stable
+ */
+interface CollectedAgentTurn {
+  finalText: string;
+  /** Exact terminal artifact output from a Runtime-owned executor. */
+  output?: unknown;
+  usage: AgentTurnUsage;
+  /** Exact underlying transport calls when the Runtime-owned executor reports them. */
+  transportAttempts?: number;
+  toolCalls: Array<{
+    id?: string;
+    name: string;
+    arguments: string;
   }>;
+  events: RuntimeStreamEvent[];
+  status: AgentTaskStatus;
+  error?: BackendErrorDetail;
+  /** Public Sandbox outcome, when the turn ran through a Sandbox stream or executor. */
+  sandboxOutcome?: AgentRunOutcome;
 }
-interface EvolutionReport {
-  searchId: string;
-  /** The search ledger: the only record and checkpoint. */
-  ledger: string;
-  closeReason: SearchCloseReason;
-  /** Root first, in registration order. */
-  strategies: EvolutionStrategy[];
-  /** The strategy the search keeps: the claim's selection, else the root. */
-  selected: EvolutionStrategy;
-  claim: SearchClaim;
-  claimVerification: SearchClaimVerification;
-  /** `ship` only when the claim shipped, re-derives from the ledger, every cost is known, and
-   * the shipped finalist's test lower bound is above zero. */
-  decision: 'ship' | 'hold';
-  reason: string;
-  tournament: Record<SearchSplit, StrategyTournament>;
-  /** Known dollars, proven floors of unknown ones, and how many cells and operations (an
-   * authoring an interrupted process lost, for example) have an unknown cost. */
-  spend: {
-    knownUsd: number;
-    floorUsd: number;
-    unknownCostCells: number;
-    unknownCostOperations: number;
-  };
-}
-/** Evolve a strategy on the search kernel and claim once on the sealed test split. */
-declare function runStrategyEvolution(cfg: StrategyEvolutionConfig): Promise<EvolutionReport>;
 /**
- * The tournament on one split, projected from the ledger: each settled cell's final attempt,
- * by task and repeat, keyed by strategy name. `names` maps node ids to report names.
+ * Run ONE agent turn on any backend kind and stream its events. Yields the
+ * `RuntimeStreamEvent` vocabulary incrementally and always ends with a `final`
+ * event carrying the turn's text and usage (`metadata.tokenUsage`,
+ * `metadata.costUsd?`, `metadata.model?`) — on success, failure, abort, and
+ * timeout alike. The generator never throws; failures surface in-band as
+ * `backend_error` + `final` with a typed `error` detail.
+ *
+ * @stable
  */
-declare function strategyTournament(state: SearchStateView, split: SearchSplit, names: ReadonlyMap<string, string>): StrategyTournament;
+declare function streamAgentTurn(backend: AgentTurnBackend, input: AgentTurnInput, opts?: StreamAgentTurnOptions): AsyncGenerator<RuntimeStreamEvent>;
+/**
+ * Drain a `streamAgentTurn` stream (or any `RuntimeStreamEvent` stream that
+ * honors its terminal contract) into the turn summary plus the full event
+ * list. Fail-loud: throws when the stream ends without a terminal `final`
+ * event — a stream that violates the contract must not read as an empty turn.
+ *
+ * @stable
+ */
+declare function collectAgentTurn(stream: AsyncIterable<RuntimeStreamEvent>): Promise<CollectedAgentTurn>;
 //#endregion
 //#region src/runtime/structural-rollout.d.ts
 /** Provider-neutral conversation records read by structural candidate extraction. */
@@ -16080,6 +14671,30 @@ interface ChatWorkerSeamOptions {
 /** Session-owning worker factory for graph continuity. */
 declare function chatWorkerSeam(opts: ChatWorkerSeamOptions): MakeWorkerAgent;
 //#endregion
+//#region src/runtime/supervise/worker-events.d.ts
+/** Live observation is bounded and process-local. A reconnect explicitly reports expired history. */
+interface WorkerEventCursor {
+  readonly epoch: string;
+  readonly next: number;
+}
+interface WorkerEventEntry {
+  readonly sequence: number;
+  readonly at: number;
+  readonly event: unknown;
+  readonly omitted?: 'event-too-large' | 'event-not-serializable';
+}
+type WorkerEventPage = {
+  readonly status: 'unavailable';
+  readonly reason: 'unknown-worker' | 'not-captured';
+} | {
+  readonly status: 'available';
+  readonly entries: readonly WorkerEventEntry[];
+  readonly cursor: WorkerEventCursor;
+  readonly reset: boolean;
+  readonly historyExpired: boolean;
+  readonly remaining: number;
+};
+//#endregion
 //#region src/runtime/supervise/contracts/agent-scope.d.ts
 /**
  * One self-similar atom. A leaf is an `Agent` that never calls `scope.spawn`; a driver
@@ -17291,7 +15906,7 @@ type SpawnEvent = {
    *  without settling it after a host reboot, a crash, or a killed process. `live` names every
    *  worker the journal held open at that moment; `replaced` names those this process
    *  re-placed, so the rest are gone. The root is re-driven with both, and no re-entered drive
-   *  counts toward its no-progress bound until the root has streamed a model event in this
+   *  counts toward its barren streak until the root has streamed a model event in this
    *  process. Infrastructure evidence: replay and cost readers skip it; `seq` counts this run's
    *  re-entries. */
   kind: 'root-reentered';
@@ -17320,6 +15935,25 @@ type SpawnEvent = {
   madeProgress: boolean;
   seq: number;
   at: string;
+} | {
+  /** A manager's re-entered drives completed without progress `streak` times in a row, at or
+   *  past its `continuation.maxBarren`, and the driver paused before the next continuation
+   *  instead of ending the run. One row per pause, for an operator alarm. Informational:
+   *  replay, `materializeTreeView`, and cost readers skip it; `seq` counts this node's barren
+   *  pauses. */
+  kind: 'barren-pause';
+  id: NodeId;
+  /** The completed driver attempt the pause follows, 1-based. */
+  attempt: number;
+  streak: number;
+  pauseMs: number;
+  /** ISO 8601: when the next drive may start. */
+  resumeAt: string;
+  /** ISO 8601: when the manager's last attempt that made progress ended, or when its driver
+   *  loop began in this process if none has. */
+  lastProgressAt: string;
+  seq: number;
+  at: string;
 };
 /**
  * The spawn-tree event source (begin/append/load).
@@ -17606,42 +16240,6 @@ interface InPlaceCliExecutorOptions {
  */
 declare function createInPlaceCliExecutor(options: InPlaceCliExecutorOptions): Executor<InPlaceHarnessResult>;
 //#endregion
-//#region src/runtime/supervise/interactive-admission.d.ts
-/** The credential-free record written for one interactive admission phase. */
-type WorkerInteractiveAdmission = {
-  readonly schemaVersion: 1;
-  readonly workerId: string;
-  readonly recordedAt: string;
-  readonly phase: 'interactive_intent';
-  readonly provider: string;
-  readonly idempotencyKey: string;
-  readonly interactiveIdempotencyKey: string;
-  readonly sessionId: string;
-  readonly executionId: string;
-  readonly runId: string;
-  readonly requestedProfileDigest: `sha256:${string}`;
-  readonly requestDigest: `sha256:${string}`;
-} | {
-  readonly schemaVersion: 1;
-  readonly workerId: string;
-  readonly recordedAt: string;
-  readonly phase: 'interactive_environment';
-  readonly provider: string;
-  readonly environmentId: string;
-  readonly idempotencyKey: string;
-  readonly interactiveIdempotencyKey: string;
-  readonly requestDigest: `sha256:${string}`;
-} | {
-  readonly schemaVersion: 1;
-  readonly workerId: string;
-  readonly recordedAt: string;
-  readonly phase: 'interactive_started';
-  readonly idempotencyKey: string;
-  readonly interactiveIdempotencyKey: string;
-  readonly ref: AgentInteractiveSessionRef;
-  readonly refDigest: `sha256:${string}`;
-};
-//#endregion
 //#region src/runtime/supervise/interactive-worker.d.ts
 /** Environment fields supplied to every interactive worker after Runtime adds the exact profile. */
 type InteractiveWorkerEnvironment = Omit<CreateAgentEnvironmentInput, 'profile' | 'idempotencyKey' | 'signal'>;
@@ -17697,105 +16295,6 @@ interface InteractiveWorkerKeyInput {
  */
 declare function workerFromInteractiveProvider(provider: AgentEnvironmentProvider, options?: InteractiveWorkerOptions): MakeWorkerAgent;
 //#endregion
-//#region src/runtime/supervise/patch-checks.d.ts
-/** @experimental The per-task constraints the mechanical gate enforces. */
-interface CoderCheckConstraints {
-  /** Default 400. Hard cap; gate fails when exceeded. */
-  maxDiffLines?: number;
-  /** Literal path prefixes the patch must not touch. */
-  forbiddenPaths?: string[];
-}
-//#endregion
-//#region src/runtime/supervise/worktree-cli-executor.d.ts
-/** Terminal artifact of one worktree-CLI run — the canonical worktree-harness result (the captured
- *  diff + the harness's run record + the derived checks). */
-type WorktreePatchArtifact = WorktreeHarnessResult;
-/** @experimental */
-interface WorktreeCliExecutorOptions {
-  /** Absolute path to the git checkout the worktree is cut from. */
-  repoRoot: string;
-  /**
-   * The supervisor-authored prompt/model plus materializable structural resources.
-   * `model.default` selects the one-shot model. Routing-only model hints, placement concerns,
-   * provider extensions, and `resources.failOnError` fail before execution because this path
-   * cannot honor them. Harness-specific values the materializer cannot preserve also fail closed.
-   */
-  profile: AgentProfile;
-  /** Default instruction for direct `execute(undefined, signal)` calls. An execution-time task
-   *  is authoritative. Omit when the caller always supplies the task to `execute`. */
-  taskPrompt?: string;
-  /** Unique id for the worktree path + branch. Defaults to a fresh UUID. */
-  runId?: string;
-  /** Override the base ref the worktree is cut from (default `HEAD`). */
-  baseRef?: string;
-  /** Optional wall-clock cap per harness subprocess (ms). Omit it for no timer. */
-  harnessTimeoutMs?: number;
-  /** Run Codex with an ephemeral session, isolated config/instructions, network disabled, and
-   *  JSONL usage capture. Requires `profile.harness: 'codex'`; metered by default. */
-  codexReproducible?: boolean;
-  /** Absolute host paths denied to reproducible Codex (for benchmark answer copies, credentials,
-   *  or other task-specific ambient state). */
-  codexReadDeniedPaths?: ReadonlyArray<string>;
-  /**
-   * Shell command run in the live worktree to derive the tests-PASS signal (e.g. `pnpm test`).
-   * Its exit code becomes `artifact.checks.tests.passed`. Omit to skip (no signal derived).
-   */
-  testCmd?: string;
-  /** Shell command run in the live worktree to derive the typecheck-PASS signal (e.g. `pnpm typecheck`). */
-  typecheckCmd?: string;
-  /** Wall-clock cap per verification command (ms). Default = `harnessTimeoutMs` or 5 min. */
-  checkTimeoutMs?: number;
-  /** Cap on each check's captured output. Default 16k. */
-  checkOutputCap?: number;
-  /** Test seam — inject a git runner so unit tests drive the worktree helpers without git. */
-  runGit?: GitRunner;
-  /** Test seam — inject the harness runner so unit tests script a `LocalHarnessResult`. */
-  runHarness?: typeof runLocalHarness;
-  /** Test seam — inject the verification-command runner so unit tests script test/typecheck
-   *  outcomes without spawning a real shell. Defaults to a `/bin/sh -c` spawn in the worktree. */
-  runCommand?: WorktreeCheckRunner;
-  /**
-   * Exclude this leaf's spend from accounting. Defaults to `true` for ordinary CLI runs and
-   * `false` for `codexReproducible`, which captures real token usage. A metered custom runner must
-   * likewise return `LocalHarnessResult.usage`.
-   */
-  budgetExempt?: boolean;
-  /** @internal Kernel-minted attempt identity threaded by the built-in registry. */
-  executionAttemptId?: string;
-}
-/**
- * Build a worktree-CLI leaf `Executor`. Per-spawn (a fresh worktree + abort + teardown each), so a
- * fanout of N profiles = N parallel worktrees that never clobber each other.
- *
- * Fail-loud: an empty `repoRoot`, an incomplete/unsupported profile, a separate harness override,
- * or an explicitly empty `taskPrompt` throws at construction. Calling `execute(undefined, signal)`
- * without a configured prompt throws before a worktree is created. `resultArtifact()` before
- * `execute()` resolves throws.
- *
- * @experimental
- */
-declare function createWorktreeCliExecutor(options: WorktreeCliExecutorOptions): Executor<WorktreePatchArtifact>;
-//#endregion
-//#region src/runtime/supervise/patch-deliverable.d.ts
-/** @experimental */
-interface PatchDeliverableOptions extends CoderCheckConstraints {
-  /**
-   * Which verification signals the gate REQUIRES to be present-and-passing. A required signal
-   * that the artifact never derived (the command was not configured on the executor) fails the
-   * gate closed. Unlisted signals default to passed-when-absent (the executor simply didn't run
-   * that command). Default `[]` — gate on no-op / secret / forbidden / diff-size only.
-   */
-  require?: ReadonlyArray<'tests' | 'typecheck'>;
-}
-/**
- * Build the `DeliverableSpec<WorktreePatchArtifact>`: `check(artifact)` runs the shared mechanical
- * gate (`runCoderChecks`) over the captured patch + the worktree-derived pass signals and returns
- * whether the patch is DELIVERED (the `valid` conjunction).
- *
- * @experimental
- */
-declare function patchDelivered(options?: PatchDeliverableOptions): DeliverableSpec<WorktreePatchArtifact>;
-//#endregion
 //#region src/runtime/supervise/profile-registry.d.ts
 /** One completed run of one exact profile revision, under its stable NAME. */
 interface ProfileRunRecord {
@@ -17968,20 +16467,6 @@ interface WriteWorkerSteerOptions {
   readonly source?: string;
   readonly interrupt?: boolean;
 }
-/** One durable worker-scoped cancel request appended to the run's cancellation inbox. */
-interface WorkerCancelRequest {
-  /** Caller-minted stable operation identifier — the idempotency key of the whole operation. */
-  readonly operationId: string;
-  /** ISO timestamp of the append. */
-  readonly at: string;
-  /** Who asked — 'human', a brain label, a tool name. Provenance, not authorization. */
-  readonly source: string;
-  /** The worker the request targets: a workerId (node id — routed to the owning manager at any
-   *  depth), or a profile name or spawn label (resolved by the root manager against its direct
-   *  children only). */
-  readonly worker: string;
-  readonly reason?: string;
-}
 /**
  * The durable acknowledgement state for one worker-scoped cancel operation, keyed by
  * `operationId`. The runtime acknowledger is the ONLY writer; `cancelWorker` only reads it.
@@ -18041,35 +16526,10 @@ declare function supervisorRunDir(rootDir: string, id: string): string;
  * here anymore.
  */
 declare function legacySupervisorRunDir(rootDir: string, id: string): string;
-/**
- * The pre-rename runs root (`<root>/.loops/supervisor`). Only readers that ENUMERATE historical
- * runs need this — the per-id form is {@link legacySupervisorRunDir}. Nothing writes here.
- */
-declare function legacySupervisorRunsRoot(rootDir: string): string;
 /** A worker label reduced to a safe filename stem. Empty labels get a stable fallback. */
 declare function safeWorkerFile(label: string): string;
-/** The directory holding every per-worker file of one run (inboxes and control-event logs). */
-declare function supervisorWorkersDir(eventDir: string): string;
-/** The durable inbox file for one worker of one run. */
-declare function workerInboxFile(rootDir: string, supervisorId: string, worker: string): string;
 /** Same, addressed from an already-known run directory (the reader's usual entry point). */
 declare function workerInboxFileFromEventDir(eventDir: string, worker: string): string;
-/**
- * The best-effort control-event log for one worker (`workers/<label>.ndjson`) — delivery
- * bookkeeping for steers, plus whatever lifecycle events a writer chooses to append. Distinct from
- * the inbox: the inbox is the durable down-leg queue, this is the record of what happened to it.
- */
-declare function workerControlLogFile(eventDir: string, worker: string): string;
-/** Directory containing atomically admitted steer requests and runtime acknowledgements. */
-declare function workerSteersDir(eventDir: string): string;
-/** Directory containing one canonical request file per steer operation. */
-declare function workerSteerRequestsDir(eventDir: string): string;
-/** Directory containing one runtime acknowledgement per steer operation. */
-declare function workerSteerAcknowledgementsDir(eventDir: string): string;
-/** Canonical request file for one caller-owned steer operation id. */
-declare function workerSteerRequestFile(eventDir: string, operationId: string): string;
-/** Runtime acknowledgement file for one caller-owned steer operation id. */
-declare function workerSteerAcknowledgementFile(eventDir: string, operationId: string): string;
 /**
  * Admit one steer exactly once under a caller-owned operation id.
  *
@@ -18093,24 +16553,7 @@ declare function writeWorkerSteer(rootDir: string, supervisorId: string, worker:
 /** Read every atomically admitted request for one exact worker id, in admission order. @stable */
 declare function readWorkerSteerRequests(eventDir: string, worker?: string): WorkerSteerRequest[];
 /** Read one runtime steer acknowledgement, or `undefined` while no manager has answered. @stable */
-declare function readWorkerSteerAcknowledgement(eventDir: string, operationId: string): WorkerSteerAcknowledgement | undefined;
-/** The directory holding every cancellation artifact of one run (request inbox + acknowledgements). */
-declare function workerCancellationsDir(eventDir: string): string;
-/**
- * The durable cancel-request inbox of one run — one NDJSON line per {@link WorkerCancelRequest}.
- * It stays append-only so independent operations retain admission order and readers can skip a
- * partial trailing line. `appendDurableFile` uses O_APPEND, one write, file fsync, and directory
- * fsync; single-record acknowledgements use atomic replacement instead.
- */
-declare function workerCancelRequestsFile(eventDir: string): string;
-/**
- * The acknowledgement file for one cancel operation. The filename is a sanitized stem of the
- * `operationId`; the record inside carries the exact id, and readers verify it so two distinct
- * ids that sanitize to one stem fail loud instead of answering for each other.
- */
-declare function workerCancellationFile(eventDir: string, operationId: string): string;
-/** Read every valid cancel request in the run's cancellation inbox. Corrupt lines are skipped. */
-declare function readWorkerCancelRequests(eventDir: string): WorkerCancelRequest[];
+declare function readWorkerSteerAcknowledgement(eventDir: string, operationId: string): WorkerSteerAcknowledgement | undefined;
 /**
  * Read the acknowledgement for one cancel operation. `undefined` when the runtime has not
  * answered. A record whose stored `operationId` differs from the requested one is a filename
@@ -18140,6 +16583,130 @@ declare function cancelWorker(eventDir: string, worker: string, operationId: str
   readonly source?: string;
 }): WorkerCancellation;
 //#endregion
+//#region src/runtime/supervise/scope-contract.d.ts
+/** Construction args for `createScope`. The supervisor threads the shared pool, journal,
+ *  blob store, and executor registry through; `depth`/`maxDepth` pair the runtime
+ *  recursion ceiling with the conserved pool (R3). */
+interface ScopeArgs {
+  /** This scope's owning node id — children get `${parentId}:s${seq}` ids. */
+  readonly parentId: NodeId;
+  /** Journal/blob root key the supervisor `beginTree`'d. */
+  readonly root: NodeId;
+  /** The reservation pool for this scope: the root total or one nested allocated partition. */
+  readonly pool: BudgetPool;
+  /** Append-only spawn journal; this scope writes `spawned` + `settled` records. */
+  readonly journal: SpawnJournal;
+  /** Content-addressed result store backing `outRef` rehydration. */
+  readonly blobs: ResultBlobStore;
+  /** The open executor resolver (BYO → router/inline → registered harness factory). */
+  readonly executors: ExecutorRegistry;
+  /** Per-spawn executor-construction seams (sandbox client, router config, cli bin). */
+  readonly seams: Readonly<Record<string, unknown>>;
+  /** This scope's recursion depth (root = 0). */
+  readonly depth: number;
+  /** Runtime recursion-depth ceiling — a spawn past it fails closed `depth-exceeded`. */
+  readonly maxDepth?: number;
+  /** The allocator that bounds concurrently working agents across this scope, every nested scope,
+   *  and every other tree that shares it. Absent means no bound: only the budget limits concurrency. */
+  readonly workerSlots?: WorkerSlots;
+  /** @internal The slot this scope's own manager holds in its parent scope. A nested scope's first
+   *  running child works on it while the manager waits. Absent on a root scope. */
+  readonly slotOwner?: SlotPermit;
+  /** Optional policy that keeps part of each manager's budget for its own inference. */
+  readonly reservationPolicy?: RecursiveReservationPolicy;
+  /** The budget from which this scope's owner-share floor is derived. */
+  readonly ownerBudget?: Budget;
+  /** What a steerable child's own time box does: a check-in by default (`deadline.ts`
+   *  `DeadlineCheckIn`); `false` stops the child at its time box. Nested scopes inherit it. */
+  readonly deadlineCheckIn?: DeadlineCheckIn;
+  /** How long a keyed leaf whose turn ended over its budget keeps its environment for a same-key
+   *  re-spawn to continue (ms). Default `DEFAULT_BUDGET_STOP_HOLD_MS`; `0` keeps none.
+   *  Nested scopes inherit it. */
+  readonly budgetStopHoldMs?: number;
+  /** Abort signal for this scope; an abort cascades into every live child's executor. */
+  readonly signal: AbortSignal;
+  /** Injected clock — keeps the journal `at` timestamp deterministic in tests. */
+  readonly now?: () => number;
+  /** Lifecycle stream sink. `spawn` emits `agent.spawn`, `next` emits `agent.child` — the
+   *  SAME stream `runAgentRounds`/`tool-loop` feed, so the recursive tree is ONE observable stream
+   *  (the topology viewer reads it). Undefined ⇒ the journal stays the only record. */
+  readonly hooks?: RuntimeHooks;
+  /**
+   * Trace context to hand down to each spawned worker (`SupervisorOpts.workerTrace`). Called with
+   * THIS scope's own `parentId` — the node doing the spawning — and the resolved context is seeded
+   * onto each child's `ExecutorContext` under `workerTraceSeamKey`. Absent (the untraced default)
+   * ⇒ no seam is seeded and no worker environment is touched.
+   */
+  readonly workerTrace?: WorkerTraceResolver;
+  /**
+   * Present when this run RECORDS spans but the worker backend has NO channel to carry the trace
+   * context (`WORKER_TRACE_PROPAGATION[backend] === false` — cli-worktree has no env
+   * channel; router / router-tools / provider have no worker process). Each spawn then journals a
+   * `trace-unpropagated` event naming the severed hop, so a child whose trace shows up as a
+   * disconnected root is a recorded fact rather than a silent stranger. Absent ⇒ either the run
+   * is untraced or the backend propagates; nothing is journaled.
+   */
+  readonly workerTraceUnpropagated?: {
+    readonly backend: string;
+    readonly reason: 'no-env-channel' | 'no-worker-process' | 'caller-omitted';
+  };
+  /** Durable run directory that receives exact worker interactive bindings. */
+  readonly interactiveBindingDir?: string;
+  /** @internal Trusted root-adapter publication channel. It is never exposed as a Scope method. */
+  readonly ownerMaterialization?: {
+    readonly runtime: NodeSnapshot['runtime'];
+    readonly authoredProfile?: unknown;
+    readonly attemptId: string;
+    readonly prior?: ProfileMaterializationReceipt;
+    readonly journalRoot?: NodeId;
+    readonly nodeId?: NodeId;
+    readonly requiredKnown?: boolean;
+    readonly onReceipt?: (materialization: ProfileMaterializationReceipt, binding: ExecutionBindingReceipt) => void;
+  };
+  /**
+   * Resume seam — set ONLY by the supervisor when `SupervisorOpts.resume` is on AND a non-empty
+   * journal tree exists for this root. It carries the replayed committed work (so `scope.resume`
+   * exposes it to a resume-aware `act`) and the recorded ordinal/cursor maxima the new counters
+   * continue past, so a freshly-spawned child never reuses a journaled `seq`. Absent ⇒ fresh run.
+   */
+  readonly resumeFrom?: {
+    /** @internal Executor adoption plans validated by the supervisor's recovery preparation. */
+    readonly recoveries?: readonly RetainedChildRecovery[];
+    readonly events?: readonly SpawnEvent[];
+    readonly settled: ReadonlyArray<Settled<unknown>>;
+    readonly view: TreeView;
+    /** Highest `spawned` ordinal already journaled; new spawns start at `+1`. */
+    readonly maxSpawnOrdinal: number;
+    /** Highest cursor `seq` already journaled; new settlements start at `+1`. */
+    readonly maxCursorSeq: number;
+    /** 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). */
+    readonly priorSpend: {
+      readonly childWork: Spend;
+      readonly driverInference: Spend;
+    };
+  };
+}
+//#endregion
+//#region src/runtime/supervise/scope-construction.d.ts
+/** Create the reactive `Scope` a driver's `Agent.act` runs inside: spawn children on an atomically reserved conserved budget, settle via the `next()` cursor, journal for replay. */
+declare function createScope<Out>(args: ScopeArgs): Scope<Out>;
+//#endregion
+//#region src/runtime/supervise/scope-observation.d.ts
+/**
+ * The step-8 merge-boundary adapter (M4): rehydrate a `Settled.done` into the kernel's
+ * `Iteration` shape so `defaultSelectWinner` stays single-sourced — the supervisor selects
+ * across settled children with the SAME argmax the loop kernel uses, not a forked copy.
+ *
+ * `index` is the cursor `seq` (the recorded, replay-stable order); `output`/`verdict`/
+ * `tokenUsage`/`costUsd` are read straight off the settlement (already rehydrated from the
+ * `outRef` blob by `next()`). Events are empty — a settled child is an opaque leaf result,
+ * not a sandbox event stream — and the timing/cost fields project its conserved `Spend`.
+ * Fail loud on a `down` settlement: only a `done` child is an iteration.
+ */
+declare function settledToIteration<Out>(settled: Settled<Out>): Iteration<unknown, Out>;
+//#endregion
 //#region src/runtime/supervise/search-spec.d.ts
 /**
  * One multi-agent research configuration: seven orthogonal axes, all data.
@@ -18190,7 +16757,8 @@ interface SearchSpec {
     readonly analysts?: ReadonlyArray<string>;
   };
   readonly stop: {
-    /** Re-entered turns in a row without progress before the run ends (`continuation.maxBarren`). */
+    /** Re-entered turns in a row without progress before each further continuation waits a
+     *  barren pause (`continuation.maxBarren`). */
     readonly maxBarren: number;
     /** End the run when a window of settlements lifts the best score by no more than `minDelta`. */
     readonly plateau?: {
@@ -18314,6 +16882,25 @@ interface FencedSqlRunContext extends RunContext {
  */
 declare function createFencedSqlRunContext(db: SqlAdapter, runId: string, options?: SqlRunContextOptions): Promise<FencedSqlRunContext>;
 //#endregion
+//#region src/runtime/supervise/supervisor-root-handle.d.ts
+/**
+ * Mint a `RootHandle` plus its supervisor-private control. The handle is the substrate a
+ * chat/pi-viz client attaches to (Q2): `view()` reads the live tree, `signal()` delivers
+ * an out-of-band message, `abort()` cascades. Before `run` binds it (and after `run`
+ * unbinds it) the handle is fail-loud: a client that talks to a handle that is not
+ * driving a live run gets a typed error, never a silent no-op.
+ */
+declare function createRootHandle<Out>(): SteerableRootHandle<Out>;
+//#endregion
+//#region src/runtime/supervise/supervisor-run.d.ts
+/** The default recursion-depth ceiling. The conserved pool is what bounds a tree's depth: every
+ *  level draws its slice from the level above, so a tree ends when its slices run out. This
+ *  ceiling only stops a runaway recursion that keeps spawning tiny slices, so it sits well above
+ *  any depth a budget can usefully pay for. */
+declare const DEFAULT_MAX_DEPTH = 16;
+/** Create a supervisor that owns one recursive agent execution tree. */
+declare function createSupervisor<Task, Out>(): Supervisor<Task, Out>;
+//#endregion
 //#region src/runtime/supervise/trace-evidence.d.ts
 /** Schema version for content-addressed worker tool-trace artifacts. */
 declare const WORKER_TOOL_TRACE_SCHEMA_VERSION: 1;
@@ -18322,10 +16909,6 @@ interface WorkerToolTraceArtifact {
   readonly schemaVersion: typeof WORKER_TOOL_TRACE_SCHEMA_VERSION;
   readonly spans: ReadonlyArray<ToolSpan>;
 }
-/** Collect and persist one executor's structured tool trace without changing its task outcome. */
-declare function captureWorkerTraceEvidence(readSource: (() => TraceSource | undefined) | undefined, blobs: ResultBlobStore, executed: boolean): Promise<WorkerTraceEvidence>;
-/** Rehydrate exact persisted spans through agent-eval's one bounded trace-analysis adapter. */
-declare function workerTraceAnalysisStore(evidence: WorkerTraceEvidence, blobs: Pick<ResultBlobStore, 'get'>): Promise<TraceAnalysisStore>;
 /** Validate a stored trace artifact before an analyst or replay trusts it. */
 declare function parseWorkerToolTraceArtifact(value: unknown, traceRef?: string): WorkerToolTraceArtifact;
 //#endregion
@@ -18527,6 +17110,97 @@ declare function readWorkerInteractiveBinding(eventDir: string, workerId: string
  */
 declare function attachWorker(eventDir: string, workerId: string, options: AttachWorkerOptions): Promise<WorkerInteractiveSession>;
 //#endregion
+//#region src/runtime/supervise/worktree-cli-executor.d.ts
+/** Terminal artifact of one worktree-CLI run — the canonical worktree-harness result (the captured
+ *  diff + the harness's run record + the derived checks). */
+type WorktreePatchArtifact = WorktreeHarnessResult;
+/** @experimental */
+interface WorktreeCliExecutorOptions {
+  /** Absolute path to the git checkout the worktree is cut from. */
+  repoRoot: string;
+  /**
+   * The supervisor-authored prompt/model plus materializable structural resources.
+   * `model.default` selects the one-shot model. Routing-only model hints, placement concerns,
+   * provider extensions, and `resources.failOnError` fail before execution because this path
+   * cannot honor them. Harness-specific values the materializer cannot preserve also fail closed.
+   */
+  profile: AgentProfile;
+  /** Default instruction for direct `execute(undefined, signal)` calls. An execution-time task
+   *  is authoritative. Omit when the caller always supplies the task to `execute`. */
+  taskPrompt?: string;
+  /** Unique id for the worktree path + branch. Defaults to a fresh UUID. */
+  runId?: string;
+  /** Override the base ref the worktree is cut from (default `HEAD`). */
+  baseRef?: string;
+  /** Optional wall-clock cap per harness subprocess (ms). Omit it for no timer. */
+  harnessTimeoutMs?: number;
+  /** Run Codex with an ephemeral session, isolated config/instructions, network disabled, and
+   *  JSONL usage capture. Requires `profile.harness: 'codex'`; metered by default. */
+  codexReproducible?: boolean;
+  /** Absolute host paths denied to reproducible Codex (for benchmark answer copies, credentials,
+   *  or other task-specific ambient state). */
+  codexReadDeniedPaths?: ReadonlyArray<string>;
+  /**
+   * Shell command run in the live worktree to derive the tests-PASS signal (e.g. `pnpm test`).
+   * Its exit code becomes `artifact.checks.tests.passed`. Omit to skip (no signal derived).
+   */
+  testCmd?: string;
+  /** Shell command run in the live worktree to derive the typecheck-PASS signal (e.g. `pnpm typecheck`). */
+  typecheckCmd?: string;
+  /** Wall-clock cap per verification command (ms). Default = `harnessTimeoutMs` or 5 min. */
+  checkTimeoutMs?: number;
+  /** Cap on each check's captured output. Default 16k. */
+  checkOutputCap?: number;
+  /** Test seam — inject a git runner so unit tests drive the worktree helpers without git. */
+  runGit?: GitRunner;
+  /** Test seam — inject the harness runner so unit tests script a `LocalHarnessResult`. */
+  runHarness?: typeof runLocalHarness;
+  /** Test seam — inject the verification-command runner so unit tests script test/typecheck
+   *  outcomes without spawning a real shell. Defaults to a `/bin/sh -c` spawn in the worktree. */
+  runCommand?: WorktreeCheckRunner;
+  /**
+   * Exclude this leaf's spend from accounting. Defaults to `true` for ordinary CLI runs and
+   * `false` for `codexReproducible`, which captures real token usage. A metered custom runner must
+   * likewise return `LocalHarnessResult.usage`.
+   */
+  budgetExempt?: boolean;
+  /** @internal Kernel-minted attempt identity threaded by the built-in registry. */
+  executionAttemptId?: string;
+}
+/**
+ * Build a worktree-CLI leaf `Executor`. Per-spawn (a fresh worktree + abort + teardown each), so a
+ * fanout of N profiles = N parallel worktrees that never clobber each other.
+ *
+ * Fail-loud: an empty `repoRoot`, an incomplete/unsupported profile, a separate harness override,
+ * or an explicitly empty `taskPrompt` throws at construction. Calling `execute(undefined, signal)`
+ * without a configured prompt throws before a worktree is created. `resultArtifact()` before
+ * `execute()` resolves throws.
+ *
+ * @experimental
+ */
+declare function createWorktreeCliExecutor(options: WorktreeCliExecutorOptions): Executor<WorktreePatchArtifact>;
+//#endregion
+//#region src/runtime/supervise/patch-checks.d.ts
+/** @experimental The per-task constraints the mechanical gate enforces. */
+interface CoderCheckConstraints {
+  /** Default 400. Hard cap; gate fails when exceeded. */
+  maxDiffLines?: number;
+  /** Literal path prefixes the patch must not touch. */
+  forbiddenPaths?: string[];
+}
+//#endregion
+//#region src/runtime/supervise/patch-deliverable.d.ts
+/** @experimental */
+interface PatchDeliverableOptions extends CoderCheckConstraints {
+  /**
+   * Which verification signals the gate REQUIRES to be present-and-passing. A required signal
+   * that the artifact never derived (the command was not configured on the executor) fails the
+   * gate closed. Unlisted signals default to passed-when-absent (the executor simply didn't run
+   * that command). Default `[]` — gate on no-op / secret / forbidden / diff-size only.
+   */
+  require?: ReadonlyArray<'tests' | 'typecheck'>;
+}
+//#endregion
 //#region src/runtime/supervise/worktree-fanout.d.ts
 /** @experimental One authored profile in a worktree fanout. Its exact `harness` field chooses the
  * local CLI; the supervisor authors the complete profile per sub-task. */
@@ -18756,19 +17430,6 @@ declare function boxSurfaceReader(box: SurfaceReadBox, options?: BoxSurfaceReade
  */
 declare function fsSurfaceReader(root: string): SurfaceReader;
 //#endregion
-//#region src/runtime/tangle-sandbox-exact-process-provider.d.ts
-type SandboxControlClient = Pick<Sandbox, 'create' | 'get' | 'list'>;
-interface CreateTangleSandboxExactProcessProviderOptions {
-  name?: string;
-}
-/**
- * Adapt Tangle Sandbox's managed control runtime to Runtime's exact-process provider.
- *
- * The adapter deliberately exposes no ordinary agent environment: an exact experiment
- * must start a fresh Sandbox with no managed agent and launch its declared argv directly.
- */
-declare function createTangleSandboxExactProcessProvider(client: SandboxControlClient, options?: CreateTangleSandboxExactProcessProviderOptions): AgentEnvironmentProvider;
-//#endregion
 //#region src/runtime/verifier-environment.d.ts
 interface VerifierEnvironmentOptions {
   name: string;
@@ -19294,7 +17955,8 @@ interface CoordinationTools {
     readonly unavailable?: string;
   }): CheckRead;
   /** Every `report_blocked` whose probe failed too, in report order. A blocked tool is evidence,
-   *  not a terminal condition: the run goes on, and the no-progress bound ends it when it cannot. */
+   *  not a terminal condition: the run goes on, and turns without progress pace it with longer
+   *  barren pauses until the check, the deadline, the budget or a cancel ends it. */
   blocked(): ReadonlyArray<BlockedToolReport>;
 }
 /** One `report_blocked` whose probe failed too.
@@ -19348,6 +18010,9 @@ interface DriverAttemptRecord {
   readonly contract?: DriverContractState;
   /** True when this COMPLETED attempt's unmet contract sent the loop back with a continuation. */
   readonly reprompted?: boolean;
+  /** With `reprompted`: the pause taken before that continuation because the barren streak had
+   *  reached `continuation.maxBarren`. The run's journal holds its `barren-pause` row. */
+  readonly barrenPauseMs?: number;
   /** For a completed attempt that left work open: how long the manager then waited, with no
    *  model turn, before the wake that started the next attempt. */
   readonly waitedMs?: number;
@@ -19355,10 +18020,10 @@ interface DriverAttemptRecord {
    *  the manager has no continuation policy, or when the continuation was sent. */
   readonly repromptRefusedBy?: DriverRepromptRefusal;
 }
-/** Why a completed drive with an unmet contract was not re-entered. `no-progress` means
- *  `continuation.maxBarren` consecutive re-entered drives completed without progress. `closed`
- *  means the run was already closed: the manager's own `stop` or a progress stop rule. */
-type DriverRepromptRefusal = 'closed' | Extract<DriverAttemptStop, 'aborted' | 'budget-exhausted' | 'deadline' | 'max-attempts' | 'no-progress'>;
+/** Why a completed drive with an unmet contract was not re-entered. `closed` means the run was
+ *  already closed: the manager's own `stop` or a progress stop rule. A barren streak is never a
+ *  refusal: it pauses the next continuation (`barrenPauseMs`). */
+type DriverRepromptRefusal = 'closed' | Extract<DriverAttemptStop, 'aborted' | 'budget-exhausted' | 'deadline' | 'max-attempts'>;
 /**
  * How one driver failure is answered.
  *
@@ -19371,30 +18036,6 @@ type DriverRepromptRefusal = 'closed' | Extract<DriverAttemptStop, 'aborted' | '
  *    budget, and cancellation bound the pauses.
  */
 type DriverFailureClass = 'transient' | 'terminal' | 'unavailable';
-/**
- * The code or status that marks `error` as an upstream capacity refusal, or `undefined`.
- *
- * A structured field is read first: a turn outcome's `errorCode`, a transport error's
- * `upstreamCode` and `status`, a provider SDK error's `status`. The failure text is read only when
- * no structured field decided, because a harness CLI reports the router's refusal as text.
- */
-declare function upstreamUnavailableSignal(error: unknown): string | undefined;
-/**
- * Classify one driver failure. Runtime's own typed refusals are decisions and stay terminal; an
- * upstream capacity refusal is `unavailable`; anything else foreign is an accident and is
- * retryable. A `BackendTransportError` is split by status because the taxonomy already promises
- * consumers may branch on it: a 5xx/408 is the upstream having a bad moment, a 429/503/529 is the
- * upstream out of capacity, and a 401/404/422 is a request that will fail identically forever. The
- * bridge's own never-retry classes are terminal whether or not a status rides with them.
- */
-declare function classifyDriverFailure(error: unknown, signal?: AbortSignal): DriverFailureClass;
-/** The error a give-up throws: the original cause, re-described with the attempt history so
- *  `driver-failed` carries a diagnosable message instead of one backend's last words. */
-declare class DriverAttemptsExhaustedError extends RuntimeRunStateError {
-  readonly attempts: readonly DriverAttemptRecord[];
-  readonly stop: DriverAttemptStop;
-  constructor(cause: unknown, attempts: readonly DriverAttemptRecord[], stop: DriverAttemptStop);
-}
 /**
  * What one driver loop did, counted from its attempt records: the numbers a run's settle record
  * carries so a reader can tell genuine continuations from failure retries without the journal.
@@ -19449,8 +18090,6 @@ interface DriverContinuationRecord extends DriverLoopRecord {
    *  Empty for a manager with no check. */
   readonly continuations: ReadonlyArray<ContinuationEntry>;
 }
-/** Count a loop's attempt records into its {@link DriverLoopRecord}. */
-declare function summarizeDriverAttempts(records: ReadonlyArray<DriverAttemptRecord>): DriverLoopRecord;
 //#endregion
 //#region src/runtime/supervise/contracts/supervisor-result.d.ts
 /** Provider-observed model identity for the root manager's settled inference turns.
@@ -20313,32 +18952,6 @@ interface RuntimeFailureCause {
   /** The upstream or provider machine code the failure carried, when it carried one. */
   readonly providerCode?: string;
 }
-/** What the caller knows about how a failed operation ended. */
-interface RuntimeFailureContext {
-  /** The caller's own signal. Aborted means the caller cancelled. */
-  readonly signal?: AbortSignal;
-  /** The operation's own deadline expired before the caller cancelled it. */
-  readonly deadlineExpired?: boolean;
-}
-/**
- * Classify a thrown failure. Pass the caller's signal so a cancellation the caller asked for is
- * attributed to the caller even when the provider surfaced it as an ordinary error, and say when
- * the operation's own deadline expired so a blown deadline is never reported as a cancellation.
- */
-declare function runtimeFailureCause(error: unknown, context?: RuntimeFailureContext): RuntimeFailureCause;
-/**
- * Classify a down settlement from the typed facts Runtime recorded while the cause was still a
- * value: the retained cause, the failure classified where the executor threw, then `infra: false`,
- * the throw path's statement that the work itself failed. `infra: true` is not an owner: Runtime
- * also sets it for cancellations, budget reconcile faults and validation errors, and from the
- * platform's failure messages, so a settlement with nothing else typed is `unknown`.
- */
-declare function settlementFailureCause(down: {
-  readonly reason: string;
-  readonly infra?: boolean;
-  readonly retainedPendingCause?: RetainedPendingCause;
-  readonly failure?: RuntimeFailureCause;
-}): RuntimeFailureCause;
 //#endregion
 //#region src/types.d.ts
 /** @stable */
@@ -20877,5 +19490,5 @@ interface KnowledgeReadinessDecision {
   nonBlockingGapIds: string[];
 }
 //#endregion
-export { SubtreeSummary as $, NodeExecutionIdentity as $C, analystToolGroupNames as $S, startRuntimeRun as $T, DelegationHistoryEntry as $_, filterAuthoredAsserts as $a, CreateWorktreeOptions as $b, harvestCorpus as $c, SelectSeat as $d, RegisteredPrompt as $f, CoderDelegate as $g, SharedBoxHandle as $h, delegate as $i, PersonaContext as $l, ResolveSpawnResourcePathsResult as $m, runInWorkspace as $n, StreamAgentTurnOptions as $o, runCancellationFile as $p, ProvisionSupervisorRequest as $r, LocalSandboxClientOptions as $s, ForkRequest as $t, PursuitNodeCost as $u, CheckUnavailableError as $v, HarnessTranscriptReadOptions as $w, DownMessageAuthorizationInput as $x, renderPairwiseMarkdown as $y, RetainedPendingCause as A, BackendTransportError as AC, McpTransport as AS, LoopResult as AT, DelegationResumeDriver as A_, ProfileRichnessThresholds as Aa, createOtelExporter as Ab, breadthStrategy as Ac, superviseFleetCapabilities as Ad, WorkerEventEntry as Af, mapSandboxToolEvent as Ag, RouterToolsSeam as Ah, graphFromStored as Ai, PipelineStage as Al, ContinuationAppend as Am, WorkerInteractiveProviderSource as An, acquireSandbox as Ao, resolveSupervisorProfile as Ap, readWorkerSteerRequests as Ar, registryScopeAnalyst as As, SpawnRefusalCause as At, IsolatedCheckOptions as Au, createPropagatingTraceEmitter as Av, TeamProgress as Aw, GateRequest as Ax, CodeModeTool as Ay, Spend as B, ValidationError as BC, ANALYST_DEFINITION_BOUNDS as BS, OutputAdapter as BT, DelegateCodeResult as B_, CheckSource as Ba, RuntimeTelemetryOptions as Bb, StrategyCtx as Bc, WorkerSpawnRetryAttempt as Bd, ReservationFloor as Bf, RouterTransportConfig as Bg, InboxMessage as Bh, DispatchReport as Bi, TrajectoryReportOptions as Bl, VerdictSummary as Bm, spendFromUsageEvents as Bn, reconnectRetainedInteractiveRun as Bo, allOf as Bp, workerInboxFileFromEventDir as Br, BenchmarkStrategySummary as Bs, AgentProfile$2 as Bt, VersionJudge as Bu, buildDelegationTraceSpans as Bv, StartRetainedInteractiveRunOptions as Bw, QuestionEscalationOutcome as Bx, Interval as By, RuntimeFailureCause as C, InMemorySpawnJournal as CC, RetainedRunStartMaterial as CE, isPeerMailEnvelope as CS, LoopEndedPayload as CT, detachedTurnEvents as C_, ChatTransportTool as Ca, OtelExporter as Cb, AgenticTool as Cc, GraphTopology as Cd, readWorkerTraceContext as Cf, resolveSecretEnv as Cg, createExecutor as Ch, createInPlaceCliExecutor as Ci, LoopUntilSpec as Cl, CoordinationLog as Cm, analystsFromRegistry as Cn, openSandboxRun as Co, SupervisorNodeContextSeed as Cp, WriteWorkerSteerOptions as Cr, verify as Cs, GraphSubtasks as Ct, checkProgramDigest as Cu, ResearchSource as Cv, decodeToolPart as Cw, LeadMessage as Cx, harnessUsageIsEmpty as Cy, runtimeFailureCause as D, resolveRedactor as DC, JsonRpcResponse as DS, LoopLineageOptions as DT, DelegationArgs as D_, createChatSessionStore as Da, buildLoopSpanNodes as Db, StrategyMessage as Dc, runGraph as Dd, WorkerSlots as Df, SandboxToolPartState as Dg, CliWorktreeSeam as Dh, StoredGraph as Di, PanelSpec as Dl, AdmittedFinding as Dm, worktreeFanout as Dn, SessionCapableBox as Do, ManagerWakePolicy as Dp, readWorkerCancelRequests as Dr, assertTraceDerivedFindings as Ds, SpawnPreflight as Dt, readDeclaredCheck as Du, multiHarnessResearcherFanout as Dv, DEFAULT_STALL_AFTER_MS as Dw, WorkerWatchOptions as Dx, CodeModeOptions as Dy, RuntimeFailureOwner as E, defaultRedactor as EC, StartRetainedRunOptions as EE, JsonRpcMessage as ES, LoopIterationStartedPayload as ET, runDetachedTurn as E_, chatWorkerSeam as Ea, buildLoopOtelSpans as Eb, RunAgenticOptions as Ec, TraversalContinuity as Ed, workerTraceSeamKey as Ef, SandboxOutputMarker as Eg, CliWorktreeBridgeSeam as Eh, GraphSelection as Ei, PanelJudge as El, PriorCoordination as Em, WorktreeFanoutOptions as En, SandboxLineageHandle as Eo, DEFAULT_DEADLINE_WARNING_MS as Ep, legacySupervisorRunsRoot as Er, RegistryAnalyzeProjection as Es, SettledWorker as Et, declaredCheckJudge as Eu, createResearcherValidator as Ev, ActivityNote as Ew, ToolOutcomeEvent as Ex, decodeHarnessUsage as Ey, Budget as F, RetainedInteractiveAdmissionError as FC, PublishOptions as FS, LoopTraceEmitter as FT, SubmitInput as F_, supervisorInstructions as Fa, toOtelAttributes as Fb, AuthorStrategyOptions as Fc, AuthorizedSpawnContext as Fd, BudgetPool as Ff, createSandboxUsageLedger as Fg, SteerableSandboxSession as Fh, lookupGraph as Fi, ScopeWidenGate as Fl, ContinuationPanelInput as Fm, VERIFY_TAIL_CHARS as Fn, recoverRetainedRun as Fo, ProgressTracker as Fp, workerCancelRequestsFile as Fr, sanitizeMcpToolSchema as Fs, AgentEnvironmentEvent$1 as Ft, NextPursuitVersionInput as Fu, DELEGATION_TRACE_MAX_BYTES as Fv, RecoverRetainedInteractiveRunOptions as Fw, RouteWhen as Fx, createCodeModeTools as Fy, NodeSnapshot as G, SpawnModelSubstitution as GC, AnalystLensOutput as GS, Validator as GT, DelegateResearchResult as G_, StructuralRolloutPolicy as Ga, sanitizeAgentRuntimeEvent as Gb, defineStrategy as Gc, retryPreSpawnRefusals as Gd, ReservationTicket as Gf, ToolLoopCompaction as Gg, DEFAULT_SHARED_BOX_WORKERS as Gh, queueOf as Gi, WidenLineage as Gl, expandQuestions as Gm, GitWorkspaceOptions as Gn, profileChatClient as Go, plateau as Gp, workerSteersDir as Gr, LoopCampaignDispatchOptions as Gs, AgentTurnResult$2 as Gt, SupervisePursuitOptions as Gu, DelegationStateCorruptError as Gv, HarnessTranscriptUnavailable as Gw, QuestionPolicy as Gx, PairwiseVerdict as Gy, SpendGap as H, ExecutorContext as HC, AnalystDefinitionIssue as HS, SandboxClient as HT, DelegateFeedbackResult as H_, RepairStop as Ha, SanitizedKnowledgeRequirement as Hb, adaptiveRefine as Hc, WorkerSpawnRetryPolicy as Hd, ReservationRejection as Hf, ToolSpec as Hg, PeerInboxMessage as Hh, DispatchUnit as Hi, VerifySpec as Hl, admitFinding as Hm, UntrackedCopyStats as Hn, startRetainedInteractiveRun as Ho, anyOf as Hp, workerSteerAcknowledgementsDir as Hr, Environment as Hs, AgentSession as Ht, assertPursuitVersions as Hu, composeLoopTraceEmitters as Hv, HarnessTranscriptCapture as Hw, QuestionEscalationTarget as Hx, LeaderboardOptions as Hy, BudgetOverspend as I, RetainedInteractiveBindingError as IC, createEventBus as IS, LoopTraceEvent as IT, SubmitOutput as I_, CheckExecChannel as Ia, RuntimeEventCollector as Ib, AuthoredStrategy as Ic, DeliverableResolutionInput as Id, BudgetPoolRestore as If, extractLlmCallEvent as Ig, createSteerableSandboxSession as Ih, pickBestGraph as Ii, SteerContext as Il, ContinuationPanelResult as Im, WorkerEvidenceInput as In, startRetainedRun as Io, ProgressTrackerOptions as Ip, workerCancellationFile as Ir, BenchmarkCell as Is, AgentEnvironmentProvider$1 as It, PursuitVersionChain as Iu, DELEGATION_TRACE_MAX_SPANS as Iv, RetainedInteractiveAdmissionHook as Iw, ChildQuestionInbox as Ix, describeCodeModeTools as Iy, Settled as J, ExecutorExecutionBinding as JC, AnalystToolGroupName as JS, RuntimeRunHandle as JT, DelegateUiAuditResult as J_, canDisplace as Ja, InPlaceHarnessResult as Jb, strategyAuthorSystemPrompt as Jc, SuperviseRegistryTable as Jd, createBudgetPool as Jf, ToolLoopToolCall as Jg, SharedBoxPlacementOptions as Jh, DesignerToolsEnv as Ji, DefinePersona as Jl, DriverBudgetReadout as Jm, WorkspaceCommit as Jn, assertProfileModelsAllowed as Jo, RunCancellation as Jp, RemoteSupervisorReader as Jr, SuperviseDispatchOptions as Js, CheckpointRequest as Jt, supervisePursuit as Ju, FileDelegationStoreOptions as Jv, captureHarnessTranscript as Jw, questionEscalationTargets as Jx, leaderboard as Jy, NodeStatus as K, AgentExecutionRef as KC, AnalystRegistry$1 as KS, RuntimeRunCompleteInput as KT, DelegateUiAuditArgs as K_, StructuralRolloutResult as Ka, sanitizeKnowledgeReadinessReport as Kb, sampleThenRefine as Kc, withWorkerSpawnRetry as Kd, ReservationWaitRefused as Kf, ToolLoopCompactionOptions as Kg, SharedBoxCloseReceipt as Kh, rollingDispatch as Ki, WidenSpec as Kl, failedItems as Km, Shell as Kn, profileOptimizerModelCall as Ko, sampleFromSettled as Kp, writeWorkerSteer as Kr, LoopDispatchOptions as Ks, AnalystFinding$1 as Kt, SupervisedPursuitResult as Ku, DelegationStore as Kv, HarnessTranscriptUnavailableReason as Kw, QuestionRecord as Kx, ProfileKeyOf as Ky, BudgetViolation as L, RetainedRunAdmissionError as LC, WatchTraceOptions as LS, LoopWinner as LT, hashIdempotencyInput as L_, CheckOutcome as La, RuntimeStreamEventCollector as Lb, ShotSpec as Lc, SuperviseOptions as Ld, BudgetReadout as Lf, sandboxEventServedBackend as Lg, AuthorityInboxMessage as Lh, recordGraphRun as Li, TrajectoryNode as Ll, ContinuationPolicy as Lm, closingWorkerNote as Ln, startRetainedRunInEnvironment as Lo, ProgressView as Lp, workerCancellationsDir as Lr, BenchmarkConfig as Ls, AgentEnvironmentQuery as Lt, PursuitVersionStop as Lu, DelegationTraceCaps as Lv, RetainedInteractiveEnvironmentInput as Lw, EscalateQuestion as Lx, runCodeMode as Ly, TRACE_SUMMARY_SCHEMA as M, JudgeError as MC, BusRecord as MS, LoopStartedPayload as MT, DelegationRunContext as M_, assessAuthoredProfile as Ma, loopEventToOtelSpan as Mb, refine as Mc, workerFromBackend as Md, DEADLINE_CHECK_IN_MESSAGE as Mf, SandboxServedBackend as Mg, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Mh, graphRunsFor as Mi, RenderCorpusToInstructionsOptions as Ml, ContinuationEntry as Mm, readWorkerInteractiveBinding as Mn, S3PrivateCasStoreOptions as Mo, NoProgressForOptions as Mp, supervisorRunDir as Mr, McpEndpoint as Ms, WorkerSpawnContext as Mt, runIsolatedCheck as Mu, readTraceContextFromEnv as Mv, createActivityLog as Mw, RouteFlow as Mx, CodeModeToolsOptions as My, TraceRootArtifact as N, NotFoundError as NC, BusStats as NS, LoopTeardownFailedPayload as NT, DelegationTaskQueue as N_, defaultProfileRichnessThresholds as Na, padSpanId as Nb, runAgentic as Nc, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as Nd, DEFAULT_CHECK_IN_IDLE_MS as Nf, SandboxUsageLedger as Ng, SandboxSteeringOptions as Nh, listGraphRuns as Ni, ScopeAnalyst as Nl, ContinuationNoteInput as Nm, EVIDENCE_MAX_CHARS as Nn, createS3PrivateCasStore as No, PlateauOptions as Np, supervisorRunsRoot as Nr, McpEnvironmentOptions as Ns, AgentEnvironment$1 as Nt, JudgedPursuitVersion as Nu, traceContextToEnv as Nv, readWorkerProgress as Nw, RouteGate as Nx, CodeModeToolset as Ny, settlementFailureCause as O, AgentEvalError$1 as OC, McpToolAnnotations as OS, LoopPlanDescription as OT, DelegationRecord as O_, AuthoredProfile as Oa, buildRuntimeEventOtelSpans as Ob, StrategyShotResult as Oc, runGraphWithTestBrain as Od, createWorkerSlots as Of, createSandboxToolPartState as Og, ProviderSeam as Oh, digestOfGraph as Oi, PanelVerdict as Ol, CONTINUATION_FACTS as Om, AttachWorkerOptions as On, createSandboxLineage as Oo, ResolvedSupervisorProfile as Op, readWorkerCancellation as Or, buildSteerContext as Os, SpawnPreflightContext as Ot, IsolatedCheckBox as Ou, researcherProfile as Ov, ExecutorProgress as Ow, DecideGate as Ox, CodeModeResult as Oy, TraceSummary as P, PlannerError as PC, EventBus as PS, LoopTokenUsage as PT, DelegationTaskQueueOptions as P_, profileRichnessFinding as Pa, padTraceId as Pb, sample as Pc, AuthorizedSpawn as Pd, DeadlineCheckIn as Pf, assertSandboxServedModel as Pg, SteerableSandboxArgs as Ph, loadGraph as Pi, ScopeAnalyzeInput as Pl, ContinuationPanel as Pm, NOTE_MAX_CHARS as Pn, reconnectRetainedRun as Po, ProgressSample as Pp, supervisorWorkersDir as Pr, createMcpEnvironment as Ps, AgentEnvironmentCapabilities$1 as Pt, NextPursuitVersion as Pu, CappedDelegationTrace as Pv, ReconnectRetainedInteractiveRunOptions as Pw, RouteMatch as Px, RunCodeModeOptions as Py, SubtreeResult as Q, MaterializedModelIdentity as QC, DefinedAnalystRecord as QS, RuntimeRunStatus as QT, DelegationHistoryArgs as Q_, defaultStructuralRolloutPolicy as Qa, WorktreeProfileMaterializationReceipt as Qb, HarvestReport as Qc, SeatStage as Qd, PromptRegistry as Qf, eventToSnapshot as Qg, ROUTER_CLIENT_HEADER as Qh, defaultDelegateBudget as Qi, Persona as Ql, DriverRetryPolicy as Qm, localShell as Qn, CollectedAgentTurn as Qo, runCancelRequestFile as Qp, ProvisionSupervisorConnection as Qr, superviseDispatch as Qs, ExecResult as Qt, PursuitCostProvenance as Qu, coderTaskToPrompt as Qv, HarnessTranscriptReadLimits as Qw, ContinuityMode as Qx, renderLeaderboardSvg as Qy, ResourceLimit as R, RetainedRunDispatchBindingError as RC, defaultToolDetectors as RS, MountManifestEntry as RT, DelegateCodeArgs as R_, CheckRunContext as Ra, RuntimeStreamEventSink as Rb, Strategy as Rc, SuperviseTestOptions as Rd, BudgetReconcileFault as Rf, sumSandboxUsage as Rg, Inbox as Rh, storedGraphDigests as Ri, TrajectoryReport as Rl, ContinuationProfile as Rm, composeWorkerEvidence as Rn, ClaimRetainedInteractiveControlOptions as Ro, StopDecision as Rp, workerControlLogFile as Rr, BenchmarkLift as Rs, AgentEnvironmentStatus as Rt, PursuitVersions as Ru, DelegationTraceCollector as Rv, RetainedInteractiveRunHandle as Rw, Question as Rx, AxisScoresOf as Ry, RuntimeStreamEvent as S, InMemoryResultBlobStore as SC, RetainedRunSnapshot as SE, createPeerMailbox as SS, LoopDecisionPayload as ST, createDetachedTurnResumeDriver as S_, ChatTransportExecutorOptions as Sa, OtelExportStats as Sb, AgenticTask as Sc, GraphResult as Sd, WorkerTraceSeamCarrier as Sf, resolveMcpServerLaunch as Sg, ExecutorConfig as Sh, InPlaceCliExecutorOptions as Si, LoopUntil as Sl, CoordinationDeliveryEvidence as Sm, AnalystAuthoring as Sn, TurnResult as So, SupervisorNodeContext as Sp, WorkerSteerRequest as Sr, selectValidWinner as Ss, GraphSubtaskPreparation as St, assertDeclaredCheck as Su, ResearchOutput as Sv, createPushTraceSource as Sw, EventAcknowledgement as Sx, createCodexRolloutStoreReader as Sy, RuntimeFailureContext as T, Redactor as TC, StartRetainedRunInEnvironmentOptions as TE, peerMailVerbNames as TS, LoopIterationEndedPayload as TT, parseDetachedSessionRef as T_, chatTransportExecutor as Ta, RuntimeEventOtelOptions as Tb, CorpusReadbackOptions as Tc, RunGraphTestOptions as Td, workerTraceHeaders as Tf, SandboxLeafOut as Tg, CliSeam as Th, GraphRunRecord as Ti, Panel as Tl, FileCoordinationLog as Tm, AuthoredHarness as Tn, SandboxLineage as To, SupervisorToolInvocationContext as Tp, legacySupervisorRunDir as Tr, CreateScopeAnalystOptions as Ts, PeerAuditAccess as Tt, declaredCheckDigest as Tu, ResearcherProfileOptions as Tv, ActivityLog as Tw, ManagerWake as Tx, HarnessUsage as Ty, Handle as U, ExecutorFactory as UC, AnalystFindingEvent as US, SelectionReceipt as UT, DelegateResearchArgs as U_, StructuralRolloutConfig as Ua, createRuntimeEventCollector as Ub, assertStrategyContract as Uc, isPreSpawnExecutorFailure as Ud, ReservationShortfall as Uf, ToolLoopCallContext as Ug, createInbox as Uh, RollingDispatchOptions as Ui, Widen as Ul, checkVerdictOf as Um, copyUntrackedIntoClone as Un, ResolveSandboxClientOptions as Uo, createProgressTracker as Up, workerSteerRequestFile as Ur, printBenchmarkReport as Us, AgentSessionRef as Ut, SuperviseGraphPursuitOptions as Uu, createDelegationTraceCollector as Uv, HarnessTranscriptEvidence as Uw, QuestionLevel as Ux, LeaderboardRow as Uy, SpendChannel as V, AgentSpec as VC, AnalystAssignmentRecord as VS, RunProvenance as VT, DelegateFeedbackArgs as V_, CheckSourceCtx as Va, SanitizedKnowledgeReadinessReport as Vb, StrategyResult as Vc, WorkerSpawnRetryHooks as Vd, ReservationHolder as Vf, RouterRouting as Vg, InboxReceipt as Vh, DispatchStopReason as Vi, Verify as Vl, admitContinuationPolicy as Vm, CopyOptions as Vn, recoverRetainedInteractiveRun as Vo, allWorkersStalled as Vp, workerSteerAcknowledgementFile as Vr, BenchmarkTaskRow as Vs, AgentProfileRef as Vt, VersionVerdict as Vu, capDelegationTrace as Vv, HarnessTranscriptArtifact as Vw, QuestionEscalationRecord as Vx, Leaderboard as Vy, NodeId as W, ExecutorRegistry as WC, AnalystKind as WS, ValidationCtx as WT, DelegateResearchConfig as W_, StructuralRolloutMessage as Wa, createRuntimeStreamEventCollector as Wb, authorStrategy as Wc, resolveWorkerSpawnRetry as Wd, ReservationStage as Wf, ToolLoopChat as Wg, DEFAULT_SHARED_BOX_RESOURCES as Wh, freeSlots as Wi, WidenDecision as Wl, distillFindings as Wm, withUntrackedArtifacts as Wn, resolveSandboxClient as Wo, noProgressFor as Wp, workerSteerRequestsDir as Wr, runBenchmark as Ws, AgentSessionStatus$1 as Wt, SupervisePursuitError as Wu, DelegationPersistenceError as Wv, HarnessTranscriptFile as Ww, QuestionOption as Wx, PairwiseOptions as Wy, SpawnPrior as X, ExecutorNodeContext as XC, AuthoredAnalystDefinition as XS, RuntimeRunPersistenceAdapter as XT, DelegationError as X_, composeCheckSources as Xa, WorktreeCommandResult as Xb, HarvestError as Xc, SeatSelection as Xd, GraphRouteError as Xf, FeedbackStore as Xg, SharedWorkerIdentity as Xh, graphDesignerExtraTools as Xi, LoopShape as Xl, DriverProgressMark as Xm, gitWorkspace as Xn, AgentTurnInput$1 as Xo, readRunCancelRequest as Xp, RemoteWorkerEvents as Xr, loopCampaignDispatch as Xs, CreateSandboxOptions$1 as Xt, RUN_FORK_CORRELATION_KEYS as Xu, CoderOutput as Xv, persistHarnessTranscript as Xw, AuthorizedDownMessage as Xx, renderLeaderboardHtml as Xy, SpawnOpts as Y, ExecutorMaterialization as YC, AnalyzeOnSettleRoute as YS, RuntimeRunOptions as YT, DelegateUiAuditRoute as Y_, compareCheckOutcomes as Ya, WorktreeCheckRunner as Yb, HarvestCorpusOptions as Yc, SeatSegment as Yd, defaultEdgeTraversalCap as Yf, FeedbackEvent as Yg, SharedBoxStats as Yh, GraphDesignerExtraTools as Yi, DefinePersonaInput as Yl, DriverContractState as Ym, WorkspaceRun as Yn, AgentTurnBackend as Yo, cancelRun as Yp, RemoteSupervisorTree as Yr, SuperviseOptionsForDispatch as Ys, CreateAgentEnvironmentInput$1 as Yt, PursuitFork as Yu, InMemoryDelegationStore as Yv, harnessTranscriptArtifact as Yw, AuthorizeDownMessage as Yx, pairwiseSignificance as Yy, SpawnRejection as Z, MaterializedExecutionIdentity as ZC, AuthoredAnalystLimits as ZS, RuntimeRunRow as ZT, DelegationFeedbackSnapshot as Z_, defaultExtractCandidate as Za, WorktreeHarnessResult as Zb, HarvestFailure as Zc, SeatSelectionInput as Zd, PromptHandle as Zf, InMemoryFeedbackStore as Zg, sharedBoxPlacement as Zh, DelegateOptions as Zi, Outcome as Zl, DriverReentry as Zm, jjWorkspace as Zn, AgentTurnUsage as Zo, readRunCancellation as Zp, connectRemoteSupervisor as Zr, loopDispatch as Zs, ExecRequest as Zt, PursuitObserverDelivery as Zu, CoderTask as Zv, HarnessTranscriptMetadata as Zw, ContinuationInstruction as Zx, renderLeaderboardMarkdown as Zy, RunAgentTaskOptions as _, SpawnForestTree as _C, RetainedRunEnvironmentAdmission as _E, PeerMailRefusal as _S, AgentRunSpec as _T, DetachedTurn as __, Scope as _a, SandboxEvidenceRetentionPort as _b, connectStdioMcp as _c, EdgeDeliveryOutcome as _d, createScope as _f, BridgeSeam as _g, DelegateHandlerOptions as _h, InteractiveWorkerKeyInput as _i, Fanout as _l, CoordinationTransportOptions as _m, SurfaceReader as _n, OpenSandboxRunBeforeStartContext as _o, ObserveSupervisorNodeEvent as _p, searchPresets as _r, fanout as _s, upstreamUnavailableSignal as _t, LeaderboardSpec as _u, UiFindingSeverity as _v, WorkerTraceUnavailableReason as _w, CodexTokenUsage as _x, CodexRolloutStoreReader as _y, AgentKnowledgeProvider as a, SqlRunStoreOptions as aC, RecoverRetainedRunOptions as aE, MapItemFailurePolicy as aS, ProviderNativeCapturePhase as aT, SettleDetachedCoderTurnOptions as a_, RecursiveReservationPolicy as aa, bestSoFar as ab, inlineSandboxClient as ac, PursuitProjection as ad, createFileRunContext as af, createAgentEnvironmentProviderRegistry as ag, environmentReader as ah, bestProfileFor as ai, defaultAnalystInstruction as al, FinalizeContext as am, computeFindingId$1 as an, structuralRollout as ao, formatPromptHandle as ap, parseWorkerToolTraceArtifact as ar, PrivateCasOptions as as, RootProviderModelEvidence as at, ShapeRegistry as au, DelegationStatusArgs as av, ExecutorAccounting as aw, captureWorktreeDiff as ax, verdictFromJudgeScore as ay, RuntimeSession as b, replaySpawnTree as bC, RetainedRunIntentAdmission as bE, PeerMailboxOptions as bS, ExecCtx as bT, DriveTurnTick as b_, ChatCompletionsTransport as ba, OtelAttribute as bb, AgenticRunResult as bc, GraphEdgeCapError as bd, ScopeArgs as bf, envKeyProvider as bg, validateDelegateArgs as bh, workerFromInteractiveProvider as bi, FanoutWinnerSelector as bl, CoordinationHttpOptions as bm, fsSurfaceReader as bn, SandboxRun as bo, SupervisorAgentDeps as bp, WorkerCancellation as br, panel as bs, CoordinationTools as bt, DeclaredCheckPlacement as bu, KnowledgeUpdate as bv, ToolStepInput as bw, AwaitWakeInput as bx, CodexStoreDelta as by, AgentTaskContext as c, D1StmtLike as cC, RetainedInteractiveEnvironmentAdmission as cE, MapTraversalEvent as cS, ProviderWorkspaceCaptureReceipt as cT, detachedSessionDelegate as c_, RootSegmentEntry as ca, WaterfallCollector as cb, InProcessSandboxClientOptions as cc, PursuitStatus as cd, SupervisorSpanAttributes as cf, ProviderLeafOut as cg, McpServer as ch, profileRegistry as ci, AssertTraceDerivedFindings as cl, bestDelivered as cm, createVerifierEnvironment as cn, EvolutionReport as co, promptHandle as cp, SqlRunContextOptions as cr, trajectoryReport as cs, DriverAttemptRecord as ct, DefinedLeaderboard as cu, FeedbackRefersTo as cv, ExecutorResult as cw, LocalHarnessResult as cx, CompletionPolicy as cy, AgentTaskStatus as d, materializeTreeView as dC, RetainedRunAdmission as dE, PEER_MAIL_WIRE_KEY as dS, ProviderWorkspaceRetentionContext as dT, FleetHandle as d_, Supervisor as da, createWaterfallCollector as db, LocalMcpMaterialization as dc, ObserverJournal as dd, SupervisorSpanRecorder as df, UnavailablePausePolicy as dg, createMcpServer as dh, PatchDeliverableOptions as di, CorpusFilter as dl, pickBestDelivered as dm, createTangleSandboxExactProcessProvider as dn, StrategyTournament as do, assertCoordinationBinding as dp, SEARCH_SPEC_CORRELATION_KEY as dr, registerShape as ds, DriverContinuationRecord as dt, LeaderboardBenchmarkAdapter as du, UiAuditorDelegationOutput as dv, HeldForContinuation as dw, CodexExecutionEvidence as dx, deterministicCompletion as dy, canonicalFindingEvent as eC, NativeContextContinuationExecution as eE, DownMessageDeliveryAttempt as eS, RetainedHarnessTranscriptCapture as eT, CoderReview as e_, ResultBlobStore as ea, AnytimeReport as eb, localSandboxClient as ec, PursuitNodePlacement as ed, subscriptionUsageLimitSignal as ef, SharedBoxProcess as eg, ResolvedSpawnResourcePath as eh, ProvisionedSupervisor as ei, Observation as el, ReentryContinuity as em, PlacementInfo as en, modelAuthoredChecks as eo, analyzesFindingsReportPrompt as ep, TrajectoryAnalysis as er, collectAgentTurn as es, TreeView as et, PersonaExecutors as eu, DelegationHistoryResult as ev, ProfileMaterializationReceipt as ew, DiffOptions as ex, CheckVerdict as ey, BackendErrorDetail as f, SpawnForest as fC, RetainedRunAdmissionHook as fE, PeerMailEnvelope as fS, ProviderWorkspaceRetentionPort as fT, FleetWorkspaceExecutorOptions as f_, SupervisorOpts as fa, RunAgentRoundsOptions as fb, MaterializeLocalMcpOptions as fc, ObserverRecord as fd, createSupervisorSpanRecorder as ff, ProviderPlacement as fg, DELEGATE_DESCRIPTION as fh, patchDelivered as fi, CorpusRecord as fl, runFinalizer as fm, BoxSurfaceReaderOptions as fn, TournamentCell as fo, CoordinationBinding as fp, SearchSpec as fr, definePersona as fs, DriverFailureClass as ft, LeaderboardFlagSpec as fu, delegationProfiles as fv, HeldRelease as fw, DEFAULT_LOCAL_HARNESS as fx, sentinelCompletion as fy, OpenAIChatToolChoice as g, SpawnForestNode as gC, RetainedRunEffect as gE, PeerMailReadout as gS, UsageEvent as gT, DetachedSessionRefParts as g_, ResumedWork as ga, SandboxEvidenceRetentionError as gb, StdioMcpServerSpec as gc, AgentGraph as gd, settledToIteration as gf, BridgeModelCredential as gg, DelegateError as gh, InteractiveWorkerEnvironment as gi, EqualKVerdict as gl, CoordinationReadAccess as gm, SurfaceReadOutcome as gn, Deliverable as go, DriveHarnessOwnerContext as gp, compileSearchSpec as gr, renderCorpusToInstructions as gs, summarizeDriverAttempts as gt, LeaderboardScore as gu, UiFindingScreenshot as gv, WorkerTraceEvidence as gw, localHarnessExecutable as gx, CodexRolloutSession as gy, OpenAIChatTool as h, SpawnForestMissingTree as hC, RetainedRunDispatchedAdmission as hE, PeerMailOutcome as hS, TokenUsageProvenance as hT, createSiblingSandboxExecutor as h_, ResumedKeyState as ha, SandboxEvidenceReceipt as hb, StdioMcpConnection as hc, verifyObserverRecords as hd, createRootHandle as hf, BridgeHarnessStore as hg, DelegateArgs as hh, createWorktreeCliExecutor as hi, EqualKOnCostOptions as hl, CoordinationPublicAddress as hm, SurfaceReadBox as hn, strategyTournament as ho, DriveHarness as hp, assertSearchSpec as hr, InMemoryCorpus as hs, classifyDriverFailure as ht, LeaderboardScenario as hu, UiFinding as hv, WorkerInteractiveUnavailableReason as hw, harnessSupportsReasoningEffort as hx, CodexRolloutIdentity as hy, AgentExecutionBackend as i, SqlRunOwnershipError as iC, RecoverRetainedRunIntentOptions as iE, downMessageRefusalReasons as iS, ProviderCheckpointCaptureContext as iT, DetachedWinnerSelection as i_, WorkspaceCheckpointMarker as ia, areaUnderCurve as ib, isTerminalDecision as ic, PursuitNodeUsage as id, RunContextLease as if, AgentEnvironmentProviderRegistry as ig, SpawnResourceReader as ih, ProfileRunRecord as ii, ObserveOptions as il, DeliveredOutput as im, WorkspaceRequest as in, selectBestIndex as io, dumbContinuationPassPrompt as ip, captureWorkerTraceEvidence as ir, PrivateCasOffloadReport as is, ProviderModelExecutionEvidence as it, ShapeContext as iu, DelegationStatus as iv, Executor as iw, WorktreeHandle as ix, mapExecutorResult as iy, TRACE_ROOT_SCHEMA as j, ConfigError as jC, BusEvent as jS, LoopSandboxPlacement as jT, DelegationResumeTick as j_, asAuthoredProfile as ja, generateSpanId as jb, depthStrategy as jc, superviseWithTestBrain as jd, WorkerEventPage as jf, sandboxProgressEvents as jg, SandboxSeam as jh, graphRegistry as ji, RenderCorpusToInstructions as jl, ContinuationContext as jm, attachWorker as jn, S3PrivateCasStore as jo, AllWorkersStalledOptions as jp, safeWorkerFile as jr, observationFromRegistry as js, SuperviseProfileEntry as jt, IsolatedCheckResult as ju, mergeTraceEnv as jv, WorkerProgress as jw, JsonScalar as jx, CodeModeToolContext as jy, EvidencePendingEvent as k, AgentEvalErrorCode as kC, McpToolDescriptor as kS, LoopPlanPayload as kT, DelegationResumeContext as k_, ProfileRichness as ka, createOpenInferenceFileExporter as kb, SurfaceScore as kc, supervise as kd, WorkerEventCursor as kf, mapSandboxEvent as kg, RouterSeam as kh, graphDigest as ki, Pipeline as kl, CheckRead as km, WorkerInteractiveBinding as kn, AcquireOptions as ko, SupervisorProfile as kp, readWorkerSteerAcknowledgement as kr, createScopeAnalyst as ks, SpawnRefusal as kt, IsolatedCheckBoxEvidence as ku, TraceContext as kv, ScopeProgressInput as kw, GateDecision as kx, CodeModeStore as ky, AgentTaskRunResult as l, SqlAdapter as lC, RetainedInteractiveIntentAdmission as lE, AUTHORITY_MARKERS as lS, ProviderWorkspaceCaptureResult as lT, settleDetachedCoderTurn as l_, RootSignal as la, WaterfallReport as lb, inProcessSandboxClient as lc, projectPursuit as ld, SupervisorSpanOptions as lf, ProviderPromptOptions as lg, McpServerOptions as lh, profileRunsForName as li, CombinatorShape as ll, collectDelivered as lm, CreateTangleSandboxExactProcessProviderOptions as ln, EvolutionStrategy as lo, supervisorAgent as lp, createFencedSqlRunContext as lr, builtinShapes as ls, DriverAttemptStop as lt, LeaderboardBenchScore as lu, ResearchOutputShape as lv, ExecutorTeardownWarning as lw, RunLocalHarnessOptions as lx, CompletionVerdict as ly, OpenAIChatResponseFormat as m, SpawnForestInDoubtNode as mC, RetainedRunCancellation as mE, PeerMailLimits as mS, ExecutorToolCall as mT, createFleetWorkspaceExecutor as m_, ReenteredWorkers as ma, SandboxEvidenceContext as mb, McpSpawnFault as mc, observerRecordDigest as md, createSupervisor as mf, cliWorktreeExecutor as mg, DELEGATE_TOOL_NAME as mh, WorktreePatchArtifact as mi, EqualKOnCost as ml, CoordinationMcpHandle as mm, SurfaceDiff as mn, runStrategyEvolution as mo, CoordinationVerbs as mp, SearchSpecOwnedOption as mr, FileCorpus as ms, DriverRepromptRefusal as mt, LeaderboardRunContext as mu, UI_LENSES as mv, WorkerInteractiveSession as mw, LocalHarness as mx, CodexForkBoundary as my, AgentBackendContext as n, parseAuthoredAnalystDefinition as nC, NativeContextContinuationInput as nE, DownMessageEvent as nS, resolveHarnessTranscriptCapture as nT, DelegateRunCtx as n_, SpawnJournal as na, AnytimeTaskCurve as nb, TerminalDecision as nc, PursuitNodeProjection as nd, InMemoryRunContextOptions as nf, sharedWorkerClientName as ng, SpawnResourceBytes as nh, provisionSupervisor as ni, ObservationError as nl, UNPROVEN_CONTINUITY as nm, SandboxEvent$1 as nn, resolveEntrySymbol as no, delegatesWorkerBriefPrompt as np, WORKER_TOOL_TRACE_SCHEMA_VERSION as nr, PrivateCasArtifactPort as ns, NoWinnerError as nt, RunPersonifiedOptions as nu, DelegationProgress as nv, UnknownMaterializationReason as nw, GitRunner as nx, ExecutorResultMapping as ny, AgentRuntimeEvent as o, openSqlRunStore as oC, RecoverRetainedRunResult as oE, MapOnSettleRoute as oS, ProviderWorkspaceAttemptProvenance as oT, UiAuditorDelegate as o_, RootHandle as oa, plateauLength as ob, InProcessOnPrompt as oc, PursuitRunProjection as od, createInMemoryRunContext as of, resolveAgentEnvironmentProvider as og, hostDirectoryReader as oh, loadProfile as oi, observe as ol, FinalizerSettled as om, makeFinding$1 as on, visibleCheckScore as oo, kernelPromptRegistry as op, workerTraceAnalysisStore as or, createPrivateCasArtifactPort as os, RootStreamReceipt as ot, ProviderAsSandboxClientOptions as ou, DelegationStatusResult as ov, ExecutorCancellation as ow, createWorktree as ox, CompletionAnalyst as oy, KnowledgeReadinessDecision as p, SpawnForestEvent as pC, RetainedRunCancelOptions as pE, PeerMailEvent as pS, ExecutorProgressEvent as pT, SiblingSandboxExecutorOptions as p_, Agent as pa, runAgentRounds as pb, McpListedTool as pc, ObserverRecordKind as pd, DEFAULT_MAX_DEPTH as pf, cliInPlaceExecutor as pg, DELEGATE_INPUT_SCHEMA as ph, WorktreeCliExecutorOptions as pi, EqualKArm as pl, CoordinationAuthentication as pm, HarvestSurfaceDiffsOptions as pn, TournamentRow as po, CoordinationToolFace as pp, SearchSpecInputs as pr, runPersonified as ps, DriverLoopRecord as pt, LeaderboardIterationInfo as pu, UI_FINDING_SEVERITIES as pv, Runtime as pw, LOCAL_HARNESSES as px, stopSentinel as py, RetainedExecutionState as q, ExecutionBindingReceipt as qC, AnalystRunContext as qS, RuntimeRunCost as qT, DelegateUiAuditConfig as q_, VisibleCheck as qa, sanitizeRuntimeStreamEvent as qb, strategyAuthorContract as qc, SuperviseRegistry as qd, ReserveOptions as qf, ToolLoopMessageRecord as qg, SharedBoxPlacement as qh, DesignerRunGraphEnv as qi, WinnerStrategy as ql, passedItems as qm, Workspace as qn, assertModelAllowed as qo, RunCancelRequest as qp, RemoteSupervisorAgent as qr, LoopOptionsForDispatch as qs, CheckpointRef as qt, superviseGraphPursuit as qu, FileDelegationStore as qv, ReadableEnvironment as qw, QuestionUrgency as qx, ScoreOf as qy, AgentBackendInput as r, SqlRunLease as rC, ReconnectRetainedRunOptions as rE, WorkerResumeContext as rS, retainHarnessTranscript as rT, DetachedSessionDelegateOptions as r_, TraceRootReceipt as ra, anytimeReport as rb, defaultSelectWinner as rc, PursuitNodeTiming as rd, RunContext as rf, AgentEnvironmentProviderRef as rg, SpawnResourceRead as rh, ProfileRegistryDir as ri, ObserveInput as rl, composeReentryTask as rm, SandboxInstance$1 as rn, sandboxCheckRunner as ro, dumbContinuationFailPrompt as rp, WorkerToolTraceArtifact as rr, PrivateCasDurableStore as rs, ProviderModelAttemptEvidence as rt, ShapeBudget as ru, DelegationResultPayload as rv, EnvironmentTeardownReceipt as rw, RemoveWorktreeOptions as rx, gateOnDeliverable as ry, AgentRuntimeEventSink as s, D1DatabaseLike as sC, RetainedInteractiveAdmission as sE, MapSpawnMarker as sS, ProviderWorkspaceCaptureProvenance as sT, coderTaskFromArgs as s_, RootSegment as sa, renderAnytimeTable as sb, InProcessPromptCtx as sc, PursuitRunTotals as sd, withRunContext as sf, ProviderExecutorOptions as sg, resolveSpawnResourcePaths as sh, pickBestProfile as si, renderReport as sl, SupervisorFinalizer as sm, VerifierEnvironmentOptions as sn, EvolutionAuthor as so, naiveContinuationPrompt as sp, FencedSqlRunContext as sr, equalKOnCost as ss, SupervisedResult as st, providerAsSandboxClient as su, FeedbackRating as sv, ExecutorCancellationRequest as sw, removeWorktree as sx, CompletionEvidence as sy, AgentAdapter as t, normalizeAnalyzeOnSettle as tC, NativeContextContinuationHandle as tE, DownMessageDeliveryOutcome as tS, RetainedHarnessTranscriptDescriptor as tT, CoderReviewer as t_, SpawnEvent as ta, AnytimeStrategySummary as tb, TERMINAL_DECISIONS as tc, PursuitNodePlatform as td, InMemoryRunContext as tf, sharedBoxRefusal as tg, SPAWN_RESOURCE_PATH_MAX_BYTES as th, SupervisorCleanupReceipt as ti, ObservationAnalysis as tl, ReentryTaskInput as tm, ResourceRequest as tn, officialChecksFromMeta as to, createPromptRegistry as tp, analyzeTrace as tr, streamAgentTurn as ts, FleetYield as tt, RunPersonified as tu, DelegationProfile as tv, RootMaterialization as tw, DiffResult as tx, DeliverableSpec as ty, AgentTaskSpec as u, d1ToSqlAdapter as uC, RetainedInteractiveStartedAdmission as uE, DEFAULT_PEER_MAIL_LIMITS as uS, ProviderWorkspaceEntryMetadata as uT, DelegationExecutor as u_, SteerableRootHandle as ua, WaterfallSpan as ub, HttpMcpServerSpec as uc, FileObserverJournal as ud, SupervisorSpanOutcome as uf, providerAsExecutor as ug, createInProcessTransport as uh, recordProfileRun as ui, Corpus as ul, finalizeBestDelivered as um, SandboxControlClient as un, StrategyEvolutionConfig as uo, supervisorAgentWithTestBrain as up, CompiledSearchSpec as ur, createShapeRegistry as us, DriverAttemptsExhaustedError as ut, LeaderboardBenchTask as uu, UiAuditLensFilter as uv, HeldEnvironment as uw, runLocalHarness as ux, completionAuthorizes as uy, RunAgentTaskStreamOptions as v, loadSpawnForest as vC, RetainedRunEventOptions as vE, PeerMailSendInput as vS, DefaultVerdict$2 as vT, DetachedTurnResumeDriverOptions as v_, UnconfirmedTeardown as va, captureBeforeDestroy as vb, materializeLocalMcp as vc, EdgeTraversal as vd, DEFAULT_BUDGET_STOP_HOLD_MS as vf, KeyProvider as vg, DelegateResult as vh, InteractiveWorkerOptions as vi, FanoutOptions as vl, serveCoordinationMcp as vm, WatchedSurface as vn, OpenSandboxRunOptions as vo, ResolveDriveHarness as vp, searchSpecDigest as vr, flatWidenGate as vs, BlockedToolReport as vt, defineLeaderboard as vu, UiLens as vv, SessionMessageLike as vw, parseCodexTokenUsage as vx, CodexRolloutStoreRef as vy, RuntimeFailureCode as w, contentAddress as wC, RetainedRunTurnInput as wE, peerMailTools as wS, LoopIterationDispatchPayload as wT, formatDetachedSessionRef as w_, ChatWorkerSeamOptions as wa, OtelSpan as wb, ArtifactHandle as wc, RunGraphOptions as wd, workerTraceEnv as wf, secretEnvOfMcpServer as wg, CliInPlaceSeam as wh, GraphRegistryDir as wi, LoopUntilState as wl, CoordinationOwnerId as wm, failuresAnalyst as wn, BranchCapableBox as wo, SupervisorToolDescriptor as wp, cancelWorker as wr, widen as ws, MakeWorkerAgent as wt, declaredCheckDeliverable as wu, ResearchTask as wv, sandboxSessionTraceSource as ww, ManagerReentryState as wx, readCodexRolloutSession as wy, RuntimeSessionStore as x, FileSpawnJournal as xC, RetainedRunReplayPoint as xE, claimsAuthority as xS, Iteration as xT, RunDetachedTurnOptions as x_, ChatSessionStore as xa, OtelExportConfig as xb, AgenticSurface as xc, GraphNode as xd, WorkerTraceResolver as xf, mcpSecretEnvMetadataKey as xg, createExecutorRegistry as xh, WorkerInteractiveAdmission as xi, FlatWidenGate as xl, CoordinationRejectReason as xm, harvestSurfaceDiffs as xn, SandboxRunAbortError as xo, SupervisorAgentTestDeps as xp, WorkerSteerAcknowledgement as xr, pipeline as xs, CoordinationToolsOptions as xt, DeclaredCheckStateCapture as xu, MultiHarnessResearcherFanoutOptions as xv, TraceSource as xw, CoordinationEvent as xx, addHarnessUsage as xy, RuntimeCanonicalStreamEvent as y, FileResultBlobStore as yC, RetainedRunHandle as yE, PeerMailbox as yS, Driver as yT, DriveTurnCapableBox as y_, WidenGate as ya, LoopSpanNode as yb, AgenticOptions as yc, GraphEdge as yd, SUBTREE_RESULT_LIMIT as yf, ResolvedMcpServerLaunch as yg, createDelegateHandler as yh, InteractiveWorkerResult as yi, FanoutSynthesis as yl, CoordinationHttpAudit as ym, boxSurfaceReader as yn, OpenSandboxRunPromptOptions as yo, ResolveSupervisorTools as yp, WorkerCancelRequest as yr, loopUntil as ys, CoordinationStats as yt, DeclaredCheck as yu, KnowledgeItem as yv, SessionTraceBox as yw, CodexExecutionPolicy as yx, CodexRolloutTurn as yy, ResourceSpend as z, RuntimeRunStateError as zC, watchTrace as zS, MountRecorder as zT, DelegateCodeConfig as z_, CheckRunner as za, RuntimeStreamEventSummary as zb, StrategyArtifacts as zc, ResolvedWorkerSpawnRetry as zd, LeakedReservation as zf, RouterResponseReceipt as zg, InboxLease as zh, taskShapeDigest as zi, TrajectoryReportFn as zl, PanelFinding as zm, settledWorkerOut as zn, claimRetainedInteractiveControl as zo, StopRule as zp, workerInboxFile as zr, BenchmarkReport as zs, AgentEnvironmentSummary as zt, SettledPursuitVersion as zu, DelegationTraceSpan as zv, RetainedInteractiveStartMaterial as zw, QuestionDecision as zx, GroupOf as zy };
-//# sourceMappingURL=types-CrNWif8-.d.ts.map
+export { NoWinnerError as $, CoordinationEvent as $_, strategyTournament as $a, RetainedInteractiveAdmissionHook as $b, TrajectoryNode as $c, formatPromptHandle as $d, CoordinationLog as $f, PairwiseOptions as $g, researcherProfile as $h, ChatTransportExecutorOptions as $i, PursuitVersions as $l, DelegateRunCtx as $m, SqlRunContextOptions as $n, createScopeAnalyst as $o, SharedBoxCloseReceipt as $p, GraphRunRecord as $r, depthStrategy as $s, createVerifierEnvironment as $t, WorkerSpawnRetryAttempt as $u, createPeerMailbox as $v, LoopTraceEvent as $x, defaultRedactor as $y, TraceRootArtifact as A, RetainedRunCancelOptions as AS, OtelSpan as A_, filterAuthoredAsserts as Aa, HeldEnvironment as Ab, AssertTraceDerivedFindings as Ac, BudgetReadout as Ad, RunCancelRequest as Af, CodexRolloutStoreRef as Ag, DelegationError as Ah, SpawnJournal as Ai, LeaderboardScenario as Al, SandboxToolPartState as Am, settledWorkerOut as An, PrivateCasDurableStore as Ao, createExecutorRegistry as Ap, RemoteWorkerEvents as Ar, InProcessSandboxClientOptions as As, AgentEnvironmentStatus as At, EdgeDeliveryOutcome as Au, ContinuityMode as Av, ExecutorProgressEvent as Ax, runLocalHarness as Ay, Handle as B, RetainedRunStartMaterial as BS, RuntimeTelemetryOptions as B_, AgentTurnUsage as Ba, TraceSource as Bb, FanoutWinnerSelector as Bc, RootStreamRecord as Bd, FinalizeContext as Bf, CodeModeTool as Bg, ResearchOutputShape as Bh, SupervisorOpts as Bi, declaredCheckDigest as Bl, RouterRouting as Bm, WorkspaceRun as Bn, renderCorpusToInstructions as Bo, SandboxSeam as Bp, loadProfile as Br, materializeLocalMcp as Bs, CreateAgentEnvironmentInput$1 as Bt, runGraph as Bu, AUTHORITY_MARKERS as Bv, LoopEndedPayload as Bx, SpawnForestEvent as By, RuntimeFailureCause as C, RecoverRetainedRunResult as CS, SandboxEvidenceContext as C_, StructuralRolloutResult as Ca, EnvironmentTeardownReceipt as Cb, ObservationAnalysis as Cc, SupervisorSpanOutcome as Cd, ProgressView as Cf, deterministicCompletion as Cg, DelegateCodeArgs as Ch, GraphDesignerExtraTools as Ci, DefinedLeaderboard as Cl, envKeyProvider as Cm, readWorkerInteractiveBinding as Cn, recoverRetainedInteractiveRun as Co, McpServer as Cp, supervisorRunDir as Cr, LocalSandboxClientOptions as Cs, SuperviseProfileEntry as Ct, projectPursuit as Cu, QuestionPolicy as Cv, ProviderWorkspaceAttemptProvenance as Cx, AnalyzeOnSettleRoute as Cy, RetainedPendingCause as D, RetainedInteractiveStartedAdmission as DS, OtelExportConfig as D_, composeCheckSources as Da, ExecutorCancellationRequest as Db, defaultAnalystInstruction as Dc, DeadlineCheckIn as Dd, anyOf as Df, CodexRolloutIdentity as Dg, DelegateUiAuditArgs as Dh, delegate as Di, LeaderboardFlagSpec as Dl, secretEnvOfMcpServer as Dm, WorkerEvidenceInput as Dn, profileChatClient as Do, DelegateHandlerOptions as Dp, RemoteSupervisorAgent as Dr, inlineSandboxClient as Ds, AgentEnvironmentEvent$1 as Dt, ObserverRecordKind as Du, AuthorizeDownMessage as Dv, ProviderWorkspaceEntryMetadata as Dx, CodexExecutionEvidence as Dy, EvidencePendingEvent as E, RetainedInteractiveIntentAdmission as ES, OtelAttribute as E_, compareCheckOutcomes as Ea, ExecutorCancellation as Eb, ObserveOptions as Ec, WorkerTraceResolver as Ed, allWorkersStalled as Ef, CodexForkBoundary as Eg, DelegateResearchConfig as Eh, defaultDelegateBudget as Ei, LeaderboardBenchmarkAdapter as El, resolveSecretEnv as Em, VERIFY_TAIL_CHARS as En, resolveSandboxClient as Eo, DelegateError as Ep, writeWorkerSteer as Er, defaultSelectWinner as Es, AgentEnvironmentCapabilities$1 as Et, ObserverRecord as Eu, questionEscalationTargets as Ev, ProviderWorkspaceCaptureResult as Ex, DefinedAnalystRecord as Ey, ResourceLimit as F, RetainedRunEventOptions as FS, padTraceId as F_, selectBestIndex as Fa, WorkerInteractiveUnavailableReason as Fb, EqualKArm as Fc, ReservationShortfall as Fd, ReentryContinuity as Ff, harnessUsageIsEmpty as Fg, DelegationResultPayload as Fh, RootSegment as Fi, DeclaredCheckPlacement as Fl, SandboxUsageLedger as Fm, withUntrackedArtifacts as Fn, trajectoryReport as Fo, CliWorktreeBridgeSeam as Fp, SupervisorCleanupReceipt as Fr, McpListedTool as Fs, AgentSessionStatus$1 as Ft, GraphResult as Fu, WorkerResumeContext as Fv, DefaultVerdict$2 as Fx, SqlRunOwnershipError as Fy, Settled as G, sanitizeKnowledgeReadinessReport as G_, EvolutionAuthor as Ga, ExecutorProgress as Gb, PanelSpec as Gc, PromptHandle as Gd, CoordinationMcpHandle as Gf, createCodeModeTools as Gg, UiFindingSeverity as Gh, Scope as Gi, IsolatedCheckOptions as Gl, ToolLoopCompactionOptions as Gm, TrajectoryAnalysis as Gn, pipeline as Go, createSteerableSandboxSession as Gp, InteractiveWorkerEnvironment as Gr, AgenticTool as Gs, PlacementInfo as Gt, workerFromBackend as Gu, PeerMailLimits as Gv, LoopPlanDescription as Gx, loadSpawnForest as Gy, NodeSnapshot as H, StartRetainedRunInEnvironmentOptions as HS, SanitizedKnowledgeRequirement as H_, StreamAgentTurnOptions as Ha, ActivityLog as Hb, LoopUntilState as Hc, readRootStreamReceipt as Hd, SupervisorFinalizer as Hf, CodeModeToolsOptions as Hg, UiAuditorDelegationOutput as Hh, ReenteredWorkers as Hi, readDeclaredCheck as Hl, ToolLoopCallContext as Hm, jjWorkspace as Hn, flatWidenGate as Ho, SandboxSteeringOptions as Hp, profileRegistry as Hr, AgenticRunResult as Hs, ExecRequest as Ht, supervise as Hu, PEER_MAIL_WIRE_KEY as Hv, LoopIterationEndedPayload as Hx, SpawnForestMissingTree as Hy, ResourceSpend as I, RetainedRunHandle as IS, RuntimeEventCollector as I_, structuralRollout as Ia, WorkerTraceEvidence as Ib, EqualKOnCostOptions as Ic, ReservationStage as Id, ReentryTaskInput as If, readCodexRolloutSession as Ig, DelegationStatus as Ih, RootSegmentEntry as Ii, DeclaredCheckStateCapture as Il, extractLlmCallEvent as Im, GitWorkspaceOptions as In, definePersona as Io, CliWorktreeSeam as Ip, provisionSupervisor as Ir, McpSpawnFault as Is, AgentTurnResult$2 as It, GraphTopology as Iu, MapItemFailurePolicy as Iv, Driver as Ix, openSqlRunStore as Iy, SpawnRejection as J, WorktreeCommandResult as J_, StrategyEvolutionConfig as Ja, WorkerProgress as Jb, RenderCorpusToInstructionsOptions as Jc, analyzesFindingsReportPrompt as Jd, CoordinationTransportOptions as Jf, GroupOf as Jg, KnowledgeUpdate as Jh, WorkerEventCursor as Ji, JudgedPursuitVersion as Jl, FeedbackEvent as Jm, parseWorkerToolTraceArtifact as Jn, widen as Jo, InboxLease as Jp, InteractiveWorkerResult as Jr, RunAgenticOptions as Js, SandboxInstance$1 as Jt, SuperviseOptions as Ju, PeerMailRefusal as Jv, LoopSandboxPlacement as Jx, FileSpawnJournal as Jy, SpawnOpts as K, InPlaceHarnessResult as K_, EvolutionReport as Ka, ScopeProgressInput as Kb, PanelVerdict as Kc, PromptRegistry as Kd, CoordinationPublicAddress as Kf, runCodeMode as Kg, UiLens as Kh, UnconfirmedTeardown as Ki, IsolatedCheckResult as Kl, ToolLoopMessageRecord as Km, analyzeTrace as Kn, selectValidWinner as Ko, AuthorityInboxMessage as Kp, InteractiveWorkerKeyInput as Kr, ArtifactHandle as Ks, ResourceRequest as Kt, AuthorizedSpawn as Ku, PeerMailOutcome as Kv, LoopPlanPayload as Kx, FileResultBlobStore as Ky, Spend as L, RetainedRunIntentAdmission as LS, RuntimeStreamEventCollector as L_, visibleCheckScore as La, WorkerTraceUnavailableReason as Lb, EqualKVerdict as Lc, ReservationTicket as Ld, UNPROVEN_CONTINUITY as Lf, HarnessUsage as Lg, DelegationStatusResult as Lh, RootSignal as Li, assertDeclaredCheck as Ll, sumSandboxUsage as Lm, Shell as Ln, runPersonified as Lo, ProviderSeam as Lp, ProfileRegistryDir as Lr, StdioMcpConnection as Ls, AnalystFinding$1 as Lt, RunGraphOptions as Lu, MapOnSettleRoute as Lv, ExecCtx as Lx, SqlAdapter as Ly, Budget as M, RetainedRunDispatchedAdmission as MS, createOtelExporter as M_, officialChecksFromMeta as Ma, HeldRelease as Mb, Corpus as Mc, ReservationFloor as Md, cancelRun as Mf, CodexStoreDelta as Mg, DelegationHistoryArgs as Mh, WorkspaceCheckpointMarker as Mi, LeaderboardSpec as Ml, mapSandboxEvent as Mm, CopyOptions as Mn, PrivateCasOptions as Mo, createExecutor as Mp, ProvisionSupervisorConnection as Mr, HttpMcpServerSpec as Ms, AgentProfile$2 as Mt, GraphEdge as Mu, DownMessageDeliveryAttempt as Mv, TokenUsageProvenance as Mx, LocalHarness as My, BudgetOverspend as N, RetainedRunEffect as NS, loopEventToOtelSpan as N_, resolveEntrySymbol as Na, Runtime as Nb, CorpusFilter as Nc, ReservationHolder as Nd, readRunCancelRequest as Nf, addHarnessUsage as Ng, DelegationHistoryEntry as Nh, RecursiveReservationPolicy as Ni, defineLeaderboard as Nl, mapSandboxToolEvent as Nm, UntrackedCopyStats as Nn, createPrivateCasArtifactPort as No, CliInPlaceSeam as Np, ProvisionSupervisorRequest as Nr, LocalMcpMaterialization as Ns, AgentSession as Nt, GraphEdgeCapError as Nu, DownMessageDeliveryOutcome as Nv, UsageEvent as Nx, CodexTokenUsage as Ny, TRACE_ROOT_SCHEMA as O, RetainedRunAdmission as OS, OtelExportStats as O_, defaultExtractCandidate as Oa, ExecutorResult as Ob, observe as Oc, BudgetPool as Od, noProgressFor as Of, CodexRolloutSession as Og, DelegateUiAuditConfig as Oh, ResultBlobStore as Oi, LeaderboardIterationInfo as Ol, SandboxLeafOut as Om, closingWorkerNote as On, profileOptimizerModelCall as Oo, DelegateResult as Op, RemoteSupervisorReader as Or, InProcessOnPrompt as Os, AgentEnvironmentProvider$1 as Ot, observerRecordDigest as Ou, AuthorizedDownMessage as Ov, ProviderWorkspaceRetentionContext as Ox, LocalHarnessResult as Oy, BudgetViolation as P, RetainedRunEnvironmentAdmission as PS, padSpanId as P_, sandboxCheckRunner as Pa, WorkerInteractiveSession as Pb, CorpusRecord as Pc, ReservationRejection as Pd, readRunCancellation as Pf, createCodexRolloutStoreReader as Pg, DelegationProgress as Ph, RootHandle as Pi, DeclaredCheck as Pl, SandboxServedBackend as Pm, copyUntrackedIntoClone as Pn, equalKOnCost as Po, CliSeam as Pp, ProvisionedSupervisor as Pr, MaterializeLocalMcpOptions as Ps, AgentSessionRef as Pt, GraphNode as Pu, DownMessageEvent as Pv, AgentRunSpec as Px, CodexExecutionPolicy as Py, FleetYield as Q, AwaitWakeInput as Q_, runStrategyEvolution as Qa, RecoverRetainedInteractiveRunOptions as Qb, SteerContext as Qc, dumbContinuationPassPrompt as Qd, CoordinationDeliveryEvidence as Qf, LeaderboardRow as Qg, ResearcherProfileOptions as Qh, ChatSessionStore as Qi, PursuitVersionStop as Ql, CoderReviewer as Qm, FencedSqlRunContext as Qn, buildSteerContext as Qo, DEFAULT_SHARED_BOX_WORKERS as Qp, GraphRegistryDir as Qr, breadthStrategy as Qs, VerifierEnvironmentOptions as Qt, ResolvedWorkerSpawnRetry as Qu, claimsAuthority as Qv, LoopTraceEmitter as Qx, Redactor as Qy, SpendChannel as R, RetainedRunReplayPoint as RS, RuntimeStreamEventSink as R_, AgentTurnBackend as Ra, SessionMessageLike as Rb, FanoutOptions as Rc, ReserveOptions as Rd, composeReentryTask as Rf, decodeHarnessUsage as Rg, FeedbackRating as Rh, SteerableRootHandle as Ri, checkProgramDigest as Rl, RouterResponseReceipt as Rm, Workspace as Rn, FileCorpus as Ro, RouterSeam as Rp, ProfileRunRecord as Rr, StdioMcpServerSpec as Rs, CheckpointRef as Rt, RunGraphTestOptions as Ru, MapSpawnMarker as Rv, Iteration as Rx, materializeTreeView as Ry, RuntimeStreamEvent as S, RecoverRetainedRunOptions as SS, runAgentRounds as S_, StructuralRolloutPolicy as Sa, UnknownMaterializationReason as Sb, Observation as Sc, SupervisorSpanOptions as Sd, PlateauOptions as Sf, completionAuthorizes as Sg, SubmitOutput as Sh, DesignerToolsEnv as Si, providerAsSandboxClient as Sl, ResolvedMcpServerLaunch as Sm, attachWorker as Sn, reconnectRetainedInteractiveRun as So, resolveSpawnResourcePaths as Sp, safeWorkerFile as Sr, superviseDispatch as Ss, SpawnRefusalCause as St, PursuitStatus as Su, QuestionOption as Sv, ProviderNativeCapturePhase as Sx, AnalystRunContext as Sy, RuntimeFailureOwner as T, RetainedInteractiveEnvironmentAdmission as TS, SandboxEvidenceRetentionPort as T_, canDisplace as Ta, ExecutorAccounting as Tb, ObserveInput as Tc, createSupervisorSpanRecorder as Td, StopRule as Tf, stopSentinel as Tg, DelegateResearchArgs as Th, DelegateOptions as Ti, LeaderboardBenchTask as Tl, resolveMcpServerLaunch as Tm, NOTE_MAX_CHARS as Tn, ResolveSandboxClientOptions as To, createMcpServer as Tp, workerInboxFileFromEventDir as Tr, TerminalDecision as Ts, AgentEnvironment$1 as Tt, ObserverJournal as Tu, QuestionUrgency as Tv, ProviderWorkspaceCaptureReceipt as Tx, AuthoredAnalystLimits as Ty, NodeStatus as U, StartRetainedRunOptions as US, createRuntimeEventCollector as U_, collectAgentTurn as Ua, ActivityNote as Ub, Panel as Uc, defaultEdgeTraversalCap as Ud, bestDelivered as Uf, CodeModeToolset as Ug, UiFinding as Uh, ResumedKeyState as Ui, IsolatedCheckBox as Ul, ToolLoopChat as Um, localShell as Un, loopUntil as Uo, SteerableSandboxArgs as Up, profileRunsForName as Ur, AgenticSurface as Us, ExecResult as Ut, superviseFleetCapabilities as Uu, PeerMailEnvelope as Uv, LoopIterationStartedPayload as Ux, SpawnForestNode as Uy, NodeId as V, RetainedRunTurnInput as VS, SanitizedKnowledgeReadinessReport as V_, CollectedAgentTurn as Va, createPushTraceSource as Vb, LoopUntilSpec as Vc, readRootStream as Vd, FinalizerSettled as Vf, CodeModeToolContext as Vg, UiAuditLensFilter as Vh, Agent as Vi, declaredCheckJudge as Vl, ToolSpec as Vm, gitWorkspace as Vn, fanout as Vo, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Vp, pickBestProfile as Vr, AgenticOptions as Vs, CreateSandboxOptions$1 as Vt, runGraphWithTestBrain as Vu, DEFAULT_PEER_MAIL_LIMITS as Vv, LoopIterationDispatchPayload as Vx, SpawnForestInDoubtNode as Vy, RetainedExecutionState as W, createRuntimeStreamEventCollector as W_, streamAgentTurn as Wa, DEFAULT_STALL_AFTER_MS as Wb, PanelJudge as Wc, GraphRouteError as Wd, CoordinationAuthentication as Wf, RunCodeModeOptions as Wg, UiFindingScreenshot as Wh, ResumedWork as Wi, IsolatedCheckBoxEvidence as Wl, ToolLoopCompaction as Wm, runInWorkspace as Wn, panel as Wo, SteerableSandboxSession as Wp, recordProfileRun as Wr, AgenticTask as Ws, ForkRequest as Wt, superviseWithTestBrain as Wu, PeerMailEvent as Wv, LoopLineageOptions as Wx, SpawnForestTree as Wy, SubtreeSummary as X, WorktreeProfileMaterializationReceipt as X_, TournamentCell as Xa, readWorkerProgress as Xb, ScopeAnalyzeInput as Xc, delegatesWorkerBriefPrompt as Xd, CoordinationHttpAudit as Xf, Leaderboard as Xg, ResearchSource as Xh, WorkerEventPage as Xi, NextPursuitVersionInput as Xl, CoderDelegate as Xm, createSupervisor as Xn, RegistryAnalyzeProjection as Xo, PeerInboxMessage as Xp, InPlaceCliExecutorOptions as Xr, StrategyShotResult as Xs, computeFindingId$1 as Xt, WorkerSlots as Xu, PeerMailbox as Xv, LoopTeardownFailedPayload as Xx, InMemorySpawnJournal as Xy, SubtreeResult as Y, WorktreeHarnessResult as Y_, StrategyTournament as Ya, createActivityLog as Yb, ScopeAnalyst as Yc, createPromptRegistry as Yd, serveCoordinationMcp as Yf, Interval as Yg, ResearchOutput as Yh, WorkerEventEntry as Yi, NextPursuitVersion as Yl, FeedbackStore as Ym, DEFAULT_MAX_DEPTH as Yn, CreateScopeAnalystOptions as Yo, InboxMessage as Yp, workerFromInteractiveProvider as Yr, StrategyMessage as Ys, WorkspaceRequest as Yt, SuperviseTestOptions as Yu, PeerMailSendInput as Yv, LoopStartedPayload as Yx, InMemoryResultBlobStore as Yy, TreeView as Z, GitRunner as Z_, TournamentRow as Za, ReconnectRetainedInteractiveRunOptions as Zb, ScopeWidenGate as Zc, dumbContinuationFailPrompt as Zd, CoordinationRejectReason as Zf, LeaderboardOptions as Zg, ResearchTask as Zh, ChatCompletionsTransport as Zi, PursuitVersionChain as Zl, CoderReview as Zm, createRootHandle as Zn, assertTraceDerivedFindings as Zo, DEFAULT_SHARED_BOX_RESOURCES as Zp, createInPlaceCliExecutor as Zr, SurfaceScore as Zs, makeFinding$1 as Zt, createWorkerSlots as Zu, PeerMailboxOptions as Zv, LoopTokenUsage as Zx, contentAddress as Zy, RunAgentTaskOptions as _, NativeContextContinuationExecution as _S, WaterfallCollector as __, CheckSource as _a, MaterializedExecutionIdentity as _b, HarvestCorpusOptions as _c, RunContextLease as _d, SupervisorToolInvocationContext as _f, verdictFromJudgeScore as _g, DelegationResumeTick as _h, RollingDispatchOptions as _i, RunPersonifiedOptions as _l, ProviderPlacement as _m, WorktreePatchArtifact as _n, recoverRetainedRun as _o, ResolvedSpawnResourcePath as _p, cancelWorker as _r, LoopOptionsForDispatch as _s, PeerAuditAccess as _t, PursuitNodeTiming as _u, QuestionDecision as _v, RetainedHarnessTranscriptCapture as _x, AnalystAssignmentRecord as _y, AgentKnowledgeProvider as a, SandboxClient as aS, renderLeaderboardHtml as a_, AuthoredProfile as aa, NotFoundError as ab, ShotSpec as ac, withWorkerSpawnRetry as ad, CoordinationToolFace as af, DelegationPersistenceError as ag, FleetHandle as ah, graphRegistry as ai, WidenDecision as al, ROUTER_CLIENT_HEADER as am, SurfaceReader as an, SandboxRunAbortError as ao, ContinuationPanel as ap, SearchSpecOwnedOption as ar, sanitizeMcpToolSchema as as, DriverAttemptRecord as at, SupervisePursuitError as au, WorkerWatchOptions as av, HarnessTranscriptCapture as ax, McpToolAnnotations as ay, RuntimeSession as b, ReconnectRetainedRunOptions as bS, createWaterfallCollector as b_, StructuralRolloutConfig as ba, ProfileMaterializationReceipt as bb, HarvestReport as bc, withRunContext as bd, AllWorkersStalledOptions as bf, CompletionPolicy as bg, DelegationTaskQueueOptions as bh, rollingDispatch as bi, ShapeRegistry as bl, BridgeSeam as bm, WorkerInteractiveBinding as bn, ClaimRetainedInteractiveControlOptions as bo, SpawnResourceReader as bp, readWorkerSteerAcknowledgement as br, loopCampaignDispatch as bs, SpawnPreflightContext as bt, PursuitRunProjection as bu, QuestionEscalationTarget as bv, retainHarnessTranscript as bx, AnalystLensOutput as by, AgentTaskContext as c, Validator as cS, renderPairwiseMarkdown as c_, asAuthoredProfile as ca, ExecutorContext as cb, StrategyCtx as cc, SeatSegment as cd, DriveHarnessOwnerContext as cf, FileDelegationStoreOptions as cg, createFleetWorkspaceExecutor as ch, loadGraph as ci, WinnerStrategy as cl, AgentEnvironmentProviderRef as cm, fsSurfaceReader as cn, SandboxLineage as co, ContinuationPolicy as cp, searchPresets as cr, BenchmarkLift as cs, DriverFailureClass as ct, superviseGraphPursuit as cu, GateRequest as cv, HarnessTranscriptUnavailable as cx, BusEvent as cy, AgentTaskStatus as d, RuntimeRunHandle as dS, AnytimeTaskCurve as d_, profileRichnessFinding as da, SpawnModelSubstitution as db, assertStrategyContract as dc, SeatStage as dd, ResolveSupervisorTools as df, CheckUnavailableError as dg, RunDetachedTurnOptions as dh, recordGraphRun as di, LoopShape as dl, resolveAgentEnvironmentProvider as dm, analystsFromRegistry as dn, AcquireOptions as do, VerdictSummary as dp, createScope as dr, BenchmarkTaskRow as ds, CoordinationStats as dt, RUN_FORK_CORRELATION_KEYS as du, RouteGate as dv, captureHarnessTranscript as dx, EventBus as dy, LoopWinner as eS, PairwiseVerdict as e_, ChatTransportTool as ea, AgentEvalError$1 as eb, refine as ec, WorkerSpawnRetryHooks as ed, kernelPromptRegistry as ef, TraceContext as eg, DetachedSessionDelegateOptions as eh, GraphSelection as ei, TrajectoryReport as el, SharedBoxPlacement as em, BoxSurfaceReaderOptions as en, Deliverable as eo, FileCoordinationLog as ep, createFencedSqlRunContext as er, registryScopeAnalyst as es, ProviderModelAttemptEvidence as et, SettledPursuitVersion as eu, EventAcknowledgement as ev, RetainedInteractiveEnvironmentInput as ex, isPeerMailEnvelope as ey, BackendErrorDetail as f, RuntimeRunOptions as fS, anytimeReport as f_, supervisorInstructions as fa, AgentExecutionRef as fb, authorStrategy as fc, SelectSeat as fd, SupervisorAgentDeps as ff, CheckVerdict as fg, runDetachedTurn as fh, storedGraphDigests as fi, Outcome as fl, ProviderExecutorOptions as fm, failuresAnalyst as fn, acquireSandbox as fo, admitContinuationPolicy as fp, ScopeArgs as fr, Environment as fs, CoordinationTools as ft, PursuitObserverDelivery as fu, RouteMatch as fv, harnessTranscriptArtifact as fx, PublishOptions as fy, OpenAIChatToolChoice as g, startRuntimeRun as gS, renderAnytimeTable as g_, CheckRunner as ga, ExecutorNodeContext as gb, strategyAuthorSystemPrompt as gc, RunContext as gd, SupervisorToolDescriptor as gf, mapExecutorResult as gg, DelegationResumeDriver as gh, DispatchUnit as gi, RunPersonified as gl, UnavailablePausePolicy as gm, WorktreeCliExecutorOptions as gn, reconnectRetainedRun as go, ResolveSpawnResourcePathsResult as gp, WriteWorkerSteerOptions as gr, LoopDispatchOptions as gs, MakeWorkerAgent as gt, PursuitNodeProjection as gu, Question as gv, HarnessTranscriptReadOptions as gx, watchTrace as gy, OpenAIChatTool as h, RuntimeRunStatus as hS, plateauLength as h_, CheckRunContext as ha, ExecutorMaterialization as hb, strategyAuthorContract as hc, InMemoryRunContextOptions as hd, SupervisorNodeContextSeed as hf, gateOnDeliverable as hg, DelegationResumeContext as hh, DispatchStopReason as hi, PersonaExecutors as hl, providerAsExecutor as hm, worktreeFanout as hn, createS3PrivateCasStore as ho, DriverRetryPolicy as hp, WorkerSteerRequest as hr, LoopCampaignDispatchOptions as hs, GraphSubtasks as ht, PursuitNodePlatform as hu, EscalateQuestion as hv, HarnessTranscriptReadLimits as hx, defaultToolDetectors as hy, AgentExecutionBackend as i, RunProvenance as iS, pairwiseSignificance as i_, createChatSessionStore as ia, JudgeError as ib, AuthoredStrategy as ic, retryPreSpawnRefusals as id, supervisorAgentWithTestBrain as if, composeLoopTraceEmitters as ig, DelegationExecutor as ih, graphFromStored as ii, Widen as il, sharedBoxPlacement as im, SurfaceReadOutcome as in, SandboxRun as io, ContinuationEntry as ip, SearchSpecInputs as ir, createMcpEnvironment as is, SupervisedResult as it, SuperviseGraphPursuitOptions as iu, ToolOutcomeEvent as iv, HarnessTranscriptArtifact as ix, JsonRpcResponse as iy, TraceSummary as j, RetainedRunCancellation as jS, buildLoopOtelSpans as j_, modelAuthoredChecks as ja, HeldForContinuation as jb, CombinatorShape as jc, LeakedReservation as jd, RunCancellation as jf, CodexRolloutTurn as jg, DelegationFeedbackSnapshot as jh, TraceRootReceipt as ji, LeaderboardScore as jl, createSandboxToolPartState as jm, spendFromUsageEvents as jn, PrivateCasOffloadReport as jo, ExecutorConfig as jp, connectRemoteSupervisor as jr, inProcessSandboxClient as js, AgentEnvironmentSummary as jt, EdgeTraversal as ju, DownMessageAuthorizationInput as jv, ExecutorToolCall as jx, LOCAL_HARNESSES as jy, TRACE_SUMMARY_SCHEMA as k, RetainedRunAdmissionHook as kS, OtelExporter as k_, defaultStructuralRolloutPolicy as ka, ExecutorTeardownWarning as kb, renderReport as kc, BudgetPoolRestore as kd, plateau as kf, CodexRolloutStoreReader as kg, DelegateUiAuditRoute as kh, SpawnEvent as ki, LeaderboardRunContext as kl, SandboxOutputMarker as km, composeWorkerEvidence as kn, PrivateCasArtifactPort as ko, createDelegateHandler as kp, RemoteSupervisorTree as kr, InProcessPromptCtx as ks, AgentEnvironmentQuery as kt, AgentGraph as ku, ContinuationInstruction as kv, ProviderWorkspaceRetentionPort as kx, RunLocalHarnessOptions as ky, AgentTaskRunResult as l, RuntimeRunCompleteInput as lS, AnytimeReport as l_, assessAuthoredProfile as la, ExecutorFactory as lb, StrategyResult as lc, SeatSelection as ld, ObserveSupervisorNodeEvent as lf, CoderOutput as lg, createSiblingSandboxExecutor as lh, lookupGraph as li, DefinePersona as ll, AgentEnvironmentProviderRegistry as lm, harvestSurfaceDiffs as ln, SandboxLineageHandle as lo, ContinuationProfile as lp, searchSpecDigest as lr, BenchmarkReport as ls, DriverRepromptRefusal as lt, supervisePursuit as lu, JsonScalar as lv, HarnessTranscriptUnavailableReason as lx, BusRecord as ly, OpenAIChatResponseFormat as m, RuntimeRunRow as mS, bestSoFar as m_, CheckOutcome as ma, ExecutorExecutionBinding as mb, sampleThenRefine as mc, InMemoryRunContext as md, SupervisorNodeContext as mf, ExecutorResultMapping as mg, DelegationRecord as mh, DispatchReport as mi, PersonaContext as ml, ProviderPromptOptions as mm, WorktreeFanoutOptions as mn, S3PrivateCasStoreOptions as mo, DriverReentry as mp, WorkerSteerAcknowledgement as mr, runBenchmark as ms, GraphSubtaskPreparation as mt, PursuitNodeCost as mu, ChildQuestionInbox as mv, HarnessTranscriptMetadata as mx, WatchTraceOptions as my, AgentBackendContext as n, MountRecorder as nS, ScoreOf as n_, chatTransportExecutor as na, BackendTransportError as nb, sample as nc, isPreSpawnExecutorFailure as nd, promptHandle as nf, readTraceContextFromEnv as ng, UiAuditorDelegate as nh, digestOfGraph as ni, Verify as nl, SharedBoxStats as nm, SurfaceDiff as nn, OpenSandboxRunOptions as no, CheckRead as np, SEARCH_SPEC_CORRELATION_KEY as nr, McpEndpoint as ns, RootProviderModelEvidence as nt, VersionVerdict as nu, ManagerReentryState as nv, RetainedInteractiveStartMaterial as nx, peerMailVerbNames as ny, AgentRuntimeEvent as o, SelectionReceipt as oS, renderLeaderboardMarkdown as o_, ProfileRichness as oa, ValidationError as ob, Strategy as oc, SuperviseRegistry as od, CoordinationVerbs as of, DelegationStore as og, FleetWorkspaceExecutorOptions as oh, graphRunsFor as oi, WidenLineage as ol, sharedBoxRefusal as om, WatchedSurface as on, TurnResult as oo, ContinuationPanelInput as op, assertSearchSpec as or, BenchmarkCell as os, DriverAttemptStop as ot, SupervisePursuitOptions as ou, DecideGate as ov, HarnessTranscriptEvidence as ox, McpToolDescriptor as oy, KnowledgeReadinessDecision as p, RuntimeRunPersistenceAdapter as pS, areaUnderCurve as p_, CheckExecChannel as pa, ExecutionBindingReceipt as pb, defineStrategy as pc, subscriptionUsageLimitSignal as pd, SupervisorAgentTestDeps as pf, DeliverableSpec as pg, DelegationArgs as ph, taskShapeDigest as pi, Persona as pl, ProviderLeafOut as pm, AuthoredHarness as pn, S3PrivateCasStore as po, DriverContractState as pp, WorkerCancellation as pr, printBenchmarkReport as ps, CoordinationToolsOptions as pt, PursuitCostProvenance as pu, RouteWhen as pv, persistHarnessTranscript as px, createEventBus as py, SpawnPrior as q, WorktreeCheckRunner as q_, EvolutionStrategy as qa, TeamProgress as qb, PipelineStage as qc, RegisteredPrompt as qd, CoordinationReadAccess as qf, AxisScoresOf as qg, KnowledgeItem as qh, WidenGate as qi, runIsolatedCheck as ql, ToolLoopToolCall as qm, WorkerToolTraceArtifact as qn, verify as qo, Inbox as qp, InteractiveWorkerOptions as qr, CorpusReadbackOptions as qs, SandboxEvent$1 as qt, AuthorizedSpawnContext as qu, PeerMailReadout as qv, LoopResult as qx, replaySpawnTree as qy, AgentBackendInput as r, OutputAdapter as rS, leaderboard as r_, chatWorkerSeam as ra, ConfigError as rb, AuthorStrategyOptions as rc, resolveWorkerSpawnRetry as rd, supervisorAgent as rf, DelegationTraceSpan as rg, detachedSessionDelegate as rh, graphDigest as ri, VerifySpec as rl, SharedWorkerIdentity as rm, SurfaceReadBox as rn, OpenSandboxRunPromptOptions as ro, ContinuationAppend as rp, SearchSpec as rr, McpEnvironmentOptions as rs, RootStreamReceipt as rt, assertPursuitVersions as ru, ManagerWake as rv, StartRetainedInteractiveRunOptions as rx, JsonRpcMessage as ry, AgentRuntimeEventSink as s, ValidationCtx as sS, renderLeaderboardSvg as s_, ProfileRichnessThresholds as sa, AgentSpec as sb, StrategyArtifacts as sc, SuperviseRegistryTable as sd, DriveHarness as sf, FileDelegationStore as sg, SiblingSandboxExecutorOptions as sh, listGraphRuns as si, WidenSpec as sl, sharedWorkerClientName as sm, boxSurfaceReader as sn, openSandboxRun as so, ContinuationPanelResult as sp, compileSearchSpec as sr, BenchmarkConfig as ss, DriverContinuationRecord as st, SupervisedPursuitResult as su, GateDecision as sv, HarnessTranscriptFile as sx, McpTransport as sy, AgentAdapter as t, MountManifestEntry as tS, ProfileKeyOf as t_, ChatWorkerSeamOptions as ta, AgentEvalErrorCode as tb, runAgentic as tc, WorkerSpawnRetryPolicy as td, naiveContinuationPrompt as tf, createPropagatingTraceEmitter as tg, DetachedWinnerSelection as th, StoredGraph as ti, TrajectoryReportOptions as tl, SharedBoxPlacementOptions as tm, HarvestSurfaceDiffsOptions as tn, OpenSandboxRunBeforeStartContext as to, PriorCoordination as tp, CompiledSearchSpec as tr, observationFromRegistry as ts, ProviderModelExecutionEvidence as tt, VersionJudge as tu, LeadMessage as tv, RetainedInteractiveRunHandle as tx, peerMailTools as ty, AgentTaskSpec as u, RuntimeRunCost as uS, AnytimeStrategySummary as u_, defaultProfileRichnessThresholds as ua, ExecutorRegistry as ub, adaptiveRefine as uc, SeatSelectionInput as ud, ResolveDriveHarness as uf, CoderTask as ug, DetachedTurn as uh, pickBestGraph as ui, DefinePersonaInput as ul, createAgentEnvironmentProviderRegistry as um, AnalystAuthoring as un, createSandboxLineage as uo, PanelFinding as up, settledToIteration as ur, BenchmarkStrategySummary as us, BlockedToolReport as ut, PursuitFork as uu, RouteFlow as uv, ReadableEnvironment as ux, BusStats as uy, RunAgentTaskStreamOptions as v, NativeContextContinuationHandle as vS, WaterfallReport as v_, CheckSourceCtx as va, MaterializedModelIdentity as vb, HarvestError as vc, createFileRunContext as vd, ManagerWakePolicy as vf, CompletionAnalyst as vg, DelegationRunContext as vh, freeSlots as vi, ShapeBudget as vl, BridgeHarnessStore as vm, createWorktreeCliExecutor as vn, startRetainedRun as vo, SpawnResourceBytes as vp, legacySupervisorRunDir as vr, SuperviseDispatchOptions as vs, SettledWorker as vt, PursuitNodeUsage as vu, QuestionEscalationOutcome as vv, RetainedHarnessTranscriptDescriptor as vx, AnalystFindingEvent as vy, RuntimeFailureCode as w, RetainedInteractiveAdmission as wS, SandboxEvidenceReceipt as w_, VisibleCheck as wa, Executor as wb, ObservationError as wc, SupervisorSpanRecorder as wd, StopDecision as wf, sentinelCompletion as wg, DelegateCodeConfig as wh, graphDesignerExtraTools as wi, LeaderboardBenchScore as wl, mcpSecretEnvMetadataKey as wm, EVIDENCE_MAX_CHARS as wn, startRetainedInteractiveRun as wo, McpServerOptions as wp, supervisorRunsRoot as wr, TERMINAL_DECISIONS as ws, WorkerSpawnContext as wt, FileObserverJournal as wu, QuestionRecord as wv, ProviderWorkspaceCaptureProvenance as wx, AuthoredAnalystDefinition as wy, RuntimeSessionStore as x, RecoverRetainedRunIntentOptions as xS, RunAgentRoundsOptions as x_, StructuralRolloutMessage as xa, RootMaterialization as xb, harvestCorpus as xc, SupervisorSpanAttributes as xd, NoProgressForOptions as xf, CompletionVerdict as xg, SubmitInput as xh, DesignerRunGraphEnv as xi, ProviderAsSandboxClientOptions as xl, KeyProvider as xm, WorkerInteractiveProviderSource as xn, claimRetainedInteractiveControl as xo, environmentReader as xp, readWorkerSteerRequests as xr, loopDispatch as xs, SpawnRefusal as xt, PursuitRunTotals as xu, QuestionLevel as xv, ProviderCheckpointCaptureContext as xx, AnalystRegistry$1 as xy, RuntimeCanonicalStreamEvent as y, NativeContextContinuationInput as yS, WaterfallSpan as y_, RepairStop as ya, NodeExecutionIdentity as yb, HarvestFailure as yc, createInMemoryRunContext as yd, SupervisorProfile as yf, CompletionEvidence as yg, DelegationTaskQueue as yh, queueOf as yi, ShapeContext as yl, BridgeModelCredential as ym, AttachWorkerOptions as yn, startRetainedRunInEnvironment as yo, SpawnResourceRead as yp, readWorkerCancellation as yr, SuperviseOptionsForDispatch as ys, SpawnPreflight as yt, PursuitProjection as yu, QuestionEscalationRecord as yv, resolveHarnessTranscriptCapture as yx, AnalystKind as yy, SpendGap as z, RetainedRunSnapshot as zS, RuntimeStreamEventSummary as z_, AgentTurnInput$1 as za, ToolStepInput as zb, FanoutSynthesis as zc, createBudgetPool as zd, DeliveredOutput as zf, CodeModeStore as zg, FeedbackRefersTo as zh, Supervisor as zi, declaredCheckDeliverable as zl, RouterTransportConfig as zm, WorkspaceCommit as zn, InMemoryCorpus as zo, RouterToolsSeam as zp, bestProfileFor as zr, connectStdioMcp as zs, CheckpointRequest as zt, TraversalContinuity as zu, MapTraversalEvent as zv, LoopDecisionPayload as zx, SpawnForest as zy };
+//# sourceMappingURL=types-DZ6L0Bv3.d.ts.map