@tangle-network/agent-runtime 0.190.0 → 0.191.0

package/dist/{index-DpNil9jh.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 { A as ProviderModelExecutionEvidence, B as Settled, Bn as RecoverRetainedRunOptions, C as NoWinnerError, E as NodeSnapshot, H as SpawnJournal, Hn as RetainedInteractiveAdmission, J as SpendGap, K as Spend, Kn as RetainedRunAdmission, M as ResumedKeyState, Mn as RetainedInteractiveRunHandle, O as ProfileMaterializationReceipt, On as ReconnectRetainedInteractiveRunOptions, Ot as OtelExportConfig, P as RootHandle, Pn as StartRetainedInteractiveRunOptions, R as Runtime, Rn as ReconnectRetainedRunOptions, T as NodeId, Tn as WorkerProgress, U as SpawnOpts, V as SpawnEvent, Vn as RecoverRetainedRunResult, X as SupervisedResult, Y as SteerableRootHandle, Z as Supervisor, Zn as RetainedRunEffect, _ as ExecutorRegistry, a as DefaultVerdict, ct as WorkerTraceEvidence, er as RetainedRunHandle, et as TreeView, gn as TraceSource, gt as TraceContext, i as Budget, in as WaitProbeRegistry, j as ResultBlobStore, kn as RecoverRetainedInteractiveRunOptions, kt as OtelExporter, n as AgentExecutionRef, o as ExecutionBindingReceipt, or as StartRetainedRunInEnvironmentOptions, ot as WorkerInteractiveSession, p as ExecutorFactory, r as AgentSpec, rt as UsageEvent, s as Executor, sr as StartRetainedRunOptions, st as WorkerInteractiveUnavailableReason, t as Agent, tn as PendingWait, tt as UnconfirmedTeardown, ut as WorkerTraceResolver, v as ExecutorResult, w as NodeExecutionIdentity, z as Scope, zn as RecoverRetainedRunIntentOptions } from "./types-02hXqnSP.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-BMWmSu4A.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-Bf-hgR6p.js";
-import "./stream-agent-turn-uqzf9ZEh.js";
+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, TraceAnalysisStore, ValidationError, buildTrajectory, computeFindingId as computeFindingId$1, makeFinding as makeFinding$1 } from "@tangle-network/agent-eval";
+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. */
@@ -4385,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>;
@@ -4485,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
@@ -4610,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>;
@@ -5038,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>;
@@ -7355,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`. */
@@ -7576,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>;
@@ -7924,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", "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"];
+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.
@@ -9085,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. */
@@ -9272,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, LoopUntilSpec as $c, DetachedTurn as $d, DelegationTraceCollector as $f, probeSandboxCapabilities as $i, sentinelCompletion as $l, freeSlots as $n, withWorkerSpawnRetry as $o, AGENT_PROFILE_MATERIALIZATION_AXES as $p, defaultStructuralRolloutPolicy as $r, runFinalizer as $s, createFileRunContext as $t, QuestionDecision as $u, AttachWorkerOptions as A, fanout as Aa, HarvestReport as Ac, validateDelegateArgs as Ad, DelegateUiAuditResult as Af, McpSpawnFault as Ai, PersonaExecutors as Al, TraversalContinuity as An, SuperviseDispatchOptions as Ao, createEventBus as Ap, ProfileRichness as Ar, ProgressTrackerOptions as As, readWorkerSteerAcknowledgement as At, WaterfallCollector as Au, WorkerEvidenceInput as B, assertTraceDerivedFindings as Ba, Corpus as Bc, DetachedWinnerSelection as Bd, DelegationStatus as Bf, SandboxRun as Bi, LeaderboardFlagSpec as Bl, dumbContinuationFailPrompt as Bn, SuperviseRegistry as Bo, InMemoryResultBlobStore as Bp, CheckRunner as Br, sampleFromSettled as Bs, workerCancellationsDir as Bt, ContinuationInstruction as Bu, SurfaceWorkerOut as C, createShapeRegistry as Ca, inlineSandboxClient as Cc, DELEGATE_INPUT_SCHEMA as Cd, DelegateFeedbackArgs as Cf, AuthoredStrategy as Ci, WinnerStrategy as Cl, EdgeTraversal as Cn, refine as Co, ValidationError as Cp, BudgetPoolRestore as Cr, FileCoordinationLog as Cs, cancelWorker as Ct, AnytimeStrategySummary as Cu, AuthoredHarness as D, FileCorpus as Da, inProcessSandboxClient as Dc, DelegateHandlerOptions as Dd, DelegateResearchResult as Df, strategyAuthorSystemPrompt as Di, Outcome as Dl, GraphResult as Dn, LoopCampaignDispatchOptions as Do, BusStats as Dp, createBudgetPool as Dr, PlateauOptions as Ds, readRunCancellation as Dt, bestSoFar as Du, superviseSurface as E, runPersonified as Ea, InProcessSandboxClientOptions as Ec, DelegateError as Ed, DelegateResearchConfig as Ef, strategyAuthorContract as Ei, LoopShape as El, GraphNode as En, sampleThenRefine as Eo, BusRecord as Ep, ReservationTicket as Er, NoProgressForOptions as Es, readRunCancelRequest as Et, areaUnderCurve as Eu, workerInteractiveBindingFile as F, selectValidWinner as Fa, defaultAnalystInstruction as Fc, CoderDelegate as Fd, DelegationHistoryEntry as Ff, materializeLocalMcp as Fi, ShapeRegistry as Fl, PromptRegistry as Fn, AuthorizedSpawn as Fo, ExecutorResultMapping as Fp, profileRichnessFinding as Fr, allWorkersStalled as Fs, supervisorRunDir as Ft, AnalystLensOutput as Fu, UntrackedCopyStats as G, McpEnvironmentOptions as Ga, EqualKOnCostOptions as Gc, settleDetachedCoderTurn as Gd, ResearchOutputShape as Gf, CheckpointCapableBox as Gi, LeaderboardSpec as Gl, promptHandle as Gn, workerFromBackend as Go, SpawnForestMissingTree as Gp, StructuralRolloutMessage as Gr, createSupervisorSpanRecorder as Gs, workerSteerAcknowledgementsDir as Gt, CoordinationToolsOptions as Gu, composeWorkerEvidence as H, createScopeAnalyst as Ha, CorpusRecord as Hc, UiAuditorDelegate as Hd, DelegationStatusResult as Hf, TurnResult as Hi, LeaderboardRunContext as Hl, formatPromptHandle as Hn, SuperviseTestOptions as Ho, SpawnForest as Hp, CheckSourceCtx as Hr, SupervisorSpanOptions as Hs, workerInboxFile as Ht, CoordinationEvent as Hu, workerInteractiveBindingsDir as I, verify as Ia, observe as Ic, CoderReview as Id, DelegationHistoryResult as If, Deliverable as Ii, DefinedLeaderboard as Il, RegisteredPrompt as In, AuthorizedSpawnContext as Io, gateOnDeliverable as Ip, supervisorInstructions as Ir, anyOf as Is, supervisorRunsRoot as It, AnalystRegistry as Iu, GitWorkspaceOptions as J, BenchmarkCell as Ja, FanoutOptions as Jc, FleetWorkspaceExecutorOptions as Jd, delegationProfiles as Jf, SandboxLineageHandle as Ji, CompletionEvidence as Jl, DispatchReport as Jn, WorkerSpawnRetryHooks as Jo, loadSpawnForest as Jp, VisibleCheck as Jr, FinalizerSettled as Js, workerSteersDir as Jt, DownMessageDeliveryAttempt as Ju, copyUntrackedIntoClone as K, createMcpEnvironment as Ka, EqualKVerdict as Kc, DelegationExecutor as Kd, UiAuditLensFilter as Kf, ForkCapableBox as Ki, defineLeaderboard as Kl, supervisorPolicyPrompt as Kn, ResolvedWorkerSpawnRetry as Ko, SpawnForestNode as Kp, StructuralRolloutPolicy as Kr, DeliveredOutput as Ks, workerSteerRequestFile as Kt, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as Ku, EVIDENCE_MAX_CHARS as L, widen as La, renderReport as Lc, CoderReviewer as Ld, DelegationProfile as Lf, OpenSandboxRunBeforeStartContext as Li, LeaderboardBenchScore as Ll, analyzesFindingsReportPrompt as Ln, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as Lo, mapExecutorResult as Lp, CheckExecChannel as Lr, createProgressTracker as Ls, supervisorWorkersDir as Lt, AnalyzeOnSettleRoute as Lu, WorkerInteractiveProviderSource as M, loopUntil as Ma, Observation as Mc, FeedbackStore as Md, DelegationError as Mf, StdioMcpConnection as Mi, RunPersonifiedOptions as Ml, runGraph as Mn, loopCampaignDispatch as Mo, defaultToolDetectors as Mp, asAuthoredProfile as Mr, StopDecision as Ms, runCancelRequestFile as Mt, WaterfallSpan as Mu, attachWorker as N, panel as Na, ObserveInput as Nc, InMemoryFeedbackStore as Nd, DelegationFeedbackSnapshot as Nf, StdioMcpServerSpec as Ni, ShapeBudget as Nl, runGraphWithTestBrain as Nn, loopDispatch as No, watchTrace as Np, assessAuthoredProfile as Nr, StopRule as Ns, runCancellationFile as Nt, createWaterfallCollector as Nu, WorktreeFanoutOptions as O, InMemoryCorpus as Oa, HarvestCorpusOptions as Oc, DelegateResult as Od, DelegateUiAuditArgs as Of, LocalMcpMaterialization as Oi, Persona as Ol, RunGraphOptions as On, LoopDispatchOptions as Oo, EventBus as Op, spendFromUsageEvents as Or, ProgressSample as Os, readWorkerCancelRequests as Ot, plateauLength as Ou, readWorkerInteractiveBinding as P, pipeline as Pa, ObserveOptions as Pc, eventToSnapshot as Pd, DelegationHistoryArgs as Pf, connectStdioMcp as Pi, ShapeContext as Pl, PromptHandle as Pn, superviseDispatch as Po, DeliverableSpec as Pp, defaultProfileRichnessThresholds as Pr, allOf as Ps, safeWorkerFile as Pt, AnalystFindingEvent as Pu, WorkspaceRun as Q, BenchmarkStrategySummary as Qa, LoopUntil as Qc, DetachedSessionRefParts as Qd, DelegationTraceCaps as Qf, SandboxCapabilities as Qi, deterministicCompletion as Ql, effectiveConcurrency as Qn, retryPreSpawnRefusals as Qo, contentAddress as Qp, defaultExtractCandidate as Qr, pickBestDelivered as Qs, RunContext as Qt, Question as Qu, NOTE_MAX_CHARS as R, CreateScopeAnalystOptions as Ra, AssertTraceDerivedFindings as Rc, DelegateRunCtx as Rd, DelegationProgress as Rf, OpenSandboxRunOptions as Ri, LeaderboardBenchTask as Rl, createPromptRegistry as Rn, DeliverableResolutionInput as Ro, FileResultBlobStore as Rp, CheckOutcome as Rr, noProgressFor as Rs, workerCancelRequestsFile as Rt, AuthorizeDownMessage as Ru, SurfaceWorkerConfig as S, builtinShapes as Sa, localSandboxClient as Sc, DELEGATE_DESCRIPTION as Sd, DelegateCodeResult as Sf, AuthorStrategyOptions as Si, WidenSpec as Sl, EdgeDeliveryOutcome as Sn, depthStrategy as So, RuntimeRunStateError as Sp, BudgetPool as Sr, CoordinationOwnerId as Ss, cancelRun as St, AnytimeReport as Su, failuresAnalyst as T, definePersona as Ta, InProcessPromptCtx as Tc, DelegateArgs as Td, DelegateResearchArgs as Tf, authorStrategy as Ti, DefinePersonaInput as Tl, GraphEdgeCapError as Tn, sample as To, BusEvent as Tp, ReservationRejection as Tr, AllWorkersStalledOptions as Ts, legacySupervisorRunsRoot as Tt, anytimeReport as Tu, settledWorkerOut as U, registryScopeAnalyst as Ua, EqualKArm as Uc, coderTaskFromArgs as Ud, FeedbackRating as Uf, openSandboxRun as Ui, LeaderboardScenario as Ul, kernelPromptRegistry as Un, supervise as Uo, SpawnForestEvent as Up, RepairStop as Ur, SupervisorSpanOutcome as Us, workerInboxFileFromEventDir as Ut, CoordinationStats as Uu, closingWorkerNote as V, buildSteerContext as Va, CorpusFilter as Vc, SettleDetachedCoderTurnOptions as Vd, DelegationStatusArgs as Vf, SandboxRunAbortError as Vi, LeaderboardIterationInfo as Vl, dumbContinuationPassPrompt as Vn, SuperviseRegistryTable as Vo, InMemorySpawnJournal as Vp, CheckSource as Vr, SupervisorSpanAttributes as Vs, workerControlLogFile as Vt, ContinuityMode as Vu, CopyOptions as W, McpEndpoint as Wa, EqualKOnCost as Wc, detachedSessionDelegate as Wd, FeedbackRefersTo as Wf, BranchCapableBox as Wi, LeaderboardScore as Wl, naiveContinuationPrompt as Wn, superviseWithTestBrain as Wo, SpawnForestInDoubtNode as Wp, StructuralRolloutConfig as Wr, SupervisorSpanRecorder as Ws, workerSteerAcknowledgementFile as Wt, CoordinationTools as Wu, Workspace as X, BenchmarkLift as Xa, FanoutWinnerSelector as Xc, createFleetWorkspaceExecutor as Xd, DELEGATION_TRACE_MAX_BYTES as Xf, createSandboxLineage as Xi, CompletionVerdict as Xl, DispatchUnit as Xn, isPreSpawnExecutorFailure as Xo, pendingWaits as Xp, compareCheckOutcomes as Xr, bestDelivered as Xs, InMemoryRunContext as Xt, DownMessageEvent as Xu, Shell as Y, BenchmarkConfig as Ya, FanoutSynthesis as Yc, SiblingSandboxExecutorOptions as Yd, CappedDelegationTrace as Yf, SessionCapableBox as Yi, CompletionPolicy as Yl, DispatchStopReason as Yn, WorkerSpawnRetryPolicy as Yo, materializeTreeView as Yp, canDisplace as Yr, SupervisorFinalizer as Ys, writeWorkerSteer as Yt, DownMessageDeliveryOutcome as Yu, WorkspaceCommit as Z, BenchmarkReport as Za, FlatWidenGate as Zc, createSiblingSandboxExecutor as Zd, DELEGATION_TRACE_MAX_SPANS as Zf, CriuCapableClient as Zi, completionAuthorizes as Zl, RollingDispatchOptions as Zn, resolveWorkerSpawnRetry as Zo, replaySpawnTree as Zp, composeCheckSources as Zr, collectDelivered as Zs, InMemoryRunContextOptions as Zt, MakeWorkerAgent as Zu, boxSurfaceReader as _, profileOptimizerModelCall as _a, TerminalDecision as _c, questionEscalationTargets as _d, SubmitInput as _f, StrategyEvolutionConfig as _i, Verify as _l, renderProfileMaterializationIssues as _m, readWorkerInteractiveAdmissions as _n, StrategyShotResult as _o, PlannerError as _p, ChatTransportTool as _r, resolveSupervisorProfile as _s, WorkerCancelRequest as _t, AuditIntentInput as _u, SandboxInstance$1 as a, startRetainedRunInEnvironment as aa, DriverProgressMark as ac, QuestionUrgency as ad, detachedTurnEvents as af, selectBestIndex as ai, Pipeline as al, ProfileMaterializationContract as am, provisionSupervisor as an, AgenticSurface as ao, DelegationPersistenceError as ap, CoordinationMcpHandle as ar, ObserveSupervisorNodeEvent as as, WORKER_TOOL_TRACE_SCHEMA_VERSION as at, LeaderboardOptions as au, SuperviseSurfaceOptions as b, equalKOnCost as ba, runAgentRounds as bc, createInProcessTransport as bd, DelegateCodeArgs as bf, runStrategyEvolution as bi, WidenDecision as bl, worktreeCliProfileMaterialization as bm, createInPlaceCliExecutor as bn, breadthStrategy as bo, RetainedRunAdmissionError as bp, chatWorkerSeam as br, CoordinationDeliveryEvidence as bs, WorkerSteerRequest as bt, auditIntent as bu, VerifierEnvironmentOptions as c, reconnectRetainedInteractiveRun as ca, DriverRepromptRefusal as cc, SpawnPreflightContext as cd, runDetachedTurn as cf, ChampionPick as ci, RenderCorpusToInstructionsOptions as cl, assertProfileMaterialization as cm, WorktreeCliExecutorOptions as cn, ArtifactHandle as co, FileDelegationStore as cp, driverAgent as cr, ResolvedSupervisorProfile as cs, parseWorkerToolTraceArtifact as ct, PairwiseVerdict as cu, HarvestSurfaceDiffsOptions as d, ResolveSandboxClientOptions as da, DriverUnmetContractDecision as dc, WorkerResumeContext as dd, DelegationResumeContext as df, EvolutionAuthor as di, ScopeWidenGate as dl, fullProfileMaterialization as dm, InteractiveWorkerEnvironment as dn, ShotSpec as do, AgentEvalError$1 as dp, CodeModeRunner as dr, SupervisorNodeContext as ds, createSupervisor as dt, leaderboard as du, AcquireOptions as ea, DriverAttemptRecord as ec, QuestionEscalationTarget as ed, DetachedTurnResumeDriverOptions as ef, filterAuthoredAsserts as ei, LoopUntilState as el, AgentProfileMaterializationAxis as em, createInMemoryRunContext as en, Environment as eo, DelegationTraceSpan as ep, queueOf as er, CoordinationBinding as es, jjWorkspace as et, stopSentinel as eu, SurfaceDiff as f, resolveSandboxClient as fa, OnUnmetContract as fc, WorkerSpawnContext as fd, DelegationResumeDriver as ff, EvolutionBandInfo as fi, SteerContext as fl, profileMaterializationAxes$1 as fm, InteractiveWorkerKeyInput as fn, Strategy as fo, AgentEvalErrorCode as fp, codeModeSupervisorTools as fr, SupervisorNodeContextSeed as fs, ScopeArgs as ft, pairwiseSignificance as fu, WatchedSurface as g, profileChatClient as ga, TERMINAL_DECISIONS as gc, normalizeAnalyzeOnSettle as gd, DelegationTaskQueueOptions as gf, ReproductionCheck as gi, TrajectoryReportOptions as gl, promptResourceProfileMaterialization as gm, WorkerInteractiveAdmission as gn, StrategyResult as go, NotFoundError as gp, ChatTransportExecutorOptions as gr, assertCoordinationBinding as gs, RunCancellation as gt, renderPairwiseMarkdown as gu, SurfaceReader as h, promotionGate as ha, RunAgentRoundsOptions as hc, createCoordinationTools as hd, DelegationTaskQueue as hf, EvolutionReport as hi, TrajectoryReportFn as hl, promptOnlyProfileMaterialization as hm, workerFromInteractiveProvider as hn, StrategyMessage as ho, JudgeError as hp, ChatSessionStore as hr, SupervisorToolInvocationContext as hs, RunCancelRequest as ht, renderLeaderboardSvg as hu, SandboxEvent$1 as i, startRetainedRun as ia, DriverContractState as ic, QuestionRecord as id, createDetachedTurnResumeDriver as if, sandboxCheckRunner as ii, PanelVerdict as il, KnownAgentProfileMaterializationAxis as im, SupervisorCleanupReceipt as in, AgenticRunResult as io, createDelegationTraceCollector as ip, delegate as ir, DriveHarnessOwnerContext as is, analyzeTrace as it, Leaderboard as iu, WorkerInteractiveBinding as j, flatWidenGate as ja, harvestCorpus as jc, FeedbackEvent as jd, DelegateUiAuditRoute as jf, McpToolDescriptor as ji, RunPersonified as jl, defaultEdgeTraversalCap as jn, SuperviseOptionsForDispatch as jo, WatchTraceOptions as jp, ProfileRichnessThresholds as jr, ProgressView as js, readWorkerSteerRequests as jt, WaterfallReport as ju, worktreeFanout as k, renderCorpusToInstructions as ka, HarvestFailure as kc, createDelegateHandler as kd, DelegateUiAuditConfig as kf, MaterializeLocalMcpOptions as ki, PersonaContext as kl, RunGraphTestOptions as kn, LoopOptionsForDispatch as ko, PublishOptions as kp, AuthoredProfile as kr, ProgressTracker as ks, readWorkerCancellation as kt, renderAnytimeTable as ku, createVerifierEnvironment as l, recoverRetainedInteractiveRun as la, DriverRetryPolicy as lc, SpawnRefusal as ld, DelegationArgs as lf, ChampionPolicy as li, ScopeAnalyst as ll, controlProfileMaterialization as lm, WorktreePatchArtifact as ln, CorpusReadbackOptions as lo, FileDelegationStoreOptions as lp, finalizeBestDelivered as lr, SupervisorAgentDeps as ls, workerTraceAnalysisStore as lt, ProfileKeyOf as lu, SurfaceReadOutcome as m, PromotionVerdict as ma, defaultUnmetContractSteer as mc, canonicalFindingEvent as md, DelegationRunContext as mf, EvolutionGeneration as mi, TrajectoryReport as ml, promptModelProfileMaterialization as mm, InteractiveWorkerResult as mn, StrategyCtx as mo, ConfigError as mp, ChatCompletionsTransport as mr, SupervisorToolDescriptor as ms, settledToIteration as mt, renderLeaderboardMarkdown as mu, AnalystFinding$1 as n, reconnectRetainedRun as na, DriverAttemptsExhaustedError as nc, QuestionOption as nd, DriveTurnTick as nf, officialChecksFromMeta as ni, PanelJudge as nl, CanonicalAgentProfileMaterializationAxis as nm, ProvisionSupervisorRequest as nn, runBenchmark as no, capDelegationTrace as np, DelegateOptions as nr, CoordinationVerbs as ns, runInWorkspace as nt, GroupOf as nu, computeFindingId$1 as o, ClaimRetainedInteractiveControlOptions as oa, DriverReentry as oc, SettledWorker as od, formatDetachedSessionRef as of, structuralRollout as oi, PipelineStage as ol, ProfileMaterializationIssue as om, PatchDeliverableOptions as on, AgenticTask as oo, DelegationStateCorruptError as op, serveCoordinationMcp as or, ResolveDriveHarness as os, WorkerToolTraceArtifact as ot, LeaderboardRow as ou, SurfaceReadBox as p, PromotionGateOptions as pa, classifyDriverFailure as pc, WorkerWatchOptions as pd, DelegationResumeTick as pf, EvolutionCandidate as pi, TrajectoryNode as pl, promptControlProfileMaterialization as pm, InteractiveWorkerOptions as pn, StrategyArtifacts as po, BackendTransportError as pp, unsafeInProcessRunner as pr, SupervisorProfile as ps, createScope as pt, renderLeaderboardHtml as pu, withUntrackedArtifacts as q, sanitizeMcpToolSchema as qa, Fanout as qc, FleetHandle as qd, UiAuditorDelegationOutput as qf, SandboxLineage as qi, CompletionAnalyst as ql, ConcurrencyCaps as qn, WorkerSpawnRetryAttempt as qo, SpawnForestTree as qp, StructuralRolloutResult as qr, FinalizeContext as qs, workerSteerRequestsDir as qt, DownMessageAuthorizationInput as qu, CreateSandboxOptions$1 as r, recoverRetainedRun as ra, DriverBudgetReadout as rc, QuestionPolicy as rd, RunDetachedTurnOptions as rf, resolveEntrySymbol as ri, PanelSpec as rl, DefineProfileMaterializationContractOptions as rm, ProvisionedSupervisor as rn, AgenticOptions as ro, composeLoopTraceEmitters as rp, defaultDelegateBudget as rr, DriveHarness as rs, TrajectoryAnalysis as rt, Interval as ru, makeFinding$1 as s, claimRetainedInteractiveControl as sa, DriverRepromptPolicy as sc, SpawnPreflight as sd, parseDetachedSessionRef as sf, visibleCheckScore as si, RenderCorpusToInstructions as sl, ValidateProfileMaterializationOptions as sm, patchDelivered as sn, AgenticTool as so, DelegationStore as sp, DriverAgentOptions as sr, ResolveSupervisorTools as ss, captureWorkerTraceEvidence as st, PairwiseOptions as su, AgentProfile$2 as t, acquireSandbox as ta, DriverAttemptStop as tc, QuestionLevel as td, DriveTurnCapableBox as tf, modelAuthoredChecks as ti, Panel as tl, AssertProfileMaterializationOptions as tm, ProvisionSupervisorConnection as tn, printBenchmarkReport as to, buildDelegationTraceSpans as tp, rollingDispatch as tr, CoordinationToolFace as ts, localShell as tt, AxisScoresOf as tu, BoxSurfaceReaderOptions as u, startRetainedInteractiveRun as ua, DriverUnmetContractContext as uc, SpawnRefusalCause as ud, DelegationRecord as uf, EvolutionArchiveNode as ui, ScopeAnalyzeInput as ul, defineProfileMaterializationContract as um, createWorktreeCliExecutor as un, RunAgenticOptions as uo, InMemoryDelegationStore as up, CodeModeOptions as ur, SupervisorAgentTestDeps as us, createRootHandle as ut, ScoreOf as uu, fsSurfaceReader as v, assertModelAllowed as va, defaultSelectWinner as vc, McpServer as vd, SubmitOutput as vf, discriminatingMeans as vi, VerifySpec as vl, sandboxActProfileMaterialization as vm, workerInteractiveAdmissionFile as vn, SurfaceScore as vo, RetainedInteractiveAdmissionError as vp, ChatWorkerSeamOptions as vr, supervisorAgent as vs, WorkerCancellation as vt, AuditIntentOptions as vu, analystsFromRegistry as w, registerShape as wa, InProcessOnPrompt as wc, DELEGATE_TOOL_NAME as wd, DelegateFeedbackResult as wf, assertStrategyContract as wi, DefinePersona as wl, GraphEdge as wn, runAgentic as wo, CoderOutput as wp, BudgetReadout as wr, PriorCoordination as ws, legacySupervisorRunDir as wt, AnytimeTaskCurve as wu, SuperviseSurfaceResult as x, trajectoryReport as xa, LocalSandboxClientOptions as xc, createMcpServer as xd, DelegateCodeConfig as xf, selectChampion as xi, WidenLineage as xl, AgentGraph as xn, defineStrategy as xo, RetainedRunDispatchBindingError as xp, createChatSessionStore as xr, CoordinationLog as xs, WriteWorkerSteerOptions as xt, defaultAuditorInstruction as xu, harvestSurfaceDiffs as y, assertProfileModelsAllowed as ya, isTerminalDecision as yc, McpServerOptions as yd, hashIdempotencyInput as yf, pickChampion as yi, Widen as yl, validateProfileMaterialization as ym, InPlaceCliExecutorOptions as yn, adaptiveRefine as yo, RetainedInteractiveBindingError as yp, chatTransportExecutor as yr, supervisorAgentWithTestBrain as ys, WorkerSteerAcknowledgement as yt, IntentAudit as yu, VERIFY_TAIL_CHARS as z, RegistryAnalyzeProjection as za, CombinatorShape as zc, DetachedSessionDelegateOptions as zd, DelegationResultPayload as zf, OpenSandboxRunPromptOptions as zi, LeaderboardBenchmarkAdapter as zl, delegatesWorkerBriefPrompt as zn, SuperviseOptions as zo, FileSpawnJournal as zp, CheckRunContext as zr, plateau as zs, workerCancellationFile as zt, AuthorizedDownMessage as zu };
-//# sourceMappingURL=index-DpNil9jh.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

package/dist/{index-Clb7_qML.d.ts → index-OSRVFARy.d.ts}

@@ -1,5 +1,5 @@
 import { V as AgentExecutionBackend, it as RuntimeSessionStore } from "./types-BdolQ6Zi.js";
-import { p as ExecutorFactory } from "./types-02hXqnSP.js";
+import { p as ExecutorFactory } from "./types-DKA_PDv0.js";
 import { AgentProfile } from "@tangle-network/agent-interface";
 import { AgentProfile as AgentProfile$1, MaximumCharge } from "@tangle-network/agent-eval";
 import { ProfileDispatchFn, Scenario } from "@tangle-network/agent-eval/campaign";
@@ -688,4 +688,4 @@ declare function turnId(runId: string, index: number, speaker: string): string;
 declare function slugifySpeaker(speaker: string): string;
 //#endregion
 export { sleep as $, RunConversationOptions as A, buildForwardHeaders as B, ConversationResult as C, HaltPredicate as D, HaltContext as E, InMemoryConversationJournal as F, CircuitBreakerState as G, readDepth as H, DEFAULT_MAX_DEPTH as I, RetryBackoff as J, CircuitOpenError as K, FORWARD_HEADERS as L, ConversationJournal as M, ConversationJournalEntry as N, HaltReason as O, FileConversationJournal as P, makePerAttemptSignal as Q, ForwardHeaderName as R, ConversationPolicy as S, ConversationTurn as T, BackendCallPolicy as U, isDepthExceeded as V, CircuitBreakerConfig as W, computeBackoff as X, RetryableErrorPredicate as Y, defaultIsRetryable as Z, createConversationBackend as _, RunPersonaConfig as a, ConversationDriveState as b, runPersonaDispatch as c, D1DatabaseLike as d, createProfileExecutionBackend as et, D1StmtLike as f, defineConversation as g, d1ToSqlAdapter as h, PersonaDriver as i, TurnOrder as j, HaltSignal as k, runConversation as l, SqlConversationJournal as m, turnId as n, RunPersonaConversationOptions as o, SqlAdapter as p, DeadlineExceededError as q, PersonaConversationResult as r, runPersonaConversation as s, slugifySpeaker as t, runConversationStream as u, AuthSource as v, ConversationStreamEvent as w, ConversationParticipant as x, Conversation as y, PropagatedHeaders as z };
-//# sourceMappingURL=index-Clb7_qML.d.ts.map
+//# sourceMappingURL=index-OSRVFARy.d.ts.map

package/dist/{index-C-gBk5M9.d.ts → index-Y14IrBuB.d.ts}

@@ -1,6 +1,6 @@
-import { Pp as DeliverableSpec, ps as SupervisorProfile, zo as SuperviseOptions } from "./index-DpNil9jh.js";
-import { X as SupervisedResult, i as Budget } from "./types-02hXqnSP.js";
-import { c as ExecutorConfig } from "./runtime-BMWmSu4A.js";
+import { Bo as SuperviseOptions, Jp as DeliverableSpec, ms as SupervisorProfile } from "./index-B2rVjcPT.js";
+import { Z as SupervisedResult, i as Budget } from "./types-DKA_PDv0.js";
+import { c as ExecutorConfig } from "./runtime-DI4mJNXI.js";
 import { y as AgentCandidateOutputArtifactPort } from "./types-1s_29INY.js";
 import { i as AgentImprovementActivationTransition, n as AgentImprovementActivationResultStore, t as AgentImprovementActivationReconciliation } from "./activation-DyWB0K6E.js";
 import { AgentCandidateBundle, AgentCandidateCapturedArtifact, AgentCandidateKnowledge } from "@tangle-network/agent-interface";
@@ -135,4 +135,4 @@ declare function runKnowledgeImprovementJob(options: RunKnowledgeImprovementJobO
 declare function buildKnowledgeImprovementExperimentBundles(bundle: AgentCandidateBundle, knowledge: KnowledgeImprovementCandidatePair): KnowledgeImprovementExperimentBundles;
 //#endregion
 export { KnowledgeImprovementActivationExecutor as C, CreateKnowledgeImprovementActivationExecutorOptions as S, SupervisedKnowledgeUpdater as _, KnowledgeImprovementJobResult as a, knowledgeReadinessDeliverable as b, createAgentKnowledgeReadinessCheck as c, KnowledgeReadinessCheckInput as d, KnowledgeReadinessCheckResult as f, SupervisedKnowledgeUpdateResult as g, SupervisedKnowledgeUpdateOptions as h, KnowledgeImprovementJobMeasurement as i, runKnowledgeImprovementJob as l, SupervisedKnowledgeUpdateInput as m, KnowledgeImprovementCandidatePair as n, RunKnowledgeImprovementJobOptions as o, RESEARCH_SUPERVISOR_SYSTEM_PROMPT as p, KnowledgeImprovementExperimentBundles as r, buildKnowledgeImprovementExperimentBundles as s, AgentKnowledgeReadinessCheckOptions as t, KnowledgeReadinessCheck as u, createSupervisedKnowledgeUpdater as v, createKnowledgeImprovementActivationExecutor as w, runSupervisedKnowledgeUpdate as x, formatSupervisedKnowledgeTask as y };
-//# sourceMappingURL=index-C-gBk5M9.d.ts.map
+//# sourceMappingURL=index-Y14IrBuB.d.ts.map