@tangle-network/agent-runtime 0.189.0 → 0.191.0

package/dist/{index-k5bcID4t.d.ts → index-B2rVjcPT.d.ts}

@@ -1,13 +1,13 @@
 import { C as MountRecorder, D as SelectionReceipt, E as SandboxClient, S as MountManifestEntry, a as Iteration, b as LoopTraceEvent, d as LoopLineageOptions, i as ExecCtx, k as Validator, m as LoopResult, r as Driver, t as AgentRunSpec, w as OutputAdapter, x as LoopWinner, y as LoopTraceEmitter } from "./types-BdolQ6Zi.js";
 import { n as AnalystRegistryLike } from "./types-zWfqDjeL.js";
 import { l as RuntimeHooks } from "./runtime-hooks-Bj6wJHlH.js";
-import { $ as TreeView, $n as RetainedRunHandle, A as ProviderModelExecutionEvidence, B as Settled, Bn as RecoverRetainedRunResult, C as NoWinnerError, Dn as ReconnectRetainedInteractiveRunOptions, Dt as OtelExportConfig, E as NodeSnapshot, Gn as RetainedRunAdmission, H as SpawnJournal, J as SpendGap, K as Spend, Ln as ReconnectRetainedRunOptions, M as ResumedKeyState, Nn as StartRetainedInteractiveRunOptions, O as ProfileMaterializationReceipt, On as RecoverRetainedInteractiveRunOptions, Ot as OtelExporter, P as RootHandle, R as Runtime, Rn as RecoverRetainedRunIntentOptions, T as NodeId, U as SpawnOpts, V as SpawnEvent, Vn as RetainedInteractiveAdmission, X as SupervisedResult, Xn as RetainedRunEffect, Y as SteerableRootHandle, Z as Supervisor, _ as ExecutorRegistry, a as DefaultVerdict, ar as StartRetainedRunInEnvironmentOptions, at as WorkerInteractiveSession, en as PendingWait, et as UnconfirmedTeardown, hn as TraceSource, ht as TraceContext, i as Budget, j as ResultBlobStore, jn as RetainedInteractiveRunHandle, lt as WorkerTraceResolver, n as AgentExecutionRef, nt as UsageEvent, o as ExecutionBindingReceipt, or as StartRetainedRunOptions, ot as WorkerInteractiveUnavailableReason, p as ExecutorFactory, r as AgentSpec, rn as WaitProbeRegistry, s as Executor, st as WorkerTraceEvidence, t as Agent, v as ExecutorResult, w as NodeExecutionIdentity, wn as WorkerProgress, z as Scope, zn as RecoverRetainedRunOptions } from "./types-BbkiJR1D.js";
-import { B as KeyProvider, Gt as JsonRpcMessage, J as WorktreeCheckRunner, Jt as McpTransport, Kt as JsonRpcResponse, Nt as PeerMailLimits, Rt as PeerMailbox, S as Inbox, St as ToolLoopChat, X as WorktreeHarnessResult, bt as ToolSpec, jt as PeerMailEvent, q as InPlaceHarnessResult, qt as McpToolDescriptor$1, s as ExecutorConfig, tt as GitRunner, u as RouterToolsSeam, vt as runLocalHarness, wt as ToolLoopCompactionOptions, yt as RouterTransportConfig } from "./runtime-EQgE3942.js";
+import { An as RecoverRetainedInteractiveRunOptions, At as OtelExporter, B as Scope, Bn as RecoverRetainedRunIntentOptions, D as NodeSnapshot, E as NodeId, En as WorkerProgress, F as RootHandle, Fn as StartRetainedInteractiveRunOptions, H as SpawnEvent, Hn as RecoverRetainedRunResult, M as ResultBlobStore, N as ResumedKeyState, Nn as RetainedInteractiveRunHandle, Q as Supervisor, Qn as RetainedRunEffect, T as NodeExecutionIdentity, U as SpawnJournal, Un as RetainedInteractiveAdmission, V as Settled, Vn as RecoverRetainedRunOptions, W as SpawnOpts, X as SteerableRootHandle, Y as SpendGap, Z as SupervisedResult, _ as ExecutorRegistry, _n as TraceSource, _t as TraceContext, a as DefaultVerdict, an as WaitProbeRegistry, cr as StartRetainedRunOptions, ct as WorkerInteractiveUnavailableReason, dt as WorkerTraceResolver, i as Budget, it as UsageEvent, j as ProviderModelExecutionEvidence, k as ProfileMaterializationReceipt, kn as ReconnectRetainedInteractiveRunOptions, kt as OtelExportConfig, lt as WorkerTraceEvidence, n as AgentExecutionRef, nn as PendingWait, nt as UnconfirmedTeardown, o as ExecutionBindingReceipt, p as ExecutorFactory, q as Spend, qn as RetainedRunAdmission, r as AgentSpec, s as Executor, sr as StartRetainedRunInEnvironmentOptions, st as WorkerInteractiveSession, t as Agent, tr as RetainedRunHandle, tt as TreeView, v as ExecutorResult, w as NoWinnerError, z as Runtime, zn as ReconnectRetainedRunOptions } from "./types-DKA_PDv0.js";
+import { c as Redactor } from "./stream-agent-turn-_GgUW49y.js";
+import { C as Inbox, Gt as PeerMailEvent, It as ToolLoopChat, Mt as runLocalHarness, Nt as RouterTransportConfig, Pt as ToolSpec, Qt as PeerMailbox, Rt as ToolLoopCompactionOptions, V as KeyProvider, an as JsonRpcMessage, c as ExecutorConfig, cn as McpTransport, ct as WorktreeCheckRunner, d as RouterToolsSeam, ht as GitRunner, on as JsonRpcResponse, qt as PeerMailLimits, sn as McpToolDescriptor$1, st as InPlaceHarnessResult, ut as WorktreeHarnessResult } from "./runtime-DI4mJNXI.js";
 import { _ as CoderTask, d as ResearchSource, o as UiLens, r as UiFinding } from "./substrate-qLePHqvH.js";
-import { o as AgentEnvironmentProviderRegistry } from "./environment-provider-C4AQiUxj.js";
-import "./stream-agent-turn-BomJ21AK.js";
-import { AGENT_PROFILE_MATERIALIZATION_AXES, AgentInteractiveSessionControlClaim, AgentInteractiveSessionRef, AgentInteractiveSessionStart, AgentInteractiveSessionStatus, AgentProfile, AgentProfile as AgentProfile$2, AgentProfile as AgentProfile$3, AgentProfilePrompt, AgentProfileSecurityPolicy, CanonicalAgentProfileMaterializationAxis, HarnessType, Sha256Digest, profileMaterializationAxes as profileMaterializationAxes$1 } 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, CustomTokenPricing, DetectorSignal, HarnessType as HarnessType$1, JudgeError, MaximumCharge, NotFoundError, ProposalFinding, RankTestMethod, RegistryRunOpts, RunRecord, StreamingDetector, ToolSpan, TraceAnalysisStore, ValidationError, buildTrajectory, computeFindingId as computeFindingId$1, makeFinding as makeFinding$1 } from "@tangle-network/agent-eval";
+import { o as AgentEnvironmentProviderRegistry } from "./environment-provider-CJ43FJfJ.js";
+import { AGENT_PROFILE_MATERIALIZATION_AXES, AgentInteractiveSessionControlClaim, AgentInteractiveSessionRef, AgentInteractiveSessionStart, AgentInteractiveSessionStatus, AgentProfile, AgentProfile as AgentProfile$2, AgentProfile as AgentProfile$3, AgentProfilePrompt, AgentProfileSecurityPolicy, CanonicalAgentProfileMaterializationAxis, Sha256Digest, profileMaterializationAxes as profileMaterializationAxes$1 } 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, CustomTokenPricing, DetectorSignal, HarnessType as HarnessType$1, JudgeError, MaximumCharge, NotFoundError, ProposalFinding, RankTestMethod, RegistryRunOpts, RunRecord, StreamingDetector, ToolSpan, TraceAnalysisEngine, TraceAnalysisStore, ValidationError, buildTrajectory, computeFindingId as computeFindingId$1, makeFinding as makeFinding$1 } from "@tangle-network/agent-eval";
 import { DispatchFn, ExternalOptimizerModelCall, JudgeConfig, ProfileDispatchFn, RunProfileMatrixOptions, RunProfileMatrixResult, Scenario } from "@tangle-network/agent-eval/campaign";
 import "@tangle-network/agent-profile-materialize";
 import { AgentRunOutcome } from "@tangle-network/sandbox/runtime";
@@ -1967,13 +1967,116 @@ type QuestionPolicy = 'auto' | 'mustDecide' | 'bubble' | 'failClosed';
 type AnalystLensOutput = ReadonlyArray<AnalystFinding> | {
   readonly summary: string;
 };
+/** One lens on the menu `list_analysts` shows and `run_analyst` resolves. */
+interface AnalystKind {
+  readonly id: string;
+  readonly description: string;
+  readonly area: string;
+}
+/**
+ * The trace-tool sets a DEFINED analyst may ask for — the exact group names agent-eval's
+ * `buildTraceToolsForGroup` accepts, restated here so the `define_analyst` JSON Schema can
+ * enumerate them for the model that writes one. Named, not free-form, because the group is the
+ * lens's cost ceiling: `all` grants seven trace tools, `discovery` grants three and no deep reads.
+ * A name eval does not know throws at registration, which is where the two lists are held together.
+ */
+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. */
+interface AuthoredAnalystLimits {
+  readonly maxIterations?: number;
+  readonly maxLlmCalls?: number;
+  readonly maxToolCalls?: number;
+  readonly maxOutputChars?: number;
+}
+/**
+ * A trace analyst a MANAGER authored at run time: the research question, the policy for answering
+ * it, the trace tools it may use, and the model seat it asks for. Data only.
+ *
+ * DATA, NEVER CODE, is the whole safety argument. `TraceAnalystDefinition` (agent-eval) also
+ * carries `prepareContext` and `postProcess` FUNCTIONS; those are host-authored and are deliberately
+ * absent here, because accepting a function from a tool argument would mean executing model-written
+ * code inside the coordination handler — the one thing every other verb in this file refuses. What a
+ * manager can author is exactly what a prompt can say.
+ *
+ * The model seat is PROPOSED, not granted: {@link AnalystRegistry.register} resolves `model` to an
+ * engine and may refuse it, the same way `preflightSpawn` refuses a worker's model route.
+ */
+interface AuthoredAnalystDefinition {
+  /** Stable lens id. Lowercase, digits and hyphens; it becomes the `kind` passed to `run_analyst`
+   *  and the `analyst_id` on every finding, so it is the attribution key. */
+  readonly id: string;
+  /** One line naming what this lens looks for — what `list_analysts` shows the next manager. */
+  readonly description: string;
+  /** The finding area this lens reports under (e.g. `coordination`, `tool-use`, `cost`). */
+  readonly area: string;
+  /** The research question, in the manager's own words. */
+  readonly question: string;
+  /** How to answer it: evidence rules, what counts as a finding, what to refuse to infer. */
+  readonly instructions: string;
+  readonly toolGroup: AnalystToolGroupName;
+  /** The model seat the lens should run on. Omit to take the run's default analyst engine. */
+  readonly model?: string;
+  readonly limits?: AuthoredAnalystLimits;
+  /** 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. */
+interface DefinedAnalystRecord {
+  readonly definition: AuthoredAnalystDefinition;
+  readonly kind: AnalystKind;
+  /** Canonical digest of `definition` — the reproducibility key. */
+  readonly digest: string;
+  readonly definedAt: number;
+}
 interface AnalystRegistry {
-  readonly kinds: ReadonlyArray<{
-    id: string;
-    description: string;
-    area: string;
-  }>;
+  readonly kinds: ReadonlyArray<AnalystKind>;
   readonly run: (kindId: string, trace: TraceAnalysisStore) => Promise<AnalystLensOutput>;
+  /**
+   * OPT-IN: admit a MANAGER-AUTHORED lens while the run is in flight, so a driver can change the
+   * questions asked of its own children's traces instead of picking from a menu fixed before the
+   * 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
+   * 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
+   * message reaches the manager as the tool result's `reason`, so it can re-author.
+   */
+  readonly register?: (definition: AuthoredAnalystDefinition) => Promise<AnalystKind> | AnalystKind;
 }
 /** A trace-analyst result re-entered as a message on the bus (the `finding` event kind). */
 interface AnalystFindingEvent {
@@ -2036,8 +2139,76 @@ interface AnalyzeOnSettleRoute {
    *  every settled `done` worker. */
   readonly over?: ReadonlyArray<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;
+/**
+ * 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>>;
+/** The result of handing a question this manager cannot answer to whatever is above it. */
+type QuestionEscalationOutcome = {
+  readonly delivered: true;
+  readonly to: string;
+} | {
+  readonly delivered: false;
+  readonly reason: string;
+};
+/**
+ * Where a question leaves this manager when `ask_parent` is called.
+ *
+ * Absent means NO INBOX IS CONFIGURED above this manager: `ask_parent` then answers `no-parent`
+ * instead of appearing to succeed. That distinction is the whole point of the seam — a manager that
+ * escalates a blocking question and reads a bare receipt BLOCKS on an answer nothing is routing to
+ * it, and a fail-closed stop policy then refuses to let it finish.
+ *
+ * `no-parent` is not "the question vanished". It is still published on the bus and journaled, so an
+ * external answerer watching the run — the coordination MCP's own `answer_question`, an operator
+ * console, a product observer on `onCoordinationEvent` — can still decide it. What `no-parent` says
+ * is that the RUNTIME will carry it nowhere by itself, so the manager must not sit and wait.
+ *
+ * An implementation returns `{ delivered: true, to }` naming who holds the question now, or
+ * `{ delivered: false, reason }`. A THROW is also a refusal: its message becomes the reason, so a
+ * broken parent channel reads as an undelivered escalation, never as a delivered one.
+ */
+type EscalateQuestion = (question: QuestionRecord) => Promise<QuestionEscalationOutcome> | QuestionEscalationOutcome;
+/** The operator-facing artifact written for every `ask_parent`: which question left, whether
+ *  anything received it, and — when nothing did — that the manager itself is now the last decider.
+ *  Journaled record-only, so the run's durable coordination log holds every question that was
+ *  raised and went unheard. */
+interface QuestionEscalationRecord {
+  readonly questionId: string;
+  readonly from: string;
+  readonly urgency: QuestionUrgency;
+  readonly delivered: boolean;
+  /** Who holds the question now. Absent when nothing received it. */
+  readonly to?: string;
+  /** Why it was not delivered. Absent on a delivered escalation. */
+  readonly reason?: string;
+  readonly at: number;
+}
 /** 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
@@ -2142,6 +2313,21 @@ type CoordinationEvent = {
 } | {
   readonly type: 'mail';
   readonly mail: PeerMailEvent;
+} |
+/** A question left this manager through `ask_parent`, and what became of it. Record-only: the
+ *  asker already holds the outcome, and an escalation is evidence for the operator, not an item
+ *  in the inbox the manager pulls from. */
+{
+  readonly type: 'escalation';
+  readonly escalation: QuestionEscalationRecord;
+} |
+/** A manager DEFINED a trace analyst (`define_analyst`). Record-only: the manager already has the
+ *  result in its tool return, so queueing it would put its own action in its own inbox. It is the
+ *  run artifact that makes an invented lens reproducible — the exact bytes, their digest, and the
+ *  owner the durable log stamps beside them. */
+{
+  readonly type: 'analyst-defined';
+  readonly analyst: DefinedAnalystRecord;
 };
 /** Immutable task, allocation, identity attribution, and semantic key supplied while a manager's
  * complete worker profile is prepared for one spawn. */
@@ -2314,6 +2500,55 @@ interface CoordinationToolsOptions {
    * because both are minted AFTER the pre-journal point. Omit = the authored profile is used.
    */
   readonly resolveSpawnProfile?: (profile: AgentProfile) => AgentProfile;
+  /**
+   * OPT-IN parent channel for `ask_parent`. See {@link EscalateQuestion}.
+   *
+   * Omit and this manager is treated as the TOP of its question chain: `ask_parent` still raises and
+   * journals the question, and answers `escalated: false, outcome: 'no-parent'` so the manager knows
+   * it must decide the question itself rather than wait.
+   */
+  readonly escalateQuestion?: EscalateQuestion;
+  /**
+   * Escalations this manager made in a PRIOR process of the same durable run
+   * (`PriorCoordination.escalations`). Seeded verbatim, so after a restart `stop` still knows which
+   * blocking questions reached no parent and still names the way out. Without it the record is
+   * journaled, reloaded, and then forgotten by the only reader that acts on it.
+   */
+  readonly priorEscalations?: ReadonlyArray<QuestionEscalationRecord>;
+  /**
+   * Domain scrub COMPOSED IN FRONT OF the built-in one for every event `read_journal` returns.
+   *
+   * The journal quotes model-authored instruction text and worker output, either of which may carry
+   * a credential the run was given, so the built-in scrub is not something a domain hook may switch
+   * off by accident: `resolveRedactor` runs the custom redactor first and `defaultRedactor`
+   * over its result — the same rule the rest of the runtime applies to trace values. Omit for the
+   * default alone; pass `false` to opt out deliberately. A redactor that throws is a refusal for
+   * that one row (it returns a `redaction-failed` marker), never a reason to return the raw event.
+   */
+  readonly redactJournal?: Redactor | false;
+  /**
+   * Rows written by PRIOR processes of this durable run (`PriorCoordination.records`), prepended to
+   * the live bus so `read_journal` answers for the whole run rather than the current process.
+   *
+   * Without it a resumed manager reads a nearly empty journal and concludes it tried nothing —
+   * which is the exact failure the verb exists to prevent. The rows are marked `prior: true` and
+   * are never re-published on the bus: they are evidence, not events to react to.
+   */
+  readonly priorJournal?: ReadonlyArray<BusRecord<CoordinationEvent>>;
+  /** Hard cap on lenses THIS manager may define through `define_analyst`. Omit =
+   *  `ANALYST_DEFINITION_BOUNDS.maxDefinitionsPerManager`; `<= 0` = no cap. Reached, the verb
+   *  refuses with `error: 'max-defined-analysts'` and names the cap, so a manager that has been
+   *  defining instead of investigating reads why. */
+  readonly maxDefinedAnalysts?: number;
+  /**
+   * Lenses this manager DEFINED in a prior process of the same durable run
+   * (`PriorCoordination.analystDefinitions`). Seeded verbatim: they are on the menu again, they
+   * count against {@link CoordinationToolsOptions.maxDefinedAnalysts}, and re-defining one is a
+   * `duplicate-analyst` refusal rather than a silent second registration. Re-registering them with
+   * the analyst registry is the owner's decision, because the registry may have changed between
+   * processes; this option only restores what the manager is allowed to believe it already wrote.
+   */
+  readonly priorAnalystDefinitions?: ReadonlyArray<DefinedAnalystRecord>;
 }
 /** Why a pre-flight refused a spawn. Each cause is a distinct, separately countable decision. */
 type SpawnRefusalCause = 'model-route' | 'bridge-full' | 'unmountable-tool';
@@ -2367,6 +2602,12 @@ interface CoordinationTools {
   } | undefined;
   settled(): ReadonlyArray<SettledWorker>;
   questions(): ReadonlyArray<QuestionRecord>;
+  /** Every `ask_parent` escalation and what became of it, in raise order. An undelivered one is a
+   *  question this run raised and nothing answered — the operator's read of a run that went quiet. */
+  escalations(): ReadonlyArray<QuestionEscalationRecord>;
+  /** Every lens this manager defined at run time, in definition order — the same records published
+   *  as `analyst-defined` events. Empty when the registry admits no authored lens. */
+  definedAnalysts(): ReadonlyArray<DefinedAnalystRecord>;
   /** The full ordered log of every bus event — UP (settled / question / finding), authorized
    *  instruction receipts, and DOWN delivery outcomes (steer / answer). Each record carries seq,
    *  timestamp, and priority. A receipt is evidence and is never auto-delivered on restart. */
@@ -2963,48 +3204,6 @@ interface DefinedLeaderboard<TCase, TArtifact = string> {
  */
 declare function defineLeaderboard<TCase, TArtifact = string>(spec: LeaderboardSpec<TCase, TArtifact>): DefinedLeaderboard<TCase, TArtifact>;
 //#endregion
-//#region src/runtime/harness-usage.d.ts
-/**
- * One harness's own token-usage report for one turn, in the runtime's field names.
- *
- * `input` is the provider's TOTAL prompt count and `output` is its TOTAL completion count.
- * The other three counters CLASSIFY a part of one of those totals; none of them adds to it.
- * `cachedInput` and `cacheWriteInput` classify `input`, which is the convention
- * `promptCacheTokenClasses` (`util.ts`) folds: `freshInput = input - cacheRead - cacheWrite`.
- * `reasoningOutput` classifies `output`.
- *
- * A counter the harness does not report stays absent, because a zero would claim the harness
- * measured none.
- */
-interface HarnessUsage {
-  /** The harness family whose adapter produced this report. */
-  readonly harness: HarnessType;
-  /** Total prompt tokens the provider charged for the turn, the cached ones included. */
-  readonly input: number;
-  /** Total completion tokens the provider charged for the turn, the reasoning ones included. */
-  readonly output: number;
-  /** The part of `input` the provider served from its prompt cache. */
-  readonly cachedInput?: number;
-  /** The part of `input` the provider wrote into its prompt cache. */
-  readonly cacheWriteInput?: number;
-  /** The part of `output` the model spent on reasoning. Never added to `output`. */
-  readonly reasoningOutput?: number;
-}
-/**
- * Decode a sandbox event with one harness's adapter, or `undefined` when the event carries no
- * harness-native usage.
- *
- * A NAMED harness reads with that harness's adapter only, and a named harness with no adapter
- * reports nothing. It never falls through to another harness's adapter: a different harness's
- * `turn.completed` decoded as codex would either drop the counters codex does not name or fail on
- * a field codex requires, and both answers would be about the wrong harness. The composite over
- * every registered adapter runs only when the caller cannot name the harness.
- *
- * Throws `ValidationError` when an adapter recognizes the event as its harness's usage carrier and
- * cannot read the numbers.
- */
-declare function decodeHarnessUsage(event: SandboxEvent, harness?: HarnessType): HarnessUsage | undefined;
-//#endregion
 //#region src/runtime/personify/types.d.ts
 /**
  * The terminal contract Drew wants: a loop returns a FINISHED deliverable, or the concrete
@@ -4427,6 +4626,15 @@ interface PriorCoordination {
   readonly questions: ReadonlyArray<QuestionRecord>;
   /** Every analyst finding the prior process published, publish order. */
   readonly findings: ReadonlyArray<AnalystFindingEvent>;
+  /** Every `ask_parent` escalation the prior process made, raise order. An undelivered one names a
+   * question the run raised that nothing above it received — retained so a resuming operator sees
+   * it, never auto-redelivered. */
+  readonly escalations: ReadonlyArray<QuestionEscalationRecord>;
+  /** Every lens the prior process DEFINED at run time, definition order. The exact authored bytes
+   * and their digest, so an invented lens can be re-registered and any finding it produced can be
+   * traced to the words that produced it. Re-registration is the owner's decision, never automatic:
+   * the registry may have changed between processes. */
+  readonly analystDefinitions: ReadonlyArray<DefinedAnalystRecord>;
   /** Every authorized continuation, in commit order. These are evidence, never replayed to a new
    * worker automatically. */
   readonly continuations: ReadonlyArray<ContinuationInstruction>;
@@ -4527,6 +4735,12 @@ interface CoordinationVerbs {
   listQuestions(args: unknown): Promise<unknown>;
   answerQuestion(args: unknown): Promise<unknown>;
   runAnalyst(args: unknown): Promise<unknown>;
+  /** This manager's OWN coordination journal, paged and redacted. A read, so a program may consult
+   *  what it already did without spending a model turn on it. */
+  readJournal(args: unknown): Promise<unknown>;
+  /** Define a new trace-analyst lens for this run. Composition, not lifecycle: a program may define
+   *  a lens and run it over the children it just joined, inside one model turn. */
+  defineAnalyst(args: unknown): Promise<unknown>;
 }
 /** Trusted context for one product-tool invocation. The node identity remains the same detached,
  * immutable snapshot supplied to the resolver; `signal` and `verbs` are the live control
@@ -4652,6 +4866,9 @@ interface SupervisorAgentDeps {
   readonly executeExtraTool?: (name: string, args: Record<string, unknown>) => Promise<string | null | undefined>;
   /** Analyst lenses available to the driver (both arms). Required for `analyzeOnSettle`. */
   readonly analysts?: AnalystRegistry;
+  /** Where an `ask_parent` question goes when it leaves this manager. Omit and `ask_parent` reports
+   *  `no-parent` — there is no runtime path that routes a question to a parent by itself. */
+  readonly escalateQuestion?: EscalateQuestion;
   /** Analyst kinds run on each worker-settle → a `finding` the driver composes its next steer from
    *  (the self-improving UP-leg). Unset/empty = status quo (no analyst feed). Requires `analysts`. */
   readonly analyzeOnSettle?: ReadonlyArray<string | AnalyzeOnSettleRoute>;
@@ -4740,6 +4957,88 @@ declare function supervisorAgent(profile: SupervisorProfile, deps: SupervisorAge
 /** Scripted-brain construction for deterministic tests. Not exported from Runtime's main entry. */
 declare function supervisorAgentWithTestBrain(profile: SupervisorProfile, deps: SupervisorAgentTestDeps): Agent<unknown, unknown>;
 //#endregion
+//#region src/runtime/supervise/worker-retry.d.ts
+/** One re-entry, reported before it waits. */
+interface WorkerSpawnRetryAttempt {
+  /** 1-based: the attempt that just failed. */
+  readonly attempt: number;
+  /** How long this seam waits before re-entering `execute`. */
+  readonly waitMs: number;
+  /** The refused profile's name, when it declares one. */
+  readonly worker?: string;
+  readonly error: string;
+}
+/**
+ * How hard a pre-spawn worker refusal is re-entered. Absent from `supervise` means NO retry — the
+ * historical behaviour, and the conservative default: a worker failure already has a typed
+ * settlement the driver can respond to, so adding silent latency to every run is not the runtime's
+ * call to make.
+ */
+interface WorkerSpawnRetryPolicy {
+  /** `false` disables the seam while leaving the option in a recorded run configuration. */
+  readonly enabled?: boolean;
+  /** Total wall-clock ms this seam may spend waiting for a slot, backoff included. Default 900000
+   *  — the span measured between saturation and the next free slot on a four-way host executor. */
+  readonly maxTotalMs?: number;
+  /** Wait before the first re-entry, doubling per attempt. Default 5000. */
+  readonly initialBackoffMs?: number;
+  /** Ceiling on the doubling. Default 60000. */
+  readonly maxBackoffMs?: number;
+  /**
+   * Extra PRE-SPAWN signatures a consumer's own admission layer emits, added to the built-in set.
+   *
+   * This widens which messages qualify, and it can only be used safely for a refusal the consumer
+   * knows is emitted before any provider call. The second proof — that the attempt yielded no
+   * execution event — still applies to every added signature, so a mistake here cannot cause a
+   * double-spend on a stream that had already started.
+   */
+  readonly additionalPreSpawnSignatures?: ReadonlyArray<RegExp>;
+}
+interface WorkerSpawnRetryHooks {
+  readonly onRetry?: (attempt: WorkerSpawnRetryAttempt) => void;
+  readonly now?: () => number;
+  readonly sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+}
+/** A policy with every bound decided — what {@link retryPreSpawnRefusals} acts on. Produced by
+ *  {@link resolveWorkerSpawnRetry}, never written by hand, so one reading of the defaults serves
+ *  the `supervise` option and a caller-owned seam alike. */
+interface ResolvedWorkerSpawnRetry {
+  readonly maxTotalMs: number;
+  readonly initialBackoffMs: number;
+  readonly maxBackoffMs: number;
+  readonly signatures: ReadonlyArray<RegExp>;
+}
+/**
+ * True when `error` is a backend refusal issued before anything ran.
+ *
+ * This answers "did this fail BEFORE any provider call", which is a strictly narrower question
+ * than "is this an infrastructure hiccup". The broader question admits `ECONNRESET` and a bare
+ * `fetch failed`, both of which can arrive after a metered call, and answering the broad question
+ * where the narrow one is required is what makes a retry double-spend.
+ */
+declare function isPreSpawnExecutorFailure(error: unknown, additionalSignatures?: ReadonlyArray<RegExp>): boolean;
+/** Read the policy, refusing a number a run cannot act on rather than silently clamping it. */
+declare function resolveWorkerSpawnRetry(policy: WorkerSpawnRetryPolicy | undefined): ResolvedWorkerSpawnRetry | undefined;
+/**
+ * Wrap a worker seam so a leaf whose spawn is refused before it runs is re-entered instead of
+ * settling dead.
+ *
+ * The wrapper composes the agent's `executorFactory`, which is where a leaf executor is built with
+ * the real child signal and node context, and it never replaces the executor object the factory
+ * returned: the retry lives in one `execute` wrapper that carries the inner executor's attestation
+ * forward and delegates every other surface to it.
+ */
+declare function withWorkerSpawnRetry(make: MakeWorkerAgent, policy: WorkerSpawnRetryPolicy | undefined, hooks?: WorkerSpawnRetryHooks): MakeWorkerAgent;
+/**
+ * Re-enter `execute` on one executor while a pre-spawn refusal keeps proving nothing ran.
+ *
+ * Exported so an owner of `makeLeafAgent` — which builds its own executors — gets the same seam
+ * without reimplementing the two proofs.
+ */
+declare function retryPreSpawnRefusals<Out>(inner: Executor<Out>, policy: ResolvedWorkerSpawnRetry, hooks?: WorkerSpawnRetryHooks & {
+  worker?: string;
+}): Executor<Out>;
+//#endregion
 //#region src/runtime/supervise/supervise.d.ts
 /**
  * Build the worker seam from a backend (WHERE workers run) + an optional completion oracle (the
@@ -4930,6 +5229,29 @@ interface SuperviseOptions {
   /** Per-attempt record for every external driver in the tree — what makes "failed after N
    *  attempts, last cause X" visible instead of one backend's last words. */
   readonly onDriverAttempt?: (record: DriverAttemptRecord) => void | Promise<void>;
+  /**
+   * How a BACKEND-DERIVED WORKER whose spawn was refused before it ran is re-entered, instead of
+   * settling dead with a slot free seconds later.
+   *
+   * `driverRetry` guards the root only. A worker that dies is typed into a `down` settlement,
+   * which is the right shape when the worker RAN — and the wrong shape for
+   * `host-executor: acquire timeout after 60000ms (in_flight=4/4, queued=1)`, a queue refusal the
+   * bridge emits before any harness child exists. Measured 2026-08-22 on discovery-lab cells
+   * oscnp s2/s3: ten live agents on one bridge that admits four, and every worker refused at the
+   * 60 s acquire deadline was lost for the whole run.
+   *
+   * Fail-closed on two proofs that the attempt did no work: the error carries a pre-spawn
+   * signature, AND the attempt yielded no execution event. An attempt that streamed anything may
+   * have metered usage, so a blind re-run would double-spend and stays fatal.
+   *
+   * Omit = no retry, the historical behaviour. Applies to backend-derived leaves, including those
+   * a `makeLeafAgent` builds; a caller-owned `makeWorkerAgent` composes
+   * {@link withWorkerSpawnRetry} itself.
+   */
+  readonly workerRetry?: WorkerSpawnRetryPolicy;
+  /** Per-re-entry record for every retried worker spawn — what makes a saturated executor visible
+   *  as waiting rather than as a worker that silently took longer. */
+  readonly onWorkerRetry?: (attempt: WorkerSpawnRetryAttempt) => void;
   /**
    * How many times an EXTERNAL-harness driver that RETURNED with `deliverable` still unmet is
    * re-entered on the SAME live session with the unmet items.
@@ -4975,6 +5297,15 @@ interface SuperviseOptions {
    * the same authorizeSpawn / security / allowedModels gate, pool reservation, `maxLiveWorkers`
    * cap, journal, and bus the MCP verb crosses, at every depth and on both arms. */
   readonly resolveSupervisorTools?: ResolveSupervisorTools;
+  /**
+   * Where an `ask_parent` question goes when it leaves a manager (see {@link EscalateQuestion}).
+   *
+   * Installed on EVERY manager of the run, at every depth, so a driver's escalation reaches the
+   * product's own inbox — a UI, an operator queue, a human. Omit and every manager reports
+   * `outcome: 'no-parent'` on `ask_parent`, which is the honest reading when nothing above it is
+   * listening: the runtime routes no question to a parent by itself.
+   */
+  readonly escalateQuestion?: EscalateQuestion;
   /** Awaited product transaction hook for every coordination record. `eventId` is stable across a
    * lost acknowledgement and durable restart; the record is not pull-visible until this commits. */
   readonly onCoordinationEvent?: (context: SupervisorNodeContext, eventId: Sha256Digest, record: BusRecord<CoordinationEvent>) => void | Promise<void>;
@@ -7292,6 +7623,8 @@ interface DriverAgentOptions {
   /** The analyst lenses available to the driver. Required for `analyzeOnSettle` (and `run_analyst`).
    *  Unset → no analyst feed (status quo: the driver gets settled outputs, no findings). */
   readonly analysts?: AnalystRegistry;
+  /** Where an `ask_parent` question goes when it leaves this manager. Omit = `no-parent`. */
+  readonly escalateQuestion?: EscalateQuestion;
   /** Analyst kind ids run AUTOMATICALLY when a worker settles `done` — each result re-enters as a
    *  `finding` the driver pulls and composes its next steer from. The UP-leg of the self-improving
    *  loop. Omit/empty = no auto-analysis (status quo). Requires `analysts`. */
@@ -7513,8 +7846,17 @@ declare function serveCoordinationMcp(opts: {
   /** Re-publish resume-time settlements through the awaited observer before this server listens. */
   replaySettlements?: boolean;
   questionPolicy?: QuestionPolicy;
+  /** Where an `ask_parent` question goes when it leaves this manager. Omit = `no-parent`. */
+  escalateQuestion?: EscalateQuestion;
+  /** Escalations replayed from a prior process — seeds what `stop` knows went unheard. */
+  priorEscalations?: ReadonlyArray<QuestionEscalationRecord>;
   /** Questions replayed from a prior process of this run — seeds the question ledger. */
   priorQuestions?: ReadonlyArray<QuestionRecord>;
+  /** Every coordination record from prior processes of this run — what `read_journal` reads before
+   *  this process's own rows, so a resumed manager sees what it already did. */
+  priorJournal?: ReadonlyArray<BusRecord<CoordinationEvent>>;
+  /** Lenses this manager defined in a prior process — seeds the menu and the definition cap. */
+  priorAnalystDefinitions?: ReadonlyArray<DefinedAnalystRecord>;
   /** Product-selected tools already bound to this exact supervisor node. They share this server
    *  with the coordination verbs, so the existing MCP duplicate-name guard applies before listen. */
   nodeTools?: ReadonlyArray<McpToolDescriptor$1>;
@@ -7861,7 +8203,7 @@ declare class GraphEdgeCapError extends Error {
  * Forwarded to the root `supervise()` VERBATIM. Everything not owned, transformed, or refused
  * above belongs here — the default is "a graph honors it", not "someone remembered to add it".
  */
-declare const GRAPH_FORWARDED_SUPERVISE_OPTIONS: readonly ["backend", "rootHandle", "signal", "execution", "resolveDeliverable", "coordination", "peerMail", "driverBackend", "profileSecurity", "authorizeSpawn", "isDriverProfile", "router", "driveHarness", "driverRetry", "onDriverAttempt", "repromptOnUnmet", "onUnmetContract", "childSettleGraceMs", "resolveDriveHarness", "driveHarnessMaterialization", "resolveSupervisorTools", "extraTools", "executeExtraTool", "perWorker", "maxLiveWorkers", "watchWorkers", "stallAfterMs", "runDir", "probes", "stopRule", "onProgressStop", "maxDepth", "maxTurns", "compaction", "now", "allowedModels", "finalizer", "otel"];
+declare const GRAPH_FORWARDED_SUPERVISE_OPTIONS: readonly ["backend", "escalateQuestion", "rootHandle", "signal", "execution", "resolveDeliverable", "coordination", "peerMail", "driverBackend", "profileSecurity", "authorizeSpawn", "isDriverProfile", "router", "driveHarness", "driverRetry", "onDriverAttempt", "workerRetry", "onWorkerRetry", "repromptOnUnmet", "onUnmetContract", "childSettleGraceMs", "resolveDriveHarness", "driveHarnessMaterialization", "resolveSupervisorTools", "extraTools", "executeExtraTool", "perWorker", "maxLiveWorkers", "watchWorkers", "stallAfterMs", "runDir", "probes", "stopRule", "onProgressStop", "maxDepth", "maxTurns", "compaction", "now", "allowedModels", "finalizer", "otel"];
 /** `backend` and `driverBackend` keep graph-specific documentation below.
  *
  * Do not inherit and redeclare them through an indexed access type.
@@ -9022,7 +9364,26 @@ declare function analystsFromRegistry(registry: AnalystRegistryLike, kinds?: Rea
   area: string;
 }>, opts?: {
   runOpts?: RegistryRunOpts;
+  authoring?: AnalystAuthoring;
 }): AnalystRegistry;
+/**
+ * What `analystsFromRegistry` needs before a manager may define its own lens.
+ *
+ * Only the ENGINE is asked for, because everything else about a defined lens is already in the
+ * manager's own words. The engine is the model seat plus the recursive investigation loop, and it
+ * cannot come from a tool argument: an `AgentProfile` names a model the run's own model policy has
+ * already fenced, but an analyst engine is host-constructed with host credentials.
+ */
+interface AnalystAuthoring {
+  /**
+   * Resolve the investigation engine for the seat a definition asked for. `undefined` means the
+   * definition named no seat and wants the run's default engine. THROW to refuse a seat this run
+   * cannot serve — the message is what the manager reads and re-authors from.
+   */
+  readonly resolveEngine: (model: string | undefined) => TraceAnalysisEngine;
+  /** Forwarded to `createTraceAnalyst`; omit for its default. */
+  readonly settlementTimeoutMs?: number;
+}
 /** The default self-improvement LENS — authored content, not a code path. On each settled worker it hands
  *  the driver the still-FAILING tests (not just a score), so the next spawn targets the persistently-hard
  *  cases. Swap `analysts` to change what the driver improves from — that's the one knob. */
@@ -9209,5 +9570,5 @@ interface VerifierEnvironmentOptions {
 /** Any checkable task as an `Environment`, no tool surface required: the artifact is the worker's answer and the domain is one deployable `check` over it. */
 declare function createVerifierEnvironment(opts: VerifierEnvironmentOptions): Environment;
 //#endregion
-export { gitWorkspace as $, BenchmarkTaskRow as $a, RenderCorpusToInstructions as $c, detachedTurnEvents as $d, DelegationPersistenceError as $f, probeSandboxCapabilities as $i, LeaderboardOptions as $l, freeSlots as $n, ResolveSupervisorTools as $o, ProfileMaterializationContract as $p, defaultStructuralRolloutPolicy as $r, DriverRepromptPolicy as $s, createFileRunContext as $t, QuestionUrgency as $u, AttachWorkerOptions as A, fanout as Aa, AssertTraceDerivedFindings as Ac, CoderReview as Ad, DelegationHistoryResult as Af, McpSpawnFault as Ai, DefinedLeaderboard as Al, TraversalContinuity as An, SuperviseDispatchOptions as Ao, gateOnDeliverable as Ap, ProfileRichness as Ar, noProgressFor as As, readWorkerSteerAcknowledgement as At, AnalystRegistry as Au, WorkerEvidenceInput as B, assertTraceDerivedFindings as Ba, FanoutOptions as Bc, DelegationExecutor as Bd, UiAuditLensFilter as Bf, SandboxRun as Bi, defineLeaderboard as Bl, dumbContinuationFailPrompt as Bn, SuperviseRegistry as Bo, SpawnForestNode as Bp, CheckRunner as Br, FinalizerSettled as Bs, workerCancellationsDir as Bt, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as Bu, SurfaceWorkerOut as C, createShapeRegistry as Ca, harvestCorpus as Cc, createDelegateHandler as Cd, DelegateUiAuditConfig as Cf, AuthoredStrategy as Ci, RunPersonified as Cl, EdgeTraversal as Cn, refine as Co, PublishOptions as Cp, BudgetPoolRestore as Cr, ProgressView as Cs, cancelWorker as Ct, renderAnytimeTable as Cu, AuthoredHarness as D, FileCorpus as Da, defaultAnalystInstruction as Dc, InMemoryFeedbackStore as Dd, DelegationFeedbackSnapshot as Df, strategyAuthorSystemPrompt as Di, ShapeRegistry as Dl, GraphResult as Dn, LoopCampaignDispatchOptions as Do, watchTrace as Dp, createBudgetPool as Dr, allWorkersStalled as Ds, readRunCancellation as Dt, createWaterfallCollector as Du, superviseSurface as E, runPersonified as Ea, ObserveOptions as Ec, FeedbackStore as Ed, DelegationError as Ef, strategyAuthorContract as Ei, ShapeContext as El, GraphNode as En, sampleThenRefine as Eo, defaultToolDetectors as Ep, ReservationTicket as Er, allOf as Es, readRunCancelRequest as Et, WaterfallSpan as Eu, workerInteractiveBindingFile as F, selectValidWinner as Fa, EqualKArm as Fc, SettleDetachedCoderTurnOptions as Fd, DelegationStatusArgs as Ff, materializeLocalMcp as Fi, LeaderboardIterationInfo as Fl, PromptRegistry as Fn, AuthorizedSpawn as Fo, InMemorySpawnJournal as Fp, profileRichnessFinding as Fr, SupervisorSpanOutcome as Fs, supervisorRunDir as Ft, ContinuityMode as Fu, UntrackedCopyStats as G, McpEnvironmentOptions as Ga, LoopUntilSpec as Gc, createSiblingSandboxExecutor as Gd, DELEGATION_TRACE_MAX_SPANS as Gf, CheckpointCapableBox as Gi, completionAuthorizes as Gl, promptHandle as Gn, workerFromBackend as Go, replaySpawnTree as Gp, StructuralRolloutMessage as Gr, runFinalizer as Gs, workerSteerAcknowledgementsDir as Gt, MakeWorkerAgent as Gu, composeWorkerEvidence as H, createScopeAnalyst as Ha, FanoutWinnerSelector as Hc, FleetWorkspaceExecutorOptions as Hd, delegationProfiles as Hf, TurnResult as Hi, CompletionEvidence as Hl, formatPromptHandle as Hn, SuperviseTestOptions as Ho, loadSpawnForest as Hp, CheckSourceCtx as Hr, bestDelivered as Hs, workerInboxFile as Ht, DownMessageDeliveryAttempt as Hu, workerInteractiveBindingsDir as I, verify as Ia, EqualKOnCost as Ic, UiAuditorDelegate as Id, DelegationStatusResult as If, Deliverable as Ii, LeaderboardRunContext as Il, RegisteredPrompt as In, AuthorizedSpawnContext as Io, SpawnForest as Ip, supervisorInstructions as Ir, SupervisorSpanRecorder as Is, supervisorRunsRoot as It, CoordinationEvent as Iu, GitWorkspaceOptions as J, BenchmarkCell as Ja, PanelJudge as Jc, DetachedTurnResumeDriverOptions as Jd, DelegationTraceSpan as Jf, SandboxLineageHandle as Ji, stopSentinel as Jl, DispatchReport as Jn, CoordinationVerbs as Jo, AgentProfileMaterializationAxis as Jp, VisibleCheck as Jr, DriverAttemptsExhaustedError as Js, workerSteersDir as Jt, QuestionEscalationTarget as Ju, copyUntrackedIntoClone as K, createMcpEnvironment as Ka, LoopUntilState as Kc, DetachedSessionRefParts as Kd, DelegationTraceCaps as Kf, ForkCapableBox as Ki, deterministicCompletion as Kl, supervisorPolicyPrompt as Kn, CoordinationBinding as Ko, contentAddress as Kp, StructuralRolloutPolicy as Kr, DriverAttemptRecord as Ks, workerSteerRequestFile as Kt, Question as Ku, EVIDENCE_MAX_CHARS as L, widen as La, EqualKOnCostOptions as Lc, coderTaskFromArgs as Ld, FeedbackRating as Lf, OpenSandboxRunBeforeStartContext as Li, LeaderboardScenario as Ll, analyzesFindingsReportPrompt as Ln, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as Lo, SpawnForestEvent as Lp, CheckExecChannel as Lr, createSupervisorSpanRecorder as Ls, supervisorWorkersDir as Lt, CoordinationStats as Lu, WorkerInteractiveProviderSource as M, loopUntil as Ma, Corpus as Mc, DelegateRunCtx as Md, DelegationProgress as Mf, StdioMcpConnection as Mi, LeaderboardBenchTask as Ml, runGraph as Mn, loopCampaignDispatch as Mo, FileResultBlobStore as Mp, asAuthoredProfile as Mr, sampleFromSettled as Ms, runCancelRequestFile as Mt, AuthorizeDownMessage as Mu, attachWorker as N, panel as Na, CorpusFilter as Nc, DetachedSessionDelegateOptions as Nd, DelegationResultPayload as Nf, StdioMcpServerSpec as Ni, LeaderboardBenchmarkAdapter as Nl, runGraphWithTestBrain as Nn, loopDispatch as No, FileSpawnJournal as Np, assessAuthoredProfile as Nr, SupervisorSpanAttributes as Ns, runCancellationFile as Nt, AuthorizedDownMessage as Nu, WorktreeFanoutOptions as O, InMemoryCorpus as Oa, observe as Oc, eventToSnapshot as Od, DelegationHistoryArgs as Of, LocalMcpMaterialization as Oi, HarnessUsage as Ol, RunGraphOptions as On, LoopDispatchOptions as Oo, DeliverableSpec as Op, spendFromUsageEvents as Or, anyOf as Os, readWorkerCancelRequests as Ot, AnalystFindingEvent as Ou, readWorkerInteractiveBinding as P, pipeline as Pa, CorpusRecord as Pc, DetachedWinnerSelection as Pd, DelegationStatus as Pf, connectStdioMcp as Pi, LeaderboardFlagSpec as Pl, PromptHandle as Pn, superviseDispatch as Po, InMemoryResultBlobStore as Pp, defaultProfileRichnessThresholds as Pr, SupervisorSpanOptions as Ps, safeWorkerFile as Pt, ContinuationInstruction as Pu, WorkspaceRun as Q, BenchmarkStrategySummary as Qa, PipelineStage as Qc, createDetachedTurnResumeDriver as Qd, createDelegationTraceCollector as Qf, SandboxCapabilities as Qi, Leaderboard as Ql, effectiveConcurrency as Qn, ResolveDriveHarness as Qo, KnownAgentProfileMaterializationAxis as Qp, defaultExtractCandidate as Qr, DriverReentry as Qs, RunContext as Qt, QuestionRecord as Qu, NOTE_MAX_CHARS as R, CreateScopeAnalystOptions as Ra, EqualKVerdict as Rc, detachedSessionDelegate as Rd, FeedbackRefersTo as Rf, OpenSandboxRunOptions as Ri, LeaderboardScore as Rl, createPromptRegistry as Rn, DeliverableResolutionInput as Ro, SpawnForestInDoubtNode as Rp, CheckOutcome as Rr, DeliveredOutput as Rs, workerCancelRequestsFile as Rt, CoordinationTools as Ru, SurfaceWorkerConfig as S, builtinShapes as Sa, HarvestReport as Sc, DelegateResult as Sd, DelegateUiAuditArgs as Sf, AuthorStrategyOptions as Si, PersonaExecutors as Sl, EdgeDeliveryOutcome as Sn, depthStrategy as So, EventBus as Sp, BudgetPool as Sr, ProgressTrackerOptions as Ss, cancelRun as St, plateauLength as Su, failuresAnalyst as T, definePersona as Ta, ObserveInput as Tc, FeedbackEvent as Td, DelegateUiAuditRoute as Tf, authorStrategy as Ti, ShapeBudget as Tl, GraphEdgeCapError as Tn, sample as To, WatchTraceOptions as Tp, ReservationRejection as Tr, StopRule as Ts, legacySupervisorRunsRoot as Tt, WaterfallReport as Tu, settledWorkerOut as U, registryScopeAnalyst as Ua, FlatWidenGate as Uc, SiblingSandboxExecutorOptions as Ud, CappedDelegationTrace as Uf, openSandboxRun as Ui, CompletionPolicy as Ul, kernelPromptRegistry as Un, supervise as Uo, materializeTreeView as Up, RepairStop as Ur, collectDelivered as Us, workerInboxFileFromEventDir as Ut, DownMessageDeliveryOutcome as Uu, closingWorkerNote as V, buildSteerContext as Va, FanoutSynthesis as Vc, FleetHandle as Vd, UiAuditorDelegationOutput as Vf, SandboxRunAbortError as Vi, CompletionAnalyst as Vl, dumbContinuationPassPrompt as Vn, SuperviseRegistryTable as Vo, SpawnForestTree as Vp, CheckSource as Vr, SupervisorFinalizer as Vs, workerControlLogFile as Vt, DownMessageAuthorizationInput as Vu, CopyOptions as W, McpEndpoint as Wa, LoopUntil as Wc, createFleetWorkspaceExecutor as Wd, DELEGATION_TRACE_MAX_BYTES as Wf, BranchCapableBox as Wi, CompletionVerdict as Wl, naiveContinuationPrompt as Wn, superviseWithTestBrain as Wo, pendingWaits as Wp, StructuralRolloutConfig as Wr, pickBestDelivered as Ws, workerSteerAcknowledgementFile as Wt, DownMessageEvent as Wu, Workspace as X, BenchmarkLift as Xa, PanelVerdict as Xc, DriveTurnTick as Xd, capDelegationTrace as Xf, createSandboxLineage as Xi, GroupOf as Xl, DispatchUnit as Xn, DriveHarnessOwnerContext as Xo, CanonicalAgentProfileMaterializationAxis as Xp, compareCheckOutcomes as Xr, DriverContractState as Xs, InMemoryRunContext as Xt, QuestionOption as Xu, Shell as Y, BenchmarkConfig as Ya, PanelSpec as Yc, DriveTurnCapableBox as Yd, buildDelegationTraceSpans as Yf, SessionCapableBox as Yi, AxisScoresOf as Yl, DispatchStopReason as Yn, DriveHarness as Yo, AssertProfileMaterializationOptions as Yp, canDisplace as Yr, DriverBudgetReadout as Ys, writeWorkerSteer as Yt, QuestionLevel as Yu, WorkspaceCommit as Z, BenchmarkReport as Za, Pipeline as Zc, RunDetachedTurnOptions as Zd, composeLoopTraceEmitters as Zf, CriuCapableClient as Zi, Interval as Zl, RollingDispatchOptions as Zn, ObserveSupervisorNodeEvent as Zo, DefineProfileMaterializationContractOptions as Zp, composeCheckSources as Zr, DriverProgressMark as Zs, InMemoryRunContextOptions as Zt, QuestionPolicy as Zu, boxSurfaceReader as _, profileOptimizerModelCall as _a, InProcessPromptCtx as _c, DELEGATE_INPUT_SCHEMA as _d, DelegateFeedbackArgs as _f, StrategyEvolutionConfig as _i, DefinePersonaInput as _l, readWorkerInteractiveAdmissions as _n, StrategyShotResult as _o, ValidationError as _p, ChatTransportTool as _r, AllWorkersStalledOptions as _s, WorkerCancelRequest as _t, AnytimeStrategySummary as _u, SandboxInstance$1 as a, startRetainedRunInEnvironment as aa, classifyDriverFailure as ac, WorkerResumeContext as ad, DelegationResumeContext as af, selectBestIndex as ai, TrajectoryNode as al, fullProfileMaterialization as am, provisionSupervisor as an, AgenticSurface as ao, AgentEvalError$1 as ap, CoordinationMcpHandle as ar, SupervisorProfile as as, WORKER_TOOL_TRACE_SCHEMA_VERSION as at, leaderboard as au, SuperviseSurfaceOptions as b, equalKOnCost as ba, HarvestCorpusOptions as bc, DelegateError as bd, DelegateResearchConfig as bf, runStrategyEvolution as bi, Persona as bl, createInPlaceCliExecutor as bn, breadthStrategy as bo, BusRecord as bp, chatWorkerSeam as br, ProgressSample as bs, WorkerSteerRequest as bt, areaUnderCurve as bu, VerifierEnvironmentOptions as c, reconnectRetainedInteractiveRun as ca, TERMINAL_DECISIONS as cc, canonicalFindingEvent as cd, DelegationRunContext as cf, ChampionPick as ci, TrajectoryReportOptions as cl, promptModelProfileMaterialization as cm, WorktreeCliExecutorOptions as cn, ArtifactHandle as co, ConfigError as cp, driverAgent as cr, assertCoordinationBinding as cs, parseWorkerToolTraceArtifact as ct, renderLeaderboardMarkdown as cu, HarvestSurfaceDiffsOptions as d, ResolveSandboxClientOptions as da, isTerminalDecision as dc, questionEscalationTargets as dd, SubmitInput as df, EvolutionAuthor as di, Widen as dl, renderProfileMaterializationIssues as dm, InteractiveWorkerEnvironment as dn, ShotSpec as do, PlannerError as dp, CodeModeRunner as dr, supervisorAgentWithTestBrain as ds, createSupervisor as dt, AuditIntentInput as du, AcquireOptions as ea, DriverRepromptRefusal as ec, SettledWorker as ed, formatDetachedSessionRef as ef, filterAuthoredAsserts as ei, RenderCorpusToInstructionsOptions as el, ProfileMaterializationIssue as em, createInMemoryRunContext as en, Environment as eo, DelegationStateCorruptError as ep, queueOf as er, ResolvedSupervisorProfile as es, jjWorkspace as et, LeaderboardRow as eu, SurfaceDiff as f, resolveSandboxClient as fa, runAgentRounds as fc, McpServer as fd, SubmitOutput as ff, EvolutionBandInfo as fi, WidenDecision as fl, sandboxActProfileMaterialization as fm, InteractiveWorkerKeyInput as fn, Strategy as fo, RetainedInteractiveAdmissionError as fp, codeModeSupervisorTools as fr, CoordinationDeliveryEvidence as fs, ScopeArgs as ft, AuditIntentOptions as fu, WatchedSurface as g, profileChatClient as ga, InProcessOnPrompt as gc, DELEGATE_DESCRIPTION as gd, DelegateCodeResult as gf, ReproductionCheck as gi, DefinePersona as gl, WorkerInteractiveAdmission as gn, StrategyResult as go, RuntimeRunStateError as gp, ChatTransportExecutorOptions as gr, PriorCoordination as gs, RunCancellation as gt, AnytimeReport as gu, SurfaceReader as h, promotionGate as ha, inlineSandboxClient as hc, createMcpServer as hd, DelegateCodeConfig as hf, EvolutionReport as hi, WinnerStrategy as hl, workerFromInteractiveProvider as hn, StrategyMessage as ho, RetainedRunDispatchBindingError as hp, ChatSessionStore as hr, FileCoordinationLog as hs, RunCancelRequest as ht, defaultAuditorInstruction as hu, SandboxEvent$1 as i, startRetainedRun as ia, OnUnmetContract as ic, SpawnRefusalCause as id, DelegationRecord as if, sandboxCheckRunner as ii, SteerContext as il, defineProfileMaterializationContract as im, SupervisorCleanupReceipt as in, AgenticRunResult as io, InMemoryDelegationStore as ip, delegate as ir, SupervisorNodeContextSeed as is, analyzeTrace as it, ScoreOf as iu, WorkerInteractiveBinding as j, flatWidenGate as ja, CombinatorShape as jc, CoderReviewer as jd, DelegationProfile as jf, McpToolDescriptor as ji, LeaderboardBenchScore as jl, defaultEdgeTraversalCap as jn, SuperviseOptionsForDispatch as jo, mapExecutorResult as jp, ProfileRichnessThresholds as jr, plateau as js, readWorkerSteerRequests as jt, AnalyzeOnSettleRoute as ju, worktreeFanout as k, renderCorpusToInstructions as ka, renderReport as kc, CoderDelegate as kd, DelegationHistoryEntry as kf, MaterializeLocalMcpOptions as ki, decodeHarnessUsage as kl, RunGraphTestOptions as kn, LoopOptionsForDispatch as ko, ExecutorResultMapping as kp, AuthoredProfile as kr, createProgressTracker as ks, readWorkerCancellation as kt, AnalystLensOutput as ku, createVerifierEnvironment as l, recoverRetainedInteractiveRun as la, TerminalDecision as lc, createCoordinationTools as ld, DelegationTaskQueue as lf, ChampionPolicy as li, Verify as ll, promptOnlyProfileMaterialization as lm, WorktreePatchArtifact as ln, CorpusReadbackOptions as lo, JudgeError as lp, finalizeBestDelivered as lr, resolveSupervisorProfile as ls, workerTraceAnalysisStore as lt, renderLeaderboardSvg as lu, SurfaceReadOutcome as m, PromotionVerdict as ma, localSandboxClient as mc, createInProcessTransport as md, DelegateCodeArgs as mf, EvolutionGeneration as mi, WidenSpec as ml, worktreeCliProfileMaterialization as mm, InteractiveWorkerResult as mn, StrategyCtx as mo, RetainedRunAdmissionError as mp, ChatCompletionsTransport as mr, CoordinationOwnerId as ms, settledToIteration as mt, auditIntent as mu, AnalystFinding$1 as n, reconnectRetainedRun as na, DriverUnmetContractContext as nc, SpawnPreflightContext as nd, runDetachedTurn as nf, officialChecksFromMeta as ni, ScopeAnalyzeInput as nl, assertProfileMaterialization as nm, ProvisionSupervisorRequest as nn, runBenchmark as no, FileDelegationStore as np, DelegateOptions as nr, SupervisorAgentTestDeps as ns, runInWorkspace as nt, PairwiseVerdict as nu, computeFindingId$1 as o, ClaimRetainedInteractiveControlOptions as oa, defaultUnmetContractSteer as oc, WorkerSpawnContext as od, DelegationResumeDriver as of, structuralRollout as oi, TrajectoryReport as ol, profileMaterializationAxes$1 as om, PatchDeliverableOptions as on, AgenticTask as oo, AgentEvalErrorCode as op, serveCoordinationMcp as or, SupervisorToolDescriptor as os, WorkerToolTraceArtifact as ot, pairwiseSignificance as ou, SurfaceReadBox as p, PromotionGateOptions as pa, LocalSandboxClientOptions as pc, McpServerOptions as pd, hashIdempotencyInput as pf, EvolutionCandidate as pi, WidenLineage as pl, validateProfileMaterialization as pm, InteractiveWorkerOptions as pn, StrategyArtifacts as po, RetainedInteractiveBindingError as pp, unsafeInProcessRunner as pr, CoordinationLog as ps, createScope as pt, IntentAudit as pu, withUntrackedArtifacts as q, sanitizeMcpToolSchema as qa, Panel as qc, DetachedTurn as qd, DelegationTraceCollector as qf, SandboxLineage as qi, sentinelCompletion as ql, ConcurrencyCaps as qn, CoordinationToolFace as qo, AGENT_PROFILE_MATERIALIZATION_AXES as qp, StructuralRolloutResult as qr, DriverAttemptStop as qs, workerSteerRequestsDir as qt, QuestionDecision as qu, CreateSandboxOptions$1 as r, recoverRetainedRun as ra, DriverUnmetContractDecision as rc, SpawnRefusal as rd, DelegationArgs as rf, resolveEntrySymbol as ri, ScopeWidenGate as rl, controlProfileMaterialization as rm, ProvisionedSupervisor as rn, AgenticOptions as ro, FileDelegationStoreOptions as rp, defaultDelegateBudget as rr, SupervisorNodeContext as rs, TrajectoryAnalysis as rt, ProfileKeyOf as ru, makeFinding$1 as s, claimRetainedInteractiveControl as sa, RunAgentRoundsOptions as sc, WorkerWatchOptions as sd, DelegationResumeTick as sf, visibleCheckScore as si, TrajectoryReportFn as sl, promptControlProfileMaterialization as sm, patchDelivered as sn, AgenticTool as so, BackendTransportError as sp, DriverAgentOptions as sr, SupervisorToolInvocationContext as ss, captureWorkerTraceEvidence as st, renderLeaderboardHtml as su, AgentProfile$2 as t, acquireSandbox as ta, DriverRetryPolicy as tc, SpawnPreflight as td, parseDetachedSessionRef as tf, modelAuthoredChecks as ti, ScopeAnalyst as tl, ValidateProfileMaterializationOptions as tm, ProvisionSupervisorConnection as tn, printBenchmarkReport as to, DelegationStore as tp, rollingDispatch as tr, SupervisorAgentDeps as ts, localShell as tt, PairwiseOptions as tu, BoxSurfaceReaderOptions as u, startRetainedInteractiveRun as ua, defaultSelectWinner as uc, normalizeAnalyzeOnSettle as ud, DelegationTaskQueueOptions as uf, EvolutionArchiveNode as ui, VerifySpec as ul, promptResourceProfileMaterialization as um, createWorktreeCliExecutor as un, RunAgenticOptions as uo, NotFoundError as up, CodeModeOptions as ur, supervisorAgent as us, createRootHandle as ut, renderPairwiseMarkdown as uu, fsSurfaceReader as v, assertModelAllowed as va, InProcessSandboxClientOptions as vc, DELEGATE_TOOL_NAME as vd, DelegateFeedbackResult as vf, discriminatingMeans as vi, LoopShape as vl, workerInteractiveAdmissionFile as vn, SurfaceScore as vo, CoderOutput as vp, ChatWorkerSeamOptions as vr, NoProgressForOptions as vs, WorkerCancellation as vt, AnytimeTaskCurve as vu, analystsFromRegistry as w, registerShape as wa, Observation as wc, validateDelegateArgs as wd, DelegateUiAuditResult as wf, assertStrategyContract as wi, RunPersonifiedOptions as wl, GraphEdge as wn, runAgentic as wo, createEventBus as wp, BudgetReadout as wr, StopDecision as ws, legacySupervisorRunDir as wt, WaterfallCollector as wu, SuperviseSurfaceResult as x, trajectoryReport as xa, HarvestFailure as xc, DelegateHandlerOptions as xd, DelegateResearchResult as xf, selectChampion as xi, PersonaContext as xl, AgentGraph as xn, defineStrategy as xo, BusStats as xp, createChatSessionStore as xr, ProgressTracker as xs, WriteWorkerSteerOptions as xt, bestSoFar as xu, harvestSurfaceDiffs as y, assertProfileModelsAllowed as ya, inProcessSandboxClient as yc, DelegateArgs as yd, DelegateResearchArgs as yf, pickChampion as yi, Outcome as yl, InPlaceCliExecutorOptions as yn, adaptiveRefine as yo, BusEvent as yp, chatTransportExecutor as yr, PlateauOptions as ys, WorkerSteerAcknowledgement as yt, anytimeReport as yu, VERIFY_TAIL_CHARS as z, RegistryAnalyzeProjection as za, Fanout as zc, settleDetachedCoderTurn as zd, ResearchOutputShape as zf, OpenSandboxRunPromptOptions as zi, LeaderboardSpec as zl, delegatesWorkerBriefPrompt as zn, SuperviseOptions as zo, SpawnForestMissingTree as zp, CheckRunContext as zr, FinalizeContext as zs, workerCancellationFile as zt, CoordinationToolsOptions as zu };
-//# sourceMappingURL=index-k5bcID4t.d.ts.map
+export { WorkspaceRun as $, BenchmarkStrategySummary as $a, LoopUntil as $c, DetachedSessionDelegateOptions as $d, DelegationResultPayload as $f, SandboxCapabilities as $i, deterministicCompletion as $l, effectiveConcurrency as $n, retryPreSpawnRefusals as $o, FileSpawnJournal as $p, defaultExtractCandidate as $r, pickBestDelivered as $s, RunContext as $t, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as $u, worktreeFanout as A, renderCorpusToInstructions as Aa, HarvestFailure as Ac, parseAuthoredAnalystDefinition as Ad, DelegationTaskQueueOptions as Af, MaterializeLocalMcpOptions as Ai, PersonaContext as Al, promptResourceProfileMaterialization as Am, RunGraphTestOptions as An, LoopOptionsForDispatch as Ao, NotFoundError as Ap, AuthoredProfile as Ar, ProgressTracker as As, readWorkerCancellation as At, renderAnytimeTable as Au, VERIFY_TAIL_CHARS as B, RegistryAnalyzeProjection as Ba, CombinatorShape as Bc, DelegateError as Bd, DelegateResearchConfig as Bf, OpenSandboxRunPromptOptions as Bi, LeaderboardBenchmarkAdapter as Bl, delegatesWorkerBriefPrompt as Bn, SuperviseOptions as Bo, BusRecord as Bp, CheckRunContext as Br, plateau as Bs, workerCancellationFile as Bt, AnalystRegistry as Bu, SurfaceWorkerConfig as C, builtinShapes as Ca, localSandboxClient as Cc, WorkerSpawnContext as Cd, DelegationArgs as Cf, AuthorStrategyOptions as Ci, WidenSpec as Cl, controlProfileMaterialization as Cm, EdgeDeliveryOutcome as Cn, depthStrategy as Co, FileDelegationStoreOptions as Cp, BudgetPool as Cr, CoordinationOwnerId as Cs, cancelRun as Ct, AnytimeReport as Cu, superviseSurface as D, runPersonified as Da, InProcessSandboxClientOptions as Dc, createCoordinationTools as Dd, DelegationResumeTick as Df, strategyAuthorContract as Di, LoopShape as Dl, promptControlProfileMaterialization as Dm, GraphNode as Dn, sampleThenRefine as Do, BackendTransportError as Dp, ReservationTicket as Dr, NoProgressForOptions as Ds, readRunCancelRequest as Dt, areaUnderCurve as Du, failuresAnalyst as E, definePersona as Ea, InProcessPromptCtx as Ec, canonicalFindingEvent as Ed, DelegationResumeDriver as Ef, authorStrategy as Ei, DefinePersonaInput as El, profileMaterializationAxes$1 as Em, GraphEdgeCapError as En, sample as Eo, AgentEvalErrorCode as Ep, ReservationRejection as Er, AllWorkersStalledOptions as Es, legacySupervisorRunsRoot as Et, anytimeReport as Eu, readWorkerInteractiveBinding as F, pipeline as Fa, ObserveOptions as Fc, createMcpServer as Fd, DelegateCodeConfig as Ff, connectStdioMcp as Fi, ShapeContext as Fl, PromptHandle as Fn, superviseDispatch as Fo, RetainedRunDispatchBindingError as Fp, defaultProfileRichnessThresholds as Fr, allOf as Fs, safeWorkerFile as Ft, ANALYST_DEFINITION_BOUNDS as Fu, CopyOptions as G, McpEndpoint as Ga, EqualKOnCost as Gc, FeedbackEvent as Gd, DelegateUiAuditRoute as Gf, BranchCapableBox as Gi, LeaderboardScore as Gl, naiveContinuationPrompt as Gn, superviseWithTestBrain as Go, WatchTraceOptions as Gp, StructuralRolloutConfig as Gr, SupervisorSpanRecorder as Gs, workerSteerAcknowledgementFile as Gt, AuthorizeDownMessage as Gu, closingWorkerNote as H, buildSteerContext as Ha, CorpusFilter as Hc, DelegateResult as Hd, DelegateUiAuditArgs as Hf, SandboxRunAbortError as Hi, LeaderboardIterationInfo as Hl, dumbContinuationPassPrompt as Hn, SuperviseRegistryTable as Ho, EventBus as Hp, CheckSource as Hr, SupervisorSpanAttributes as Hs, workerControlLogFile as Ht, AnalyzeOnSettleRoute as Hu, workerInteractiveBindingFile as I, selectValidWinner as Ia, defaultAnalystInstruction as Ic, DELEGATE_DESCRIPTION as Id, DelegateCodeResult as If, materializeLocalMcp as Ii, ShapeRegistry as Il, PromptRegistry as In, AuthorizedSpawn as Io, RuntimeRunStateError as Ip, profileRichnessFinding as Ir, allWorkersStalled as Is, supervisorRunDir as It, AnalystDefinitionIssue as Iu, withUntrackedArtifacts as J, sanitizeMcpToolSchema as Ja, Fanout as Jc, eventToSnapshot as Jd, DelegationHistoryArgs as Jf, SandboxLineage as Ji, CompletionAnalyst as Jl, ConcurrencyCaps as Jn, WorkerSpawnRetryAttempt as Jo, DeliverableSpec as Jp, StructuralRolloutResult as Jr, FinalizeContext as Js, workerSteerRequestsDir as Jt, ContinuityMode as Ju, UntrackedCopyStats as K, McpEnvironmentOptions as Ka, EqualKOnCostOptions as Kc, FeedbackStore as Kd, DelegationError as Kf, CheckpointCapableBox as Ki, LeaderboardSpec as Kl, promptHandle as Kn, workerFromBackend as Ko, defaultToolDetectors as Kp, StructuralRolloutMessage as Kr, createSupervisorSpanRecorder as Ks, workerSteerAcknowledgementsDir as Kt, AuthorizedDownMessage as Ku, workerInteractiveBindingsDir as L, verify as La, observe as Lc, DELEGATE_INPUT_SCHEMA as Ld, DelegateFeedbackArgs as Lf, Deliverable as Li, DefinedLeaderboard as Ll, RegisteredPrompt as Ln, AuthorizedSpawnContext as Lo, ValidationError as Lp, supervisorInstructions as Lr, anyOf as Ls, supervisorRunsRoot as Lt, AnalystFindingEvent as Lu, WorkerInteractiveBinding as M, flatWidenGate as Ma, harvestCorpus as Mc, McpServer as Md, SubmitOutput as Mf, McpToolDescriptor as Mi, RunPersonified as Ml, sandboxActProfileMaterialization as Mm, defaultEdgeTraversalCap as Mn, SuperviseOptionsForDispatch as Mo, RetainedInteractiveAdmissionError as Mp, ProfileRichnessThresholds as Mr, ProgressView as Ms, readWorkerSteerRequests as Mt, WaterfallReport as Mu, WorkerInteractiveProviderSource as N, loopUntil as Na, Observation as Nc, McpServerOptions as Nd, hashIdempotencyInput as Nf, StdioMcpConnection as Ni, RunPersonifiedOptions as Nl, validateProfileMaterialization as Nm, runGraph as Nn, loopCampaignDispatch as No, RetainedInteractiveBindingError as Np, asAuthoredProfile as Nr, StopDecision as Ns, runCancelRequestFile as Nt, WaterfallSpan as Nu, AuthoredHarness as O, FileCorpus as Oa, inProcessSandboxClient as Oc, downMessageRefusalReasons as Od, DelegationRunContext as Of, strategyAuthorSystemPrompt as Oi, Outcome as Ol, promptModelProfileMaterialization as Om, GraphResult as On, LoopCampaignDispatchOptions as Oo, ConfigError as Op, createBudgetPool as Or, PlateauOptions as Os, readRunCancellation as Ot, bestSoFar as Ou, attachWorker as P, panel as Pa, ObserveInput as Pc, createInProcessTransport as Pd, DelegateCodeArgs as Pf, StdioMcpServerSpec as Pi, ShapeBudget as Pl, worktreeCliProfileMaterialization as Pm, runGraphWithTestBrain as Pn, loopDispatch as Po, RetainedRunAdmissionError as Pp, assessAuthoredProfile as Pr, StopRule as Ps, runCancellationFile as Pt, createWaterfallCollector as Pu, WorkspaceCommit as Q, BenchmarkReport as Qa, FlatWidenGate as Qc, DelegateRunCtx as Qd, DelegationProgress as Qf, CriuCapableClient as Qi, completionAuthorizes as Ql, RollingDispatchOptions as Qn, resolveWorkerSpawnRetry as Qo, FileResultBlobStore as Qp, composeCheckSources as Qr, collectDelivered as Qs, InMemoryRunContextOptions as Qt, CoordinationToolsOptions as Qu, EVIDENCE_MAX_CHARS as R, widen as Ra, renderReport as Rc, DELEGATE_TOOL_NAME as Rd, DelegateFeedbackResult as Rf, OpenSandboxRunBeforeStartContext as Ri, LeaderboardBenchScore as Rl, analyzesFindingsReportPrompt as Rn, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as Ro, CoderOutput as Rp, CheckExecChannel as Rr, createProgressTracker as Rs, supervisorWorkersDir as Rt, AnalystKind as Ru, SuperviseSurfaceResult as S, trajectoryReport as Sa, LocalSandboxClientOptions as Sc, WorkerResumeContext as Sd, runDetachedTurn as Sf, selectChampion as Si, WidenLineage as Sl, assertProfileMaterialization as Sm, AgentGraph as Sn, defineStrategy as So, FileDelegationStore as Sp, createChatSessionStore as Sr, CoordinationLog as Ss, WriteWorkerSteerOptions as St, defaultAuditorInstruction as Su, analystsFromRegistry as T, registerShape as Ta, InProcessOnPrompt as Tc, analystToolGroupNames as Td, DelegationResumeContext as Tf, assertStrategyContract as Ti, DefinePersona as Tl, fullProfileMaterialization as Tm, GraphEdge as Tn, runAgentic as To, AgentEvalError$1 as Tp, BudgetReadout as Tr, PriorCoordination as Ts, legacySupervisorRunDir as Tt, AnytimeTaskCurve as Tu, composeWorkerEvidence as U, createScopeAnalyst as Ua, CorpusRecord as Uc, createDelegateHandler as Ud, DelegateUiAuditConfig as Uf, TurnResult as Ui, LeaderboardRunContext as Ul, formatPromptHandle as Un, SuperviseTestOptions as Uo, PublishOptions as Up, CheckSourceCtx as Ur, SupervisorSpanOptions as Us, workerInboxFile as Ut, AuthoredAnalystDefinition as Uu, WorkerEvidenceInput as V, assertTraceDerivedFindings as Va, Corpus as Vc, DelegateHandlerOptions as Vd, DelegateResearchResult as Vf, SandboxRun as Vi, LeaderboardFlagSpec as Vl, dumbContinuationFailPrompt as Vn, SuperviseRegistry as Vo, BusStats as Vp, CheckRunner as Vr, sampleFromSettled as Vs, workerCancellationsDir as Vt, AnalystToolGroupName as Vu, settledWorkerOut as W, registryScopeAnalyst as Wa, EqualKArm as Wc, validateDelegateArgs as Wd, DelegateUiAuditResult as Wf, openSandboxRun as Wi, LeaderboardScenario as Wl, kernelPromptRegistry as Wn, supervise as Wo, createEventBus as Wp, RepairStop as Wr, SupervisorSpanOutcome as Ws, workerInboxFileFromEventDir as Wt, AuthoredAnalystLimits as Wu, Shell as X, BenchmarkConfig as Xa, FanoutSynthesis as Xc, CoderReview as Xd, DelegationHistoryResult as Xf, SessionCapableBox as Xi, CompletionPolicy as Xl, DispatchStopReason as Xn, WorkerSpawnRetryPolicy as Xo, gateOnDeliverable as Xp, canDisplace as Xr, SupervisorFinalizer as Xs, writeWorkerSteer as Xt, CoordinationStats as Xu, GitWorkspaceOptions as Y, BenchmarkCell as Ya, FanoutOptions as Yc, CoderDelegate as Yd, DelegationHistoryEntry as Yf, SandboxLineageHandle as Yi, CompletionEvidence as Yl, DispatchReport as Yn, WorkerSpawnRetryHooks as Yo, ExecutorResultMapping as Yp, VisibleCheck as Yr, FinalizerSettled as Ys, workerSteersDir as Yt, CoordinationEvent as Yu, Workspace as Z, BenchmarkLift as Za, FanoutWinnerSelector as Zc, CoderReviewer as Zd, DelegationProfile as Zf, createSandboxLineage as Zi, CompletionVerdict as Zl, DispatchUnit as Zn, isPreSpawnExecutorFailure as Zo, mapExecutorResult as Zp, compareCheckOutcomes as Zr, bestDelivered as Zs, InMemoryRunContext as Zt, CoordinationTools as Zu, boxSurfaceReader as _, profileChatClient as _a, TERMINAL_DECISIONS as _c, SettledWorker as _d, RunDetachedTurnOptions as _f, ReproductionCheck as _i, TrajectoryReportOptions as _l, DefineProfileMaterializationContractOptions as _m, WorkerInteractiveAdmission as _n, StrategyResult as _o, composeLoopTraceEmitters as _p, ChatTransportExecutorOptions as _r, assertCoordinationBinding as _s, RunCancellation as _t, renderPairwiseMarkdown as _u, SandboxInstance$1 as a, startRetainedRun as aa, DriverContractState as ac, EscalateQuestion as ad, settleDetachedCoderTurn as af, sandboxCheckRunner as ai, PanelVerdict as al, SpawnForestMissingTree as am, SupervisorCleanupReceipt as an, AgenticRunResult as ao, ResearchOutputShape as ap, delegate as ar, DriveHarnessOwnerContext as as, analyzeTrace as at, Leaderboard as au, AnalystAuthoring as b, assertProfileModelsAllowed as ba, isTerminalDecision as bc, SpawnRefusal as bd, formatDetachedSessionRef as bf, pickChampion as bi, Widen as bl, ProfileMaterializationIssue as bm, InPlaceCliExecutorOptions as bn, adaptiveRefine as bo, DelegationStateCorruptError as bp, chatTransportExecutor as br, supervisorAgentWithTestBrain as bs, WorkerSteerAcknowledgement as bt, IntentAudit as bu, VerifierEnvironmentOptions as c, claimRetainedInteractiveControl as ca, DriverRepromptPolicy as cc, QuestionDecision as cd, FleetWorkspaceExecutorOptions as cf, visibleCheckScore as ci, RenderCorpusToInstructions as cl, loadSpawnForest as cm, patchDelivered as cn, AgenticTool as co, delegationProfiles as cp, DriverAgentOptions as cr, ResolveSupervisorTools as cs, captureWorkerTraceEvidence as ct, PairwiseOptions as cu, HarvestSurfaceDiffsOptions as d, startRetainedInteractiveRun as da, DriverUnmetContractContext as dc, QuestionEscalationTarget as dd, createSiblingSandboxExecutor as df, EvolutionArchiveNode as di, ScopeAnalyzeInput as dl, replaySpawnTree as dm, createWorktreeCliExecutor as dn, RunAgenticOptions as do, DELEGATION_TRACE_MAX_SPANS as dp, CodeModeOptions as dr, SupervisorAgentTestDeps as ds, createRootHandle as dt, ScoreOf as du, probeSandboxCapabilities as ea, runFinalizer as ec, DefinedAnalystRecord as ed, DetachedWinnerSelection as ef, defaultStructuralRolloutPolicy as ei, LoopUntilSpec as el, InMemoryResultBlobStore as em, createFileRunContext as en, BenchmarkTaskRow as eo, DelegationStatus as ep, freeSlots as er, withWorkerSpawnRetry as es, gitWorkspace as et, sentinelCompletion as eu, SurfaceDiff as f, ResolveSandboxClientOptions as fa, DriverUnmetContractDecision as fc, QuestionLevel as fd, DetachedSessionRefParts as ff, EvolutionAuthor as fi, ScopeWidenGate as fl, contentAddress as fm, InteractiveWorkerEnvironment as fn, ShotSpec as fo, DelegationTraceCaps as fp, CodeModeRunner as fr, SupervisorNodeContext as fs, createSupervisor as ft, leaderboard as fu, WatchedSurface as g, promotionGate as ga, RunAgentRoundsOptions as gc, QuestionUrgency as gd, DriveTurnTick as gf, EvolutionReport as gi, TrajectoryReportFn as gl, CanonicalAgentProfileMaterializationAxis as gm, workerFromInteractiveProvider as gn, StrategyMessage as go, capDelegationTrace as gp, ChatSessionStore as gr, SupervisorToolInvocationContext as gs, RunCancelRequest as gt, renderLeaderboardSvg as gu, SurfaceReader as h, PromotionVerdict as ha, defaultUnmetContractSteer as hc, QuestionRecord as hd, DriveTurnCapableBox as hf, EvolutionGeneration as hi, TrajectoryReport as hl, AssertProfileMaterializationOptions as hm, InteractiveWorkerResult as hn, StrategyCtx as ho, buildDelegationTraceSpans as hp, ChatCompletionsTransport as hr, SupervisorToolDescriptor as hs, settledToIteration as ht, renderLeaderboardMarkdown as hu, SandboxEvent$1 as i, recoverRetainedRun as ia, DriverBudgetReadout as ic, DownMessageEvent as id, detachedSessionDelegate as if, resolveEntrySymbol as ii, PanelSpec as il, SpawnForestInDoubtNode as im, ProvisionedSupervisor as in, AgenticOptions as io, FeedbackRefersTo as ip, defaultDelegateBudget as ir, DriveHarness as is, TrajectoryAnalysis as it, Interval as iu, AttachWorkerOptions as j, fanout as ja, HarvestReport as jc, questionEscalationTargets as jd, SubmitInput as jf, McpSpawnFault as ji, PersonaExecutors as jl, renderProfileMaterializationIssues as jm, TraversalContinuity as jn, SuperviseDispatchOptions as jo, PlannerError as jp, ProfileRichness as jr, ProgressTrackerOptions as js, readWorkerSteerAcknowledgement as jt, WaterfallCollector as ju, WorktreeFanoutOptions as k, InMemoryCorpus as ka, HarvestCorpusOptions as kc, normalizeAnalyzeOnSettle as kd, DelegationTaskQueue as kf, LocalMcpMaterialization as ki, Persona as kl, promptOnlyProfileMaterialization as km, RunGraphOptions as kn, LoopDispatchOptions as ko, JudgeError as kp, spendFromUsageEvents as kr, ProgressSample as ks, readWorkerCancelRequests as kt, plateauLength as ku, createVerifierEnvironment as l, reconnectRetainedInteractiveRun as la, DriverRepromptRefusal as lc, QuestionEscalationOutcome as ld, SiblingSandboxExecutorOptions as lf, ChampionPick as li, RenderCorpusToInstructionsOptions as ll, materializeTreeView as lm, WorktreeCliExecutorOptions as ln, ArtifactHandle as lo, CappedDelegationTrace as lp, driverAgent as lr, ResolvedSupervisorProfile as ls, parseWorkerToolTraceArtifact as lt, PairwiseVerdict as lu, SurfaceReadOutcome as m, PromotionGateOptions as ma, classifyDriverFailure as mc, QuestionPolicy as md, DetachedTurnResumeDriverOptions as mf, EvolutionCandidate as mi, TrajectoryNode as ml, AgentProfileMaterializationAxis as mm, InteractiveWorkerOptions as mn, StrategyArtifacts as mo, DelegationTraceSpan as mp, unsafeInProcessRunner as mr, SupervisorProfile as ms, createScope as mt, renderLeaderboardHtml as mu, AnalystFinding$1 as n, acquireSandbox as na, DriverAttemptStop as nc, DownMessageDeliveryAttempt as nd, UiAuditorDelegate as nf, modelAuthoredChecks as ni, Panel as nl, SpawnForest as nm, ProvisionSupervisorConnection as nn, printBenchmarkReport as no, DelegationStatusResult as np, rollingDispatch as nr, CoordinationToolFace as ns, localShell as nt, AxisScoresOf as nu, computeFindingId$1 as o, startRetainedRunInEnvironment as oa, DriverProgressMark as oc, MakeWorkerAgent as od, DelegationExecutor as of, selectBestIndex as oi, Pipeline as ol, SpawnForestNode as om, provisionSupervisor as on, AgenticSurface as oo, UiAuditLensFilter as op, CoordinationMcpHandle as or, ObserveSupervisorNodeEvent as os, WORKER_TOOL_TRACE_SCHEMA_VERSION as ot, LeaderboardOptions as ou, SurfaceReadBox as p, resolveSandboxClient as pa, OnUnmetContract as pc, QuestionOption as pd, DetachedTurn as pf, EvolutionBandInfo as pi, SteerContext as pl, AGENT_PROFILE_MATERIALIZATION_AXES as pm, InteractiveWorkerKeyInput as pn, Strategy as po, DelegationTraceCollector as pp, codeModeSupervisorTools as pr, SupervisorNodeContextSeed as ps, ScopeArgs as pt, pairwiseSignificance as pu, copyUntrackedIntoClone as q, createMcpEnvironment as qa, EqualKVerdict as qc, InMemoryFeedbackStore as qd, DelegationFeedbackSnapshot as qf, ForkCapableBox as qi, defineLeaderboard as ql, supervisorPolicyPrompt as qn, ResolvedWorkerSpawnRetry as qo, watchTrace as qp, StructuralRolloutPolicy as qr, DeliveredOutput as qs, workerSteerRequestFile as qt, ContinuationInstruction as qu, CreateSandboxOptions$1 as r, reconnectRetainedRun as ra, DriverAttemptsExhaustedError as rc, DownMessageDeliveryOutcome as rd, coderTaskFromArgs as rf, officialChecksFromMeta as ri, PanelJudge as rl, SpawnForestEvent as rm, ProvisionSupervisorRequest as rn, runBenchmark as ro, FeedbackRating as rp, DelegateOptions as rr, CoordinationVerbs as rs, runInWorkspace as rt, GroupOf as ru, makeFinding$1 as s, ClaimRetainedInteractiveControlOptions as sa, DriverReentry as sc, Question as sd, FleetHandle as sf, structuralRollout as si, PipelineStage as sl, SpawnForestTree as sm, PatchDeliverableOptions as sn, AgenticTask as so, UiAuditorDelegationOutput as sp, serveCoordinationMcp as sr, ResolveDriveHarness as ss, WorkerToolTraceArtifact as st, LeaderboardRow as su, AgentProfile$2 as t, AcquireOptions as ta, DriverAttemptRecord as tc, DownMessageAuthorizationInput as td, SettleDetachedCoderTurnOptions as tf, filterAuthoredAsserts as ti, LoopUntilState as tl, InMemorySpawnJournal as tm, createInMemoryRunContext as tn, Environment as to, DelegationStatusArgs as tp, queueOf as tr, CoordinationBinding as ts, jjWorkspace as tt, stopSentinel as tu, BoxSurfaceReaderOptions as u, recoverRetainedInteractiveRun as ua, DriverRetryPolicy as uc, QuestionEscalationRecord as ud, createFleetWorkspaceExecutor as uf, ChampionPolicy as ui, ScopeAnalyst as ul, pendingWaits as um, WorktreePatchArtifact as un, CorpusReadbackOptions as uo, DELEGATION_TRACE_MAX_BYTES as up, finalizeBestDelivered as ur, SupervisorAgentDeps as us, workerTraceAnalysisStore as ut, ProfileKeyOf as uu, fsSurfaceReader as v, profileOptimizerModelCall as va, TerminalDecision as vc, SpawnPreflight as vd, createDetachedTurnResumeDriver as vf, StrategyEvolutionConfig as vi, Verify as vl, KnownAgentProfileMaterializationAxis as vm, readWorkerInteractiveAdmissions as vn, StrategyShotResult as vo, createDelegationTraceCollector as vp, ChatTransportTool as vr, resolveSupervisorProfile as vs, WorkerCancelRequest as vt, AuditIntentInput as vu, SurfaceWorkerOut as w, createShapeRegistry as wa, inlineSandboxClient as wc, WorkerWatchOptions as wd, DelegationRecord as wf, AuthoredStrategy as wi, WinnerStrategy as wl, defineProfileMaterializationContract as wm, EdgeTraversal as wn, refine as wo, InMemoryDelegationStore as wp, BudgetPoolRestore as wr, FileCoordinationLog as ws, cancelWorker as wt, AnytimeStrategySummary as wu, SuperviseSurfaceOptions as x, equalKOnCost as xa, runAgentRounds as xc, SpawnRefusalCause as xd, parseDetachedSessionRef as xf, runStrategyEvolution as xi, WidenDecision as xl, ValidateProfileMaterializationOptions as xm, createInPlaceCliExecutor as xn, breadthStrategy as xo, DelegationStore as xp, chatWorkerSeam as xr, CoordinationDeliveryEvidence as xs, WorkerSteerRequest as xt, auditIntent as xu, harvestSurfaceDiffs as y, assertModelAllowed as ya, defaultSelectWinner as yc, SpawnPreflightContext as yd, detachedTurnEvents as yf, discriminatingMeans as yi, VerifySpec as yl, ProfileMaterializationContract as ym, workerInteractiveAdmissionFile as yn, SurfaceScore as yo, DelegationPersistenceError as yp, ChatWorkerSeamOptions as yr, supervisorAgent as ys, WorkerCancellation as yt, AuditIntentOptions as yu, NOTE_MAX_CHARS as z, CreateScopeAnalystOptions as za, AssertTraceDerivedFindings as zc, DelegateArgs as zd, DelegateResearchArgs as zf, OpenSandboxRunOptions as zi, LeaderboardBenchTask as zl, createPromptRegistry as zn, DeliverableResolutionInput as zo, BusEvent as zp, CheckOutcome as zr, noProgressFor as zs, workerCancelRequestsFile as zt, AnalystLensOutput as zu };
+//# sourceMappingURL=index-B2rVjcPT.d.ts.map