@tangle-network/agent-runtime 0.123.1 → 0.128.0

package/dist/{index-xP27vtnt.d.ts → index-BhZhQw77.d.ts}

@@ -2,7 +2,7 @@ import { d as AgentTaskStatus, f as BackendErrorDetail, i as AgentExecutionBacke
 import { n as AnalystRegistryLike } from "./types-zWfqDjeL.js";
 import { l as RuntimeHooks } from "./runtime-hooks-sbRpjStq.js";
 import { C as MountRecorder, D as SelectionReceipt, E as SandboxClient, 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-DnNGJ5Gz.js";
-import { B as DefaultVerdict, Cn as PendingWait, Ct as SupervisedResult, En as WaitProbeRegistry, Et as TreeView, Gn as ExecutorProgress, H as Executor, I as Agent, K as ExecutorFactory, L as AgentExecutionRef, Nt as WorkerTraceResolver, Ot as UsageEvent, R as AgentSpec, Rn as TraceSource, Rt as TraceContext, St as SteerableRootHandle, V as ExecutionBindingReceipt, Xt as OtelExportConfig, Y as ExecutorRegistry, Zt as OtelExporter, _t as SpawnJournal, at as ProfileMaterializationReceipt, ct as ResumedKeyState, gt as SpawnEvent, ht as Settled, i as AgentEnvironmentProvider, jt as WorkerTraceEvidence, mt as Scope, nt as NodeId, o as AgentEnvironmentProviderRegistry, pt as Runtime, qn as WorkerProgress, rt as NodeSnapshot, st as ResultBlobStore, tt as NodeExecutionIdentity, ut as RootHandle, vt as SpawnOpts, w as ProviderExecutorOptions, wt as Supervisor, xt as Spend, z as Budget } from "./environment-provider-PM9PeW_J.js";
+import { B as DefaultVerdict, Cn as PendingWait, Ct as SupervisedResult, En as WaitProbeRegistry, Et as TreeView, Gn as ExecutorProgress, H as Executor, I as Agent, K as ExecutorFactory, L as AgentExecutionRef, Nt as WorkerTraceResolver, Ot as UsageEvent, R as AgentSpec, Rn as TraceSource, Rt as TraceContext, St as SteerableRootHandle, V as ExecutionBindingReceipt, Xt as OtelExportConfig, Y as ExecutorRegistry, Zt as OtelExporter, _t as SpawnJournal, at as ProfileMaterializationReceipt, ct as ResumedKeyState, gt as SpawnEvent, ht as Settled, i as AgentEnvironmentProvider, jt as WorkerTraceEvidence, mt as Scope, nt as NodeId, o as AgentEnvironmentProviderRegistry, pt as Runtime, qn as WorkerProgress, rt as NodeSnapshot, st as ResultBlobStore, tt as NodeExecutionIdentity, ut as RootHandle, vt as SpawnOpts, w as ProviderExecutorOptions, wt as Supervisor, xt as Spend, z as Budget } from "./environment-provider-CUFsyymu.js";
 import { o as UiLens, r as UiFinding, s as CoderTask } from "./substrate-BcnuSHXm.js";
 import { E as ToolLoopCompactionOptions, f as runLocalHarness, h as RouterConfig, n as CodexExecutionPolicy, o as LocalHarness, r as CodexTokenUsage, v as ToolSpec, w as ToolLoopChat } from "./local-harness-BIajef4A.js";
 import { AgentEvalError, AgentEvalError as AgentEvalError$1, AgentEvalErrorCode, AgentProfile, AnalystFinding, AnalystFinding as AnalystFinding$1, AnalystFinding as AnalystFinding$2, AnalystRunInputs, ChatClient, ConfigError, DetectorSignal, HarnessType, JudgeError, MaximumCharge, NotFoundError, ProposalFinding, RankTestMethod, RunRecord, StreamingDetector, ToolSpan, TraceAnalysisStore, ValidationError, buildTrajectory, computeFindingId as computeFindingId$1, makeFinding as makeFinding$1 } from "@tangle-network/agent-eval";
@@ -2084,6 +2084,8 @@ interface CliWorktreeBridgeSeam {
   model?: string;
   /** Canonical profile overlay merged over the spawned profile. */
   agentProfile?: AgentProfile$1;
+  /** Caller-owned deadline for each bridge turn. Runtime enforces it locally and sends the
+   *  same value in `execution.timeoutMs` so cli-bridge cannot substitute its own cutoff. */
   timeoutMs?: number;
   /** Stable cli-bridge session id. Defaults to `bridge-worktree-${runId}`. */
   sessionId?: string;
@@ -2145,6 +2147,8 @@ interface BridgeSeam {
   cwd?: string;
   /** Canonical profile overlay merged over the spawned profile. */
   agentProfile?: AgentProfile$1;
+  /** Caller-owned deadline for each bridge turn. Runtime enforces it locally and sends the
+   *  same value in `execution.timeoutMs` so the bridge-owned process follows the same policy. */
   timeoutMs?: number;
   /** Stable, caller-owned cli-bridge session id for harness-side resume. Defaults
    *  to a freshly minted per-spawn id so each worker is its own resumable session. */
@@ -2492,8 +2496,24 @@ declare function canonicalFindingEvent(finding: AnalystFindingEvent): AnalystFin
  * (the audit trail), routing adds delivery, never replaces the record.
  */
 interface AnalyzeOnSettleRoute {
-  /** The analyst lens id (resolved against the `analysts` registry). */
+  /** The analyst id: a lens id resolved against the `analysts` registry, or — when `agent` is
+   *  present — the AGENT analyst's stable identity carried on its finding/steer events (it need
+   *  not exist in any registry). */
   readonly kind: string;
+  /**
+   * Make this analyst a tool-equipped AGENT instead of a registry lens: on each matching settle
+   * the runtime spawns this profile as a WORKER through the SAME spawn machinery a driver spawn
+   * uses (`Scope.spawn` + the run's `makeWorkerAgent` seam) — so its spend reserves from the
+   * conserved pool, its node is journaled and traced like any worker, and a node-pinning seam
+   * sees the spawn context marker (`WorkerSpawnContext.analyst`). Its task is `directive` plus
+   * the settled worker's tool-trace evidence; its settle OUTPUT is the findings, published as a
+   * `finding` event (same canonicalization) and delivered per `to` exactly like registry-analyst
+   * findings. A settle that failed publishes `{ analystRunFailed }`; a spawn the pool or fences
+   * refuse publishes `{ analystSpawnRefused }` — observable, never a silent drop. An agent
+   * analyst's settlement never enters the settled-worker ledger, never feeds the finalizer, and
+   * never re-fires the analyst-on-settle hook (no analyst-on-analyst cascade by construction).
+   */
+  readonly agent?: AgentProfile$1;
   /** Deliver the findings to this live worker, named by its PROFILE NAME (the stable node
    *  identity a graph pins) or its spawn label. Omit = the driver (bus only). Delivery goes
    *  through the same authorization + steer machinery a driver-authored steer uses and is
@@ -2501,7 +2521,10 @@ interface AnalyzeOnSettleRoute {
    *  failed one (`delivered: false`) is a recorded outcome, never a silent drop. */
   readonly to?: string;
   /** Standing instruction wrapped around the findings on a routed delivery — what the recipient
-   *  should DO with the analysis. Omit = the bare findings JSON. */
+   *  should DO with the analysis. For an AGENT analyst (`agent` set) it is instead the analysis
+   *  directive handed to the agent as its task; the routed delivery then carries the bare
+   *  findings, because the directive was already consumed upstream. Omit = the bare findings
+   *  JSON (and, for an agent analyst, a task of evidence only). */
   readonly directive?: string;
   /** Restrict which settled workers feed this lens, by profile name or spawn label. Omit =
    *  every settled `done` worker. */
@@ -2509,6 +2532,23 @@ interface AnalyzeOnSettleRoute {
 }
 /** Normalize the two spellings of an analyst-on-settle entry to the route form. */
 declare function normalizeAnalyzeOnSettle(entry: string | AnalyzeOnSettleRoute): AnalyzeOnSettleRoute;
+/** 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
+ *  identity ({@link WorkerResumeContext}), and the executor seam owns the actual session
+ *  re-attachment. */
+type ContinuityMode = 'fresh' | 'resume';
+/** The resume lineage a `'resume'` spawn hands the executor seam
+ *  ({@link WorkerSpawnContext.resume}). The kernel owns identity, ordering, ledger truth, and
+ *  spend continuity (the resumed worker reserves from the same conserved pool); the seam owns the
+ *  re-attachment itself — e.g. mapping `ofWorker` to a backend session id. */
+interface WorkerResumeContext {
+  /** The prior SETTLED worker whose session the new worker continues. */
+  readonly ofWorker: string;
+  /** 1-based position of the NEW worker in the node's continuity chain: a node spawned once and
+   *  resumed once hands the resumed worker `sequence: 2`. */
+  readonly sequence: number;
+}
 /** The exact result of one parent→child delivery attempt. */
 type DownMessageDeliveryOutcome = 'delivered' | 'unknown-worker' | 'already-settled' | 'runtime-has-no-inbox' | 'scope-stopped' | 'runtime-error';
 /** A durable marker written after authorization and immediately before Runtime calls `Scope.send`.
@@ -2611,6 +2651,18 @@ interface WorkerSpawnContext {
   readonly key?: string;
   /** Trusted candidate/campaign attribution attached by product authorization. */
   readonly execution?: AgentExecutionRef;
+  /** Present (as the analyst id) ONLY when this spawn is an analyst-AGENT run initiated by the
+   *  runtime's analyst-on-settle hook ({@link AnalyzeOnSettleRoute.agent}) — authored by the
+   *  runtime, never accepted from a driver's tool arguments. A node-pinning `makeWorkerAgent`
+   *  reads it to admit the analyst node it would refuse as a driver-authored spawn. */
+  readonly analyst?: string;
+  /** The EFFECTIVE continuity mode of this spawn — the spawn tool's per-call argument when given,
+   *  else the profile name's declared default ({@link CoordinationToolsOptions.continuityByProfile}),
+   *  else `'fresh'`. Absent only from producers that predate continuity — read absence as
+   *  `'fresh'`. */
+  readonly continuity?: ContinuityMode;
+  /** Present iff `continuity === 'resume'`: the lineage the executor seam re-attaches with. */
+  readonly resume?: WorkerResumeContext;
 }
 type MakeWorkerAgent = (profile: AgentProfile$1, context?: WorkerSpawnContext) => Agent<unknown, unknown>;
 interface CoordinationToolsOptions {
@@ -2640,8 +2692,11 @@ interface CoordinationToolsOptions {
    *  {@link AnalyzeOnSettleRoute} generalizes the DESTINATION: findings can be delivered to a
    *  named live WORKER (wrapped in the route's directive, through the same authorized steer
    *  machinery a driver steer uses) instead of being hardwired to the spawning driver, and `over`
-   *  restricts which settled workers feed the lens. Omit/empty = no auto-analysis (default; the
-   *  driver can still run lenses on demand via `run_analyst`). Requires `analysts`. */
+   *  restricts which settled workers feed the lens. A route carrying `agent` generalizes the
+   *  ANALYST itself: a tool-equipped agent spawned as a worker whose settle output is the
+   *  findings (see {@link AnalyzeOnSettleRoute.agent}). Omit/empty = no auto-analysis (default;
+   *  the driver can still run lenses on demand via `run_analyst`). Lens routes require
+   *  `analysts`; agent routes do not. */
   readonly analyzeOnSettle?: ReadonlyArray<string | AnalyzeOnSettleRoute>;
   /** Hard cap on how many workers may be LIVE (spawned but not yet settled) at once. `spawn_agent`
    *  counts the scope's non-terminal nodes and fails closed (`error: 'max-live-workers'`) BEFORE
@@ -2686,6 +2741,17 @@ interface CoordinationToolsOptions {
    * Omit/empty = fresh ledger (every run that is not a resume).
    */
   readonly priorQuestions?: ReadonlyArray<QuestionRecord>;
+  /**
+   * Default continuity per PROFILE NAME (the stable node identity a graph pins). A name mapping
+   * to `'resume'` makes its spawns re-attach to the node's most recent settled worker whenever
+   * one exists — the node's FIRST spawn is effectively `'fresh'`, and a spawn while a prior
+   * worker of the node is still LIVE fails closed (`resume-while-live`; steer is the live-worker
+   * channel). The spawn tool's per-call `continuity` argument overrides the declared default in
+   * either direction. Omit = every spawn is `'fresh'` (status quo). Resume lineage is
+   * PROCESS-LOCAL (the same boundary as the analyst-run marker): workers settled by a prior
+   * process of a durable run are not resume targets.
+   */
+  readonly continuityByProfile?: Readonly<Record<string, ContinuityMode>>;
 }
 /** Online-detector wiring for spawned workers (`CoordinationToolsOptions.watchWorkers`). */
 interface WorkerWatchOptions {
@@ -3255,7 +3321,7 @@ interface LeaderboardSpec<TCase, TArtifact = string> {
    *  print (+ write) the ranked leaderboard markdown under the export dir. */
   export?: (result: RunProfileMatrixResult<TArtifact, LeaderboardScenario<TCase>>, ctx: LeaderboardRunContext) => Promise<void> | void;
   /** LEVEL 2 — full dispatch replacement (in-process products bring their own).
-   *  The default is `loopDispatch` + the naive steering directive over the resolved backend. */
+   *  The default is `loopDispatch` + the naive retry driver over the resolved backend. */
   dispatch?: ProfileDispatchFn<LeaderboardScenario<TCase>, TArtifact>;
   /** LEVEL 2 — full judge replacement. Default: `score` wrapped as one judge. */
   judges?: JudgeConfig<TArtifact, LeaderboardScenario<TCase>>[];
@@ -4307,23 +4373,6 @@ interface RunAgentRoundsOptions<Task, Output, Decision> {
  * @experimental
  */
 declare function runAgentRounds<Task, Output, Decision>(options: RunAgentRoundsOptions<Task, Output, Decision>): Promise<LoopResult<Task, Output, Decision>>;
-/**
- * Pre-rename name for {@link runAgentRounds}; identical function, kept so existing
- * call sites keep working.
- *
- * @deprecated Use {@link runAgentRounds}. The clearer name says what it is: the
- * multi-agent fanout/vote/refine kernel over sandboxes, NOT the one-turn tool loop
- * (`runToolLoop` / `streamToolLoop`, `/tool-loop`). `runLoop` shipped on `/kernel`
- * next to `routerToolLoop`, which made the two read as variants of one thing. The alias
- * is removed in the next major.
- */
-declare const runLoop: typeof runAgentRounds;
-/**
- * Pre-rename name for {@link RunAgentRoundsOptions}.
- *
- * @deprecated Use {@link RunAgentRoundsOptions}. Removed in the next major.
- */
-type RunLoopOptions<Task, Output, Decision> = RunAgentRoundsOptions<Task, Output, Decision>;
 /**
  * The kernel's winner argmax — best-valid-score, ties broken by earliest index,
  * falling back to the best-scoring non-errored output when none is valid. Exported
@@ -5590,121 +5639,6 @@ interface LocalMcpMaterialization {
  */
 declare function materializeLocalMcp(profile: AgentProfile$1, opts?: MaterializeLocalMcpOptions): Promise<LocalMcpMaterialization>;
 //#endregion
-//#region src/runtime/steering-drivers.d.ts
-/**
- * Terminal-or-continue decision shared by all three steering drivers. The
- * non-terminal `'refine'` keeps the loop running another shot; the terminal
- * `'pick-winner'`/`'fail'` stop it (`isTerminalDecision` in run-loop.ts treats
- * `'pick-winner'` and `'fail'` as terminal and any other string as a request
- * for another round). Identical to the reference refine driver's decision set.
- */
-type SteeringDecision = 'refine' | 'pick-winner' | 'fail';
-/**
- * A steering POLICY as plain data — the delegates-edge directive form of the two control
- * drivers. `kind` names how much of the verdict the policy may read (the experimental axis);
- * the continuation strings are the payload. Because this is JSON-able data, it is versionable
- * in a prompt registry and attachable to a graph edge — the same policy that used to exist
- * only as a builder FUNCTION, which made it invisible to any optimizer. Default texts are
- * seeded in the kernel prompt registry (`delegates/naive-continuation`,
- * `delegates/dumb-continuation-pass` / `-fail`); a caller may carry its own.
- */
-type SteeringDirectiveData = {
-  /** Reads NOTHING from the verdict: one fixed continuation every round. */
-  readonly kind: 'naive';
-  readonly continuation: string;
-  /** Hard traversal cap: the loop stops refining once history reaches this length. */
-  readonly maxTraversals: number;
-} | {
-  /** Reads ONLY `verdict.valid` (the boolean): one of two fixed continuations. */
-  readonly kind: 'dumb';
-  readonly onPass: string;
-  readonly onFail: string;
-  readonly maxTraversals: number;
-};
-/**
- * Interpret a {@link SteeringDirectiveData} as a loop `Driver` — the ONE interpreter both
- * control policies share. The directive is data; only `applyContinuation` (how the caller's
- * opaque Task carries a steering string) remains code, exactly as `taskToPrompt` does.
- */
-declare function steeringDriver<Task, Output>(directive: SteeringDirectiveData, applyContinuation: ApplyContinuation<Task>, name?: string): Driver<Task, Output, SteeringDecision>;
-/**
- * Fold a steering string into the caller's Task shape, producing the Task for
- * the next shot. The substrate never assumes how a Task carries its prompt, so
- * the caller supplies this — the same way it supplies `taskToPrompt`. The
- * original `task` is passed so the fold can preserve task-level fields (ids,
- * fixtures, feature names) and replace only the instruction.
- */
-type ApplyContinuation<Task> = (task: Task, continuation: string) => Task;
-/** Options for {@link naiveDriver}. */
-interface NaiveDriverOptions<Task> {
-  /**
-   * The fixed continuation issued every round after shot 0. The same string is
-   * sent whether the prior shot passed inspection or not — the naive driver
-   * reads no part of the verdict. Domain text is the caller's; the substrate
-   * supplies none.
-   */
-  continuation: string;
-  /** Folds `continuation` into the caller's Task shape for the next shot. */
-  applyContinuation: ApplyContinuation<Task>;
-  /** Hard shot cap. The loop stops refining once history reaches this length. */
-  maxIterations: number;
-  /** Trace-event identifier. Default `'naive'`. */
-  name?: string;
-}
-/**
- * `naiveDriver` — the no-signal steering control.
- *
- * `plan()` runs the initial `task` at shot 0, then issues the SAME fixed
- * `continuation` every subsequent round until a shot is valid or the cap is
- * hit. It reads NOTHING from `history[last].verdict` — not `.valid`, not
- * `.notes`, not `.scores`. It is the floor a coached loop must beat to earn its
- * coaching: any lift over naive that is not also present in `dumb` is
- * attributable to the pass/fail bit, and any lift of `refine` over `dumb` is
- * attributable to the grader's findings.
- */
-/** Thin compatibility wrapper over {@link steeringDriver} for the naive (no-signal) control.
- *  @deprecated The policy is DATA now — build the directive and interpret it:
- *  `steeringDriver({ kind: 'naive', continuation, maxTraversals }, applyContinuation)`. This
- *  wrapper survives for existing callers and will be removed in the next major. */
-declare function naiveDriver<Task, Output>(options: NaiveDriverOptions<Task>): Driver<Task, Output, SteeringDecision>;
-/** Options for {@link dumbDriver}. */
-interface DumbDriverOptions<Task> {
-  /**
-   * Continuation issued when the prior shot's verdict is valid. In a
-   * stop-on-pass loop this is rarely reached (a valid shot ends the loop), but
-   * it is required so the driver is total over the pass/fail bit; pass a
-   * confirmation/keep-going string.
-   */
-  onPass: string;
-  /** Continuation issued when the prior shot's verdict is NOT valid. */
-  onFail: string;
-  /** Folds the chosen continuation into the caller's Task shape. */
-  applyContinuation: ApplyContinuation<Task>;
-  /** Hard shot cap. The loop stops refining once history reaches this length. */
-  maxIterations: number;
-  /** Trace-event identifier. Default `'dumb'`. */
-  name?: string;
-}
-/**
- * `dumbDriver` — the pass/fail-only steering control.
- *
- * `plan()` runs the initial `task` at shot 0, then reads ONLY
- * `history[last].verdict.valid` (the boolean) and issues `onPass` or `onFail`
- * accordingly. It MUST NOT read `.notes` or `.scores` — that boundary is the
- * leak-free firewall. A `verdict` with no `valid` set (or no verdict) is
- * treated as not-valid, so the driver is total and never throws on a
- * grader/transport gap.
- *
- * The `dumb → refine` gap is the headline measurement: refine reads the
- * grader's `notes`, dumb reads only the pass/fail bit, so the difference is
- * exactly the value the findings add over a bare boolean.
- */
-/** Thin compatibility wrapper over {@link steeringDriver} for the dumb (pass/fail-only) control.
- *  @deprecated The policy is DATA now — build the directive and interpret it:
- *  `steeringDriver({ kind: 'dumb', onPass, onFail, maxTraversals }, applyContinuation)`. This
- *  wrapper survives for existing callers and will be removed in the next major. */
-declare function dumbDriver<Task, Output>(options: DumbDriverOptions<Task>): Driver<Task, Output, SteeringDecision>;
-//#endregion
 //#region src/runtime/strategy-author.d.ts
 /** The compressed consumable a skill carries: everything an author needs to emit a loop. */
 declare const strategyAuthorContract = "\nYou author an OPTIMIZATION STRATEGY for an agentic loop system. A strategy decides how to\nspend a compute budget to beat a task's deployable check. You compose exactly two steps:\n\n  shot(spec?: { handle?, messages?, steer?, persona?, tools? }): Promise<ShotResult | null>\n    Runs ONE worker attempt (a bounded tool loop) over an artifact.\n    - omit handle  => the shot opens its OWN fresh artifact and closes it after (a sample).\n    - pass handle  => the shot CONTINUES that artifact (state accumulates across shots).\n    - messages     => the carried conversation (pass the previous ShotResult.messages to continue).\n    - steer        => a corrective instruction injected before the shot.\n    - persona      => { systemPrompt?, model? } — give THIS shot its own role and/or model\n      (multi-agent strategies: a researcher shot then an engineer shot, a panel of k\n      personas over one budget). On a fresh shot the systemPrompt replaces the task's; on\n      a carried conversation it arrives as a hand-off message. Same conserved budget.\n    - tools        => string[] — restrict THIS shot to a subset of the task's tools by\n      name (focus an explore shot on read-only tools, an execute shot on write tools).\n      Restriction-only; unknown names make the shot fail. ALWAYS select from\n      await listTools(handle) — never hardcode. Omitted => the shot sees every tool.\n    ShotResult = { messages, score (0..1 on the task's check), passes, total, completions, toolErrors }\n    Returns null if the attempt failed infra-wise.\n\n  critique(messages): Promise<string | null>\n    A firewalled trace-analyst reads the attempt's trajectory and returns ONE corrective\n    instruction (or null when it judges the work complete). Costs ~1 completion.\n\n  consult(messages, instruction): Promise<string | null>\n    The RAW analyst channel: the same firewalled critic answers YOUR instruction over the\n    trajectory verbatim (no reformatting) — use it when you need a specific reply format\n    (a decision, a prediction). Costs ~1 completion.\n\n  surface.open(task) / surface.close(handle)\n    Open a persistent artifact you manage yourself (remember to close in a finally).\n    close is idempotent — closing an already-closed handle is a safe no-op.\n\n  listTools(handle): Promise<Array<{ name, description? }>>\n    The tools THIS task actually offers. TOOL SETS VARY PER TASK — if you restrict a\n    shot with `tools`, you MUST pick names from await listTools(handle); hardcoding\n    names from an example kills your shots on every task whose tools differ.\n\nRules:\n- ALWAYS await every shot/critique/surface call — a floating promise that rejects\n  crashes the whole benchmark run.\n- Stay within ~budget total shots; every shot/critique spends from a conserved pool.\n- For a FRESH attempt OMIT `messages` entirely (never pass `[]` — an empty array is a\n  fresh conversation too, but be explicit). To CONTINUE, pass the previous\n  ShotResult.messages unchanged.\n- Return { score, resolved, completions, progression, shots } — score = the BEST checkpoint\n  you reached (keep-best, never final-state), progression = score after each shot.\n- The module must be EXACTLY this shape (no other imports, no commentary outside code):\n\nimport { defineStrategy } from '@tangle-network/agent-runtime/kernel'\nexport default defineStrategy('your-strategy-name', async ({ surface, task, budget, shot, critique, listTools }) => {\n  // your composition (listTools comes from the destructured context — it is NOT a global)\n})\n";
@@ -6457,6 +6391,126 @@ declare function spendFromUsageEvents(events: UsageEvent[]): Spend;
  */
 declare function createBudgetPool(root: Budget, now?: () => number, restore?: BudgetPoolRestore): BudgetPool;
 //#endregion
+//#region src/runtime/supervise/chat-transport-executor.d.ts
+/** One buffered chat-completions call: the OpenAI-shape request body in, the parsed completion
+ *  JSON out. The ONE wire function of this module — the executor's default transport is built
+ *  from it, and a harness that must prove two arms share a substrate (P1 parity) drives BOTH
+ *  through the same instance. */
+type ChatCompletionsTransport = (body: Record<string, unknown>, signal?: AbortSignal) => Promise<unknown>;
+/** The default transport: POST `${url}/chat/completions` with an optional bearer. Fail-loud on
+ *  any non-2xx — the status and body head become the settle reason. */
+declare function chatCompletionsTransport(opts: {
+  url: string;
+  bearer?: string;
+}): ChatCompletionsTransport;
+/** Conversation history keyed by the settled worker id — the resume substrate. The kernel owns
+ *  identity, ordering, ledger truth, and spend continuity; this store owns only the message
+ *  lists a `'resume'` spawn continues (`WorkerSpawnContext.resume.ofWorker` is the load key).
+ *  PROCESS-LOCAL by the same boundary the kernel documents for resume itself: a prior process's
+ *  workers are not resume targets. */
+interface ChatSessionStore {
+  load(workerId: string): ReadonlyArray<Record<string, unknown>> | undefined;
+  save(workerId: string, messages: ReadonlyArray<Record<string, unknown>>): void;
+}
+/** In-memory `ChatSessionStore`. Entries are detached copies — a caller mutating a saved array
+ *  cannot corrupt a recorded session. */
+declare function createChatSessionStore(): ChatSessionStore;
+/** One entry of the caller-provided tool table: the OpenAI function spec the model sees, and the
+ *  host-side implementation run when the model calls it. */
+interface ChatTransportTool {
+  readonly spec: ToolSpec;
+  /** Runs ON THIS HOST; the returned string folds back as the `tool` message. A throw is fed
+   *  back as an error message for the model to correct — a bad tool call is a real outcome, not
+   *  an infra fault. */
+  readonly execute: (args: Record<string, unknown>, task: unknown) => Promise<string>;
+}
+interface ChatTransportExecutorOptions {
+  /** OpenAI-compatible base URL (with or without `/v1`); the executor POSTs to
+   *  `${url}/chat/completions`. Ignored when `complete` is injected. */
+  url: string;
+  /** Bearer token for the default transport. Omit for an unauthenticated endpoint. */
+  bearer?: string;
+  /** The wire model id sent on every completion. */
+  model: string;
+  /** System prompt seeding a FRESH conversation. A resumed conversation keeps the system message
+   *  it was recorded with — a session continues; it is not re-primed. */
+  system?: string;
+  /** Tool table. Omitted = a pure conversation (no `tools` field on the wire). */
+  tools?: ReadonlyArray<ChatTransportTool>;
+  temperature?: number;
+  /** Output-token ceiling for ONE completion, sent as `max_tokens` on every request when set.
+   *  Omitted = no field on the wire, so the endpoint's own default governs. A harness pairing
+   *  this executor against another sampling path (P1 parity) pins BOTH arms to one value. */
+  maxTokens?: number;
+  /** Inference-turn cap for ONE shot (one `execute`). Default 200 — a runaway backstop, not a
+   *  workflow limit (mirrors `routerToolsInlineExecutor.maxTurns`). */
+  maxTurnsPerShot?: number;
+  /** Injected buffered transport — the offline seam (mirrors `RouterConfig.complete`). When set,
+   *  `url`/`bearer` are unused and NO network is touched. */
+  complete?: ChatCompletionsTransport;
+  /** Session store backing continuity. Required to record this conversation (with `sessionKey`)
+   *  or to continue a prior one (with `resume`). */
+  sessions?: ChatSessionStore;
+  /** The id this worker's conversation is recorded under at settle — the kernel node id when
+   *  spawned through a scope, so a later `'resume'` spawn's `resume.ofWorker` finds it. */
+  sessionKey?: string;
+  /** The resume lineage from `WorkerSpawnContext.resume`: this shot continues `ofWorker`'s
+   *  recorded message list. Requires `sessions` holding that conversation — fails loud before
+   *  any spend when it does not. */
+  resume?: WorkerResumeContext;
+  /** Profile this executor materializes, for the kernel's materialization receipt. Omitted =
+   *  the node's receipt reads `executor-did-not-report` (a direct, unsupervised use). */
+  profile?: AgentProfile$1;
+  /** Kernel-minted attempt id (`ExecutorNodeContext.attemptId`) binding the receipt to this
+   *  exact spawn. */
+  attemptId?: string;
+}
+/**
+ * Build the chat-transport `Executor`: one `execute` = one conversation SHOT — seed (fresh system
+ * prompt, or the resumed session's recorded history) + the task as the next user message, then
+ * loop completion → host tool calls → tool messages until the model answers without a tool call
+ * (or the turn cap). Settles with the final assistant text as `out`.
+ *
+ * Fail-loud contract: transport failures (non-2xx, network faults, malformed completions) throw
+ * `ValidationError`, which the scope settles as an INFRA failure (`Settled.down.infra`) — never a
+ * fake success. The accumulated conversation is still recorded before the throw when a store is
+ * configured, because the inference HAPPENED and a resume may continue a failed session (the
+ * kernel deliberately allows resume-after-failure; the seam decides).
+ */
+declare function chatTransportExecutor(opts: ChatTransportExecutorOptions): Executor<string>;
+interface ChatWorkerSeamOptions {
+  /** OpenAI-compatible base URL every spawned worker speaks. Unused when `complete` is set. */
+  url: string;
+  bearer?: string;
+  /** Fallback wire model when a spawned profile carries none (`profile.model.default` wins). */
+  model?: string;
+  tools?: ReadonlyArray<ChatTransportTool>;
+  temperature?: number;
+  /** Per-completion `max_tokens` for every spawned worker (see
+   *  {@link ChatTransportExecutorOptions.maxTokens}). */
+  maxTokens?: number;
+  maxTurnsPerShot?: number;
+  /** Injected buffered transport — the offline seam; no network is touched when set. */
+  complete?: ChatCompletionsTransport;
+  /** Session store backing continuity. Default: one fresh in-memory store PER SEAM, matching the
+   *  kernel's process-local resume boundary (one seam = one run's sessions). */
+  sessions?: ChatSessionStore;
+  /** The completion oracle: each worker settles `valid` ⟺ this check passes on its final
+   *  assistant text (`gateOnDeliverable` — settled ⟺ DELIVERED, exactly how `workerFromBackend`
+   *  composes it). Pass the graph's deliverable so a keep-best driver can pick a winner; omitted,
+   *  workers settle unverdicted and only a driver `submit_result` can win. */
+  deliverable?: DeliverableSpec<unknown>;
+}
+/**
+ * The `makeWorkerAgent` seam over {@link chatTransportExecutor} — the continuity consumer
+ * `workerFromBackend` refuses to be. Every spawn becomes one conversation shot: the spawned
+ * profile's system prompt + instructions (which is where a graph's delegates directive lands)
+ * seed a fresh session, and a `'resume'` spawn re-attaches by loading `resume.ofWorker`'s
+ * recorded message list from the seam's session store. Conversations are recorded under the
+ * kernel node id, which is exactly what a later `resume.ofWorker` names.
+ */
+declare function chatWorkerSeam(opts: ChatWorkerSeamOptions): MakeWorkerAgent;
+//#endregion
 //#region src/runtime/supervise/coordination-log.d.ts
 /** Stable identity of the supervisor that owns one coordination stream. High-level supervision
  * derives it from the exact root/child execution identity plus its parent assignment. */
@@ -6750,6 +6804,11 @@ interface DriverAgentOptions {
   /** Idle time after which `observe_agent` reports a worker as stalled (a derived read; nothing is
    *  killed). Omit = the runtime default. */
   readonly stallAfterMs?: number;
+  /** Default continuity per worker PROFILE NAME — `'resume'` makes spawns of that name re-attach
+   *  to the node's latest settled worker (see
+   *  `CoordinationToolsOptions.continuityByProfile`); `spawn_agent`'s per-call `continuity`
+   *  argument overrides. Omit = every spawn fresh (status quo). */
+  readonly continuityByProfile?: Readonly<Record<string, ContinuityMode>>;
   /** The driver's stance — a string, or built from the task (the worker-driver prompt /
    *  the generator). INJECTED so the prompt is a pluggable, optimizable role. */
   readonly systemPrompt: string | ((task: unknown) => string);
@@ -6896,6 +6955,9 @@ declare function serveCoordinationMcp(opts: {
   watchWorkers?: WorkerWatchOptions;
   /** Idle time after which `observe_agent` reports a worker as stalled. */
   stallAfterMs?: number;
+  /** Default continuity per worker profile name — `'resume'` re-attaches spawns of that name to
+   *  the node's latest settled worker; the tool's per-call `continuity` overrides. */
+  continuityByProfile?: Readonly<Record<string, ContinuityMode>>;
   /** Pass-through subscriber for every bus event, including pre-delivery instruction receipts and
    * steer/answer delivery outcomes. */
   onEvent?: (event: CoordinationEvent, record: BusRecord<CoordinationEvent>) => void | Promise<void>;
@@ -7416,6 +7478,10 @@ interface SupervisorAgentDeps {
   readonly watchWorkers?: WorkerWatchOptions;
   /** Idle time after which `observe_agent` reports a worker as stalled. Omit = runtime default. */
   readonly stallAfterMs?: number;
+  /** Default continuity per worker PROFILE NAME (both arms) — `'resume'` re-attaches spawns of
+   *  that name to the node's latest settled worker; `spawn_agent`'s per-call `continuity`
+   *  overrides. Omit = every spawn fresh (status quo). */
+  readonly continuityByProfile?: Readonly<Record<string, ContinuityMode>>;
   /** PROGRESS-derived stop rule (router arm). Ends a run that has stopped learning BEFORE it
    *  exhausts a ceiling; it can never keep a run alive past one. Build it with `plateau` /
    *  `noProgressFor` / `allWorkersStalled` from `supervise/stop-rules` — the thresholds are the
@@ -7624,6 +7690,14 @@ interface SuperviseOptions {
   /** Idle time after which `observe_agent` reports a running worker as `stalled`. A derived read
    *  at observation time — nothing is killed or retried. Omit = the runtime default. */
   readonly stallAfterMs?: number;
+  /** Default continuity per worker PROFILE NAME: `'resume'` makes each spawn of that name after
+   *  the first re-attach to the node's most recent SETTLED worker — a NEW live worker whose spawn
+   *  context carries the prior worker's identity (`WorkerSpawnContext.resume`), which the executor
+   *  seam re-attaches with. `spawn_agent`'s per-call `continuity` argument overrides in either
+   *  direction; `runGraph` derives this from delegates-edge `continuity`. Omit = every spawn is
+   *  `'fresh'` (status quo). See `CoordinationToolsOptions.continuityByProfile` for the
+   *  refusal semantics (no-prior / while-live / with-key) and the process-local resume boundary. */
+  readonly continuityByProfile?: Readonly<Record<string, ContinuityMode>>;
   /** Worker output store. Defaults to in-memory. */
   readonly blobs?: ResultBlobStore;
   /**
@@ -7755,13 +7829,27 @@ type GraphEdge =
   /** Cyclic-graph backstop: traversals beyond this REFUSE (fail loud). Default
    *  {@link defaultEdgeTraversalCap}. */
   readonly maxTraversals?: number;
+  /** Default continuity for this edge's SPAWN traversals. `'resume'` makes every spawn after
+   *  the node's first re-attach to its most recent SETTLED worker: a NEW live worker whose
+   *  spawn context carries `resume: { ofWorker, sequence }` for the executor seam, spending
+   *  from the same conserved pool — the node's first spawn is effectively `'fresh'`, and a
+   *  spawn while a prior worker is still live refuses loudly (steer is the live channel).
+   *  The driver's per-call `spawn_agent` `continuity` argument overrides either way. Omit =
+   *  `'fresh'` (today's behavior, byte-identical). Caps count resumes exactly like fresh
+   *  spawns. */
+  readonly continuity?: ContinuityMode;
 } |
-/** Findings flow anywhere: an analyst LENS (environment, never a node) over N nodes' settled
- *  traces, delivered to ONE node wrapped in a directive telling the recipient what to do with
- *  the analysis. */
+/** Findings flow anywhere: an analyst over N nodes' settled traces, delivered to ONE node.
+ *  With a LENS analyst the directive wraps the findings for the recipient; with a NODE analyst
+ *  the directive is the analyst agent's task and the findings are its settle output. */
 {
   readonly kind: 'analyzes';
-  /** The analyst lens id, resolved against `RunGraphOptions.analysts`. NOT a node id. */
+  /** The analyst REFERENCE, in one of two forms: a lens id resolved against
+   *  `RunGraphOptions.analysts` (environment), or the id of a graph NODE with no delegates
+   *  edge pointing at it — then each matching settle spawns that node's pinned profile as a
+   *  tool-equipped analyst WORKER (same spawn machinery, conserved budget, trace join) whose
+   *  task is this edge's directive plus the settled worker's trace evidence and whose settle
+   *  output is the findings. An id that is both a node and a registry lens is refused. */
   readonly analyst: string;
   readonly over: ReadonlyArray<NodeId>;
   readonly to: NodeId;
@@ -7779,6 +7867,11 @@ interface AgentGraph {
   readonly budget: Budget;
 }
 type EdgeDeliveryOutcome = 'delivered' | 'stripped' | 'empty' | 'unpropagated';
+/** How one ledgered hop CONTINUED: a spawn traversal stamps its effective spawn mode
+ *  (`'fresh'` | `'resume'`), and every mid-run delivery into an already-live recipient — a
+ *  driver steer leg and every analyzes delivery (routed steer or driver-destined finding) —
+ *  stamps `'steer'`. Zero ambiguity: every row carries exactly one of the three. */
+type TraversalContinuity = ContinuityMode | 'steer';
 /** One recorded edge traversal — the in-memory row; the journal twin is the `edge` SpawnEvent. */
 interface EdgeTraversal {
   /** Stable edge id: `delegates:<from>-><to>` or `analyzes:<analyst>:<over…>-><to>`. */
@@ -7791,6 +7884,8 @@ interface EdgeTraversal {
   /** 1-based per-edge ordinal. */
   readonly traversal: number;
   readonly outcome: EdgeDeliveryOutcome;
+  /** How this hop continued — see {@link TraversalContinuity}. */
+  readonly continuity: TraversalContinuity;
   /** Bytes of directive + payload that actually crossed the edge. */
   readonly bytes: number;
   readonly reason?: string;
@@ -7821,8 +7916,15 @@ interface RunGraphOptions {
   readonly hooks?: RuntimeHooks;
   /** Inject the driver brain directly (offline tests / advanced). */
   readonly brain?: ToolLoopChat;
-  /** The analyst lens registry `analyzes` edges resolve against. ENVIRONMENT, not nodes. */
+  /** The analyst lens registry `analyzes` edges resolve against. ENVIRONMENT — needed only for
+   *  lens analysts; an analyzes edge naming a graph NODE as its analyst needs no registry. */
   readonly analysts?: AnalystRegistry;
+  /** Watch every worker's LIVE tool trace with the online detector panel and raise a `finding`
+   *  on the bus the moment one loops or error-storms — forwarded to `supervise()` verbatim (see
+   *  `SuperviseOptions.watchWorkers`). Online findings (`analyst: 'online:<detector>'`) are bus
+   *  events for the driver, not graph edges, so they are never ledgered as traversals. Omit =
+   *  off (no online watching, no extra events). */
+  readonly watchWorkers?: WorkerWatchOptions;
   /** Directive registry. Default: the seeded kernel registry (`kernelPromptRegistry()`). */
   readonly registry?: PromptRegistry;
   /** The run journal the edge ledger and every spawn/settle ride. Default: in-memory. */
@@ -8557,5 +8659,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 { legacySupervisorRunsRoot as $, printBenchmarkReport as $a, WaterfallReport as $c, createDelegationTraceCollector as $d, defineProfileMaterializationContract as $f, SandboxLineageHandle as $i, createExecutor as $l, DeliveredOutput as $n, harvestCorpus as $o, structuralRollout as $r, RunPersonified as $s, assertCoordinationBinding as $t, createDetachedTurnResumeDriver as $u, GitWorkspaceOptions as A, loopUntil as Aa, PairwiseVerdict as Ac, DelegationHistoryEntry as Ad, InMemorySpawnJournal as Af, SteeringDirectiveData as Ai, McpServer as Al, defaultDelegateBudget as An, loopDispatch as Ao, CheckExecChannel as Ar, RenderCorpusToInstructionsOptions as As, runGraph as At, CoderDelegate as Au, analyzeTrace as B, createScopeAnalyst as Ba, AuditIntentOptions as Bc, ResearchOutputShape as Bd, replaySpawnTree as Bf, connectStdioMcp as Bi, DelegateResult as Bl, ProgressSample as Bn, envKeyProvider as Bo, StructuralRolloutResult as Br, VerifySpec as Bs, CoordinationBinding as Bt, settleDetachedCoderTurn as Bu, closingWorkerNote as C, definePersona as Ca, AxisScoresOf as Cc, DelegateUiAuditArgs as Cd, defaultToolDetectors as Cf, assertStrategyContract as Ci, QuestionUrgency as Cl, DispatchUnit as Cn, runAgentic as Co, asAuthoredProfile as Cr, Panel as Cs, EdgeTraversal as Ct, JsonRpcResponse as Cu, UntrackedCopyStats as D, renderCorpusToInstructions as Da, LeaderboardOptions as Dc, DelegationError as Dd, FileResultBlobStore as Df, DumbDriverOptions as Di, canonicalFindingEvent as Dl, queueOf as Dn, LoopDispatchOptions as Do, defaultProfileRichnessThresholds as Dr, Pipeline as Ds, GraphResult as Dt, FeedbackStore as Du, CopyOptions as E, InMemoryCorpus as Ea, Leaderboard as Ec, DelegateUiAuditRoute as Ed, gateOnDeliverable as Ef, ApplyContinuation as Ei, WorkerWatchOptions as El, freeSlots as En, LoopCampaignDispatchOptions as Eo, canonicalizeAuthoredProfile as Er, PanelVerdict as Es, GraphNode as Et, FeedbackEvent as Eu, gitWorkspace as F, widen as Fa, renderLeaderboardHtml as Fc, DelegationStatus as Fd, SpawnForestNode as Ff, MaterializeLocalMcpOptions as Fi, DELEGATE_INPUT_SCHEMA as Fl, driverAgent as Fn, runLoop as Fo, CheckSourceCtx as Fr, TrajectoryNode as Fs, SuperviseOptions as Ft, DetachedWinnerSelection as Fu, workerTraceAnalysisStore as G, sanitizeMcpToolSchema as Ga, AnytimeStrategySummary as Gc, DELEGATION_TRACE_MAX_BYTES as Gd, CanonicalAgentProfileMaterializationAxis as Gf, OpenSandboxRunPromptOptions as Gi, CliWorktreeBridgeSeam as Gl, StopRule as Gn, inlineSandboxClient as Go, defaultExtractCandidate as Gr, WinnerStrategy as Gs, ResolveSupervisorTools as Gt, createFleetWorkspaceExecutor as Gu, WorkerToolTraceArtifact as H, McpEndpoint as Ha, auditIntent as Hc, UiAuditLensFilter as Hd, AGENT_PROFILE_MATERIALIZATION_AXES as Hf, Deliverable as Hi, validateDelegateArgs as Hl, ProgressTrackerOptions as Hn, resolveMcpServerLaunch as Ho, canDisplace as Hr, WidenDecision as Hs, DriveHarnessOwnerContext as Ht, FleetHandle as Hu, jjWorkspace as I, CreateScopeAnalystOptions as Ia, renderLeaderboardMarkdown as Ic, DelegationStatusArgs as Id, SpawnForestTree as If, McpSpawnFault as Ii, DELEGATE_TOOL_NAME as Il, finalizeBestDelivered as In, LocalSandboxClientOptions as Io, RepairStop as Ir, TrajectoryReport as Is, SuperviseRegistry as It, SettleDetachedCoderTurnOptions as Iu, ScopeArgs as J, BenchmarkLift as Ja, areaUnderCurve as Jc, DelegationTraceCollector as Jd, ProfileMaterializationContract as Jf, TurnResult as Ji, ProviderSeam as Jl, anyOf as Jn, InProcessSandboxClientOptions as Jo, modelAuthoredChecks as Jr, LoopShape as Js, SupervisorNodeContext as Jt, DetachedTurn as Ju, createRootHandle as K, BenchmarkCell as Ka, AnytimeTaskCurve as Kc, DELEGATION_TRACE_MAX_SPANS as Kd, DefineProfileMaterializationContractOptions as Kf, SandboxRun as Ki, CliWorktreeSeam as Kl, allOf as Kn, InProcessOnPrompt as Ko, defaultStructuralRolloutPolicy as Kr, DefinePersona as Ks, ResolvedSupervisorProfile as Kt, createSiblingSandboxExecutor as Ku, localShell as L, RegistryAnalyzeProjection as La, renderLeaderboardSvg as Lc, DelegationStatusResult as Ld, loadSpawnForest as Lf, McpToolDescriptor as Li, DelegateArgs as Ll, AllWorkersStalledOptions as Ln, localSandboxClient as Lo, StructuralRolloutConfig as Lr, TrajectoryReportFn as Ls, SuperviseRegistryTable as Lt, UiAuditorDelegate as Lu, Workspace as M, pipeline as Ma, ScoreOf as Mc, DelegationProfile as Md, SpawnForestEvent as Mf, naiveDriver as Mi, createInProcessTransport as Ml, CoordinationMcpHandle as Mn, RunLoopOptions as Mo, CheckRunContext as Mr, ScopeAnalyzeInput as Ms, AuthorizedSpawnContext as Mt, CoderReviewer as Mu, WorkspaceCommit as N, selectValidWinner as Na, leaderboard as Nc, DelegationProgress as Nd, SpawnForestInDoubtNode as Nf, steeringDriver as Ni, createMcpServer as Nl, serveCoordinationMcp as Nn, defaultSelectWinner as No, CheckRunner as Nr, ScopeWidenGate as Ns, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as Nt, DelegateRunCtx as Nu, copyUntrackedIntoClone as O, fanout as Oa, LeaderboardRow as Oc, DelegationFeedbackSnapshot as Od, FileSpawnJournal as Of, NaiveDriverOptions as Oi, createCoordinationTools as Ol, rollingDispatch as On, LoopOptionsForDispatch as Oo, profileRichnessFinding as Or, PipelineStage as Os, RunGraphOptions as Ot, InMemoryFeedbackStore as Ou, WorkspaceRun as P, verify as Pa, pairwiseSignificance as Pc, DelegationResultPayload as Pd, SpawnForestMissingTree as Pf, LocalMcpMaterialization as Pi, DELEGATE_DESCRIPTION as Pl, DriverAgentOptions as Pn, runAgentRounds as Po, CheckSource as Pr, SteerContext as Ps, DeliverableResolutionInput as Pt, DetachedSessionDelegateOptions as Pu, legacySupervisorRunDir as Q, Environment as Qa, WaterfallCollector as Qc, composeLoopTraceEmitters as Qd, controlProfileMaterialization as Qf, SandboxLineage as Qi, cliWorktreeExecutor as Ql, sampleFromSettled as Qn, HarvestReport as Qo, selectBestIndex as Qr, PersonaExecutors as Qs, SupervisorToolInvocationContext as Qt, RunDetachedTurnOptions as Qu, runInWorkspace as R, assertTraceDerivedFindings as Ra, renderPairwiseMarkdown as Rc, FeedbackRating as Rd, materializeTreeView as Rf, StdioMcpConnection as Ri, DelegateError as Rl, NoProgressForOptions as Rn, KeyProvider as Ro, StructuralRolloutMessage as Rr, TrajectoryReportOptions as Rs, supervise as Rt, coderTaskFromArgs as Ru, WorkerEvidenceInput as S, registerShape as Sa, stopSentinel as Sc, DelegateResearchResult as Sd, WatchTraceOptions as Sf, AuthoredStrategy as Si, QuestionRecord as Sl, DispatchStopReason as Sn, refine as So, ProfileRichnessThresholds as Sr, LoopUntilState as Ss, EdgeDeliveryOutcome as St, JsonRpcMessage as Su, settledWorkerOut as T, FileCorpus as Ta, Interval as Tc, DelegateUiAuditResult as Td, DeliverableSpec as Tf, strategyAuthorContract as Ti, WorkerSpawnContext as Tl, effectiveConcurrency as Tn, sampleThenRefine as To, authoredWorker as Tr, PanelSpec as Ts, GraphEdgeCapError as Tt, McpTransport as Tu, captureWorkerTraceEvidence as U, McpEnvironmentOptions as Ua, defaultAuditorInstruction as Uc, UiAuditorDelegationOutput as Ud, AgentProfileMaterializationAxis as Uf, OpenSandboxRunBeforeStartContext as Ui, BridgeSeam as Ul, ProgressView as Un, resolveSecretEnv as Uo, compareCheckOutcomes as Ur, WidenLineage as Us, ObserveSupervisorNodeEvent as Ut, FleetWorkspaceExecutorOptions as Uu, WORKER_TOOL_TRACE_SCHEMA_VERSION as V, registryScopeAnalyst as Va, IntentAudit as Vc, ResearchSource as Vd, contentAddress as Vf, materializeLocalMcp as Vi, createDelegateHandler as Vl, ProgressTracker as Vn, mcpSecretEnvMetadataKey as Vo, VisibleCheck as Vr, Widen as Vs, DriveHarness as Vt, DelegationExecutor as Vu, parseWorkerToolTraceArtifact as W, createMcpEnvironment as Wa, AnytimeReport as Wc, CappedDelegationTrace as Wd, AssertProfileMaterializationOptions as Wf, OpenSandboxRunOptions as Wi, CliSeam as Wl, StopDecision as Wn, secretEnvOfMcpServer as Wo, composeCheckSources as Wr, WidenSpec as Ws, ResolveDriveHarness as Wt, SiblingSandboxExecutorOptions as Wu, settledToIteration as X, BenchmarkStrategySummary as Xa, plateauLength as Xc, buildDelegationTraceSpans as Xd, ValidateProfileMaterializationOptions as Xf, CheckpointCapableBox as Xi, RouterToolsSeam as Xl, noProgressFor as Xn, HarvestCorpusOptions as Xo, resolveEntrySymbol as Xr, Persona as Xs, SupervisorProfile as Xt, DriveTurnCapableBox as Xu, createScope as Y, BenchmarkReport as Ya, bestSoFar as Yc, DelegationTraceSpan as Yd, ProfileMaterializationIssue as Yf, openSandboxRun as Yi, RouterSeam as Yl, createProgressTracker as Yn, inProcessSandboxClient as Yo, officialChecksFromMeta as Yr, Outcome as Ys, SupervisorNodeContextSeed as Yt, DetachedTurnResumeDriverOptions as Yu, WorkerSteerRequest as Z, BenchmarkTaskRow as Za, renderAnytimeTable as Zc, capDelegationTrace as Zd, assertProfileMaterialization as Zf, ForkCapableBox as Zi, SandboxSeam as Zl, plateau as Zn, HarvestFailure as Zo, sandboxCheckRunner as Zr, PersonaContext as Zs, SupervisorToolDescriptor as Zt, DriveTurnTick as Zu, WorktreeFanoutOptions as _, promotionGate as _a, CompletionPolicy as _c, DelegateCodeResult as _d, BusRecord as _f, discriminatingMeans as _i, Question as _l, naiveContinuationPrompt as _n, SurfaceScore as _o, ReservationTicket as _r, FanoutSynthesis as _s, WorktreePatchArtifact as _t, RemoveWorktreeOptions as _u, SandboxInstance$1 as a, mapSandboxEvent as aa, LeaderboardBenchScore as ac, DelegationRecord as ad, InMemoryDelegationStore as af, collectAgentTurn as ai, AuthorizeDownMessage as al, SupervisorSpanRecorder as an, AgenticTool as ao, promptResourceProfileMaterialization as ap, pickBestDelivered as ar, renderReport as as, workerControlLogFile as at, createSteerableSandboxSession as au, NOTE_MAX_CHARS as b, builtinShapes as ba, deterministicCompletion as bc, DelegateResearchArgs as bd, PublishOptions as bf, selectChampion as bi, QuestionOption as bl, ConcurrencyCaps as bn, defineStrategy as bo, AuthoredProfile as br, LoopUntil as bs, assertProfileModelsAllowed as bt, createWorktree as bu, VerifierEnvironmentOptions as c, CriuCapableClient as ca, LeaderboardFlagSpec as cc, DelegationResumeTick as cd, BackendTransportError as cf, ChampionPolicy as ci, CoordinationEvent as cl, PromptRegistry as cn, RunAgenticOptions as co, validateProfileMaterialization as cp, CoordinationDeliveryEvidence as cr, Corpus as cs, writeWorkerSteer as ct, createInbox as cu, SuperviseSurfaceResult as d, AcquireOptions as da, LeaderboardScenario as dc, DelegationTaskQueueOptions as dd, NotFoundError as df, EvolutionBandInfo as di, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as dl, createPromptRegistry as dn, Strategy as do, FileCoordinationLog as dr, EqualKArm as ds, RunContext as dt, WorktreeHarnessResult as du, SessionCapableBox as ea, RunPersonifiedOptions as ec, detachedTurnEvents as ed, DelegationPersistenceError as ef, visibleCheckScore as ei, WaterfallSpan as el, resolveSupervisorProfile as en, runBenchmark as eo, fullProfileMaterialization as ep, FinalizeContext as er, Observation as es, readWorkerSteerRequests as et, createExecutorRegistry as eu, SurfaceWorkerConfig as f, acquireSandbox as fa, LeaderboardScore as fc, SubmitInput as fd, PlannerError as ff, EvolutionCandidate as fi, DownMessageAuthorizationInput as fl, delegatesWorkerBriefPrompt as fn, StrategyArtifacts as fo, PriorCoordination as fr, EqualKOnCost as fs, createFileRunContext as ft, WorktreeProfileMaterializationReceipt as fu, AuthoredHarness as g, PromotionVerdict as ga, CompletionEvidence as gc, DelegateCodeConfig as gd, BusEvent as gf, StrategyEvolutionConfig as gi, MakeWorkerAgent as gl, kernelPromptRegistry as gn, StrategyShotResult as go, ReservationRejection as gr, FanoutOptions as gs, WorktreeCliExecutorOptions as gt, GitRunner as gu, superviseSurface as h, PromotionGateOptions as ha, CompletionAnalyst as hc, DelegateCodeArgs as hd, CoderOutput as hf, ReproductionCheck as hi, DownMessageEvent as hl, formatPromptHandle as hn, StrategyResult as ho, BudgetReadout as hr, Fanout as hs, patchDelivered as ht, DiffResult as hu, SandboxEvent$1 as i, extractLlmCallEvent as ia, DefinedLeaderboard as ic, DelegationArgs as id, FileDelegationStoreOptions as if, StreamAgentTurnOptions as ii, AnalyzeOnSettleRoute as il, SupervisorSpanOutcome as in, AgenticTask as io, promptOnlyProfileMaterialization as ip, collectDelivered as ir, observe as is, supervisorWorkersDir as it, SteerableSandboxSession as iu, Shell as j, panel as ja, ProfileKeyOf as jc, DelegationHistoryResult as jd, SpawnForest as jf, dumbDriver as ji, McpServerOptions as jl, delegate as jn, RunAgentRoundsOptions as jo, CheckOutcome as jr, ScopeAnalyst as js, AuthorizedSpawn as jt, CoderReview as ju, withUntrackedArtifacts as k, flatWidenGate as ka, PairwiseOptions as kc, DelegationHistoryArgs as kd, InMemoryResultBlobStore as kf, SteeringDecision as ki, normalizeAnalyzeOnSettle as kl, DelegateOptions as kn, loopCampaignDispatch as ko, supervisorInstructions as kr, RenderCorpusToInstructions as ks, defaultEdgeTraversalCap as kt, eventToSnapshot as ku, createVerifierEnvironment as l, SandboxCapabilities as la, LeaderboardIterationInfo as lc, DelegationRunContext as ld, ConfigError as lf, EvolutionArchiveNode as li, CoordinationTools as ll, RegisteredPrompt as ln, ShotPersona as lo, worktreeCliProfileMaterialization as lp, CoordinationLog as lr, CorpusFilter as ls, InMemoryRunContext as lt, WorktreeCheckRunner as lu, failuresAnalyst as m, resolveSandboxClient as ma, defineLeaderboard as mc, hashIdempotencyInput as md, ValidationError as mf, EvolutionReport as mi, DownMessageDeliveryOutcome as ml, dumbContinuationPassPrompt as mn, StrategyMessage as mo, BudgetPoolRestore as mr, EqualKVerdict as ms, PatchDeliverableOptions as mt, DiffOptions as mu, AnalystFinding$1 as n, SandboxToolPartState as na, ShapeContext as nc, parseDetachedSessionRef as nd, DelegationStore as nf, AgentTurnUsage as ni, AnalystFindingEvent as nl, SupervisorSpanAttributes as nn, AgenticRunResult as no, promptControlProfileMaterialization as np, SupervisorFinalizer as nr, ObserveOptions as ns, supervisorRunDir as nt, SandboxSteeringOptions as nu, computeFindingId$1 as o, mapSandboxToolEvent as oa, LeaderboardBenchTask as oc, DelegationResumeContext as od, AgentEvalError$1 as of, streamAgentTurn as oi, AuthorizedDownMessage as ol, createSupervisorSpanRecorder as on, ArtifactHandle as oo, renderProfileMaterializationIssues as op, runFinalizer as or, AssertTraceDerivedFindings as os, workerInboxFile as ot, Inbox as ou, SurfaceWorkerOut as p, ResolveSandboxClientOptions as pa, LeaderboardSpec as pc, SubmitOutput as pd, RuntimeRunStateError as pf, EvolutionGeneration as pi, DownMessageDeliveryAttempt as pl, dumbContinuationFailPrompt as pn, StrategyCtx as po, BudgetPool as pr, EqualKOnCostOptions as ps, createInMemoryRunContext as pt, CreateWorktreeOptions as pu, createSupervisor as q, BenchmarkConfig as qa, anytimeReport as qc, DelegationTraceCaps as qd, KnownAgentProfileMaterializationAxis as qf, SandboxRunAbortError as qi, ExecutorConfig as ql, allWorkersStalled as qn, InProcessPromptCtx as qo, filterAuthoredAsserts as qr, DefinePersonaInput as qs, SupervisorAgentDeps as qt, DetachedSessionRefParts as qu, CreateSandboxOptions$1 as r, createSandboxToolPartState as ra, ShapeRegistry as rc, runDetachedTurn as rd, FileDelegationStore as rf, CollectedAgentTurn as ri, AnalystRegistry as rl, SupervisorSpanOptions as rn, AgenticSurface as ro, promptModelProfileMaterialization as rp, bestDelivered as rr, defaultAnalystInstruction as rs, supervisorRunsRoot as rt, SteerableSandboxArgs as ru, makeFinding$1 as s, sumSandboxUsage as sa, LeaderboardBenchmarkAdapter as sc, DelegationResumeDriver as sd, AgentEvalErrorCode as sf, ChampionPick as si, ContinuationInstruction as sl, PromptHandle as sn, CorpusReadbackOptions as so, sandboxActProfileMaterialization as sp, runTree as sr, CombinatorShape as ss, workerInboxFileFromEventDir as st, InboxMessage as su, AgentProfile$2 as t, createSandboxLineage as ta, ShapeBudget as tc, formatDetachedSessionRef as td, DelegationStateCorruptError as tf, AgentTurnBackend as ti, createWaterfallCollector as tl, supervisorAgent as tn, AgenticOptions as to, profileMaterializationAxes as tp, FinalizerSettled as tr, ObserveInput as ts, safeWorkerFile as tt, DEFAULT_SANDBOX_STEERING_MAX_TURNS as tu, SuperviseSurfaceOptions as u, probeSandboxCapabilities as ua, LeaderboardRunContext as uc, DelegationTaskQueue as ud, JudgeError as uf, EvolutionAuthor as ui, CoordinationToolsOptions as ul, analyzesFindingsReportPrompt as un, ShotSpec as uo, CoordinationOwnerId as ur, CorpusRecord as us, InMemoryRunContextOptions as ut, WorktreeCommandResult as uu, worktreeFanout as v, equalKOnCost as va, CompletionVerdict as vc, DelegateFeedbackArgs as vd, BusStats as vf, pickChampion as vi, QuestionDecision as vl, promptHandle as vn, adaptiveRefine as vo, createBudgetPool as vr, FanoutWinnerSelector as vs, createWorktreeCliExecutor as vt, WorktreeHandle as vu, composeWorkerEvidence as w, runPersonified as wa, GroupOf as wc, DelegateUiAuditConfig as wd, watchTrace as wf, authorStrategy as wi, SettledWorker as wl, RollingDispatchOptions as wn, sample as wo, assessAuthoredProfile as wr, PanelJudge as ws, GraphEdge as wt, McpToolDescriptor$1 as wu, VERIFY_TAIL_CHARS as x, createShapeRegistry as xa, sentinelCompletion as xc, DelegateResearchConfig as xd, createEventBus as xf, AuthorStrategyOptions as xi, QuestionPolicy as xl, DispatchReport as xn, depthStrategy as xo, ProfileRichness as xr, LoopUntilSpec as xs, AgentGraph as xt, removeWorktree as xu, EVIDENCE_MAX_CHARS as y, trajectoryReport as ya, completionAuthorizes as yc, DelegateFeedbackResult as yd, EventBus as yf, runStrategyEvolution as yi, QuestionLevel as yl, supervisorPolicyPrompt as yn, breadthStrategy as yo, spendFromUsageEvents as yr, FlatWidenGate as ys, assertModelAllowed as yt, captureWorktreeDiff as yu, TrajectoryAnalysis as z, buildSteerContext as za, AuditIntentInput as zc, FeedbackRefersTo as zd, pendingWaits as zf, StdioMcpServerSpec as zi, DelegateHandlerOptions as zl, PlateauOptions as zn, ResolvedMcpServerLaunch as zo, StructuralRolloutPolicy as zr, Verify as zs, workerFromBackend as zt, detachedSessionDelegate as zu };
-//# sourceMappingURL=index-xP27vtnt.d.ts.map
+export { legacySupervisorRunsRoot as $, BenchmarkTaskRow as $a, WaterfallReport as $c, capDelegationTrace as $d, assertProfileMaterialization as $f, ForkCapableBox as $i, SandboxSeam as $l, sampleFromSettled as $n, harvestCorpus as $o, compareCheckOutcomes as $r, RunPersonified as $s, SupervisorToolInvocationContext as $t, DriveTurnTick as $u, GitWorkspaceOptions as A, fanout as Aa, PairwiseVerdict as Ac, DelegationFeedbackSnapshot as Ad, FileSpawnJournal as Af, selectChampion as Ai, createCoordinationTools as Al, DelegateOptions as An, LoopOptionsForDispatch as Ao, AuthoredProfile as Ar, RenderCorpusToInstructionsOptions as As, defaultEdgeTraversalCap as At, InMemoryFeedbackStore as Au, analyzeTrace as B, assertTraceDerivedFindings as Ba, AuditIntentOptions as Bc, FeedbackRating as Bd, materializeTreeView as Bf, StdioMcpConnection as Bi, DelegateError as Bl, PlateauOptions as Bn, envKeyProvider as Bo, CheckExecChannel as Br, VerifySpec as Bs, workerFromBackend as Bt, coderTaskFromArgs as Bu, closingWorkerNote as C, createShapeRegistry as Ca, AxisScoresOf as Cc, DelegateResearchConfig as Cd, createEventBus as Cf, EvolutionGeneration as Ci, QuestionRecord as Cl, DispatchStopReason as Cn, depthStrategy as Co, BudgetPool as Cr, Panel as Cs, EdgeTraversal as Ct, removeWorktree as Cu, UntrackedCopyStats as D, FileCorpus as Da, LeaderboardOptions as Dc, DelegateUiAuditResult as Dd, DeliverableSpec as Df, discriminatingMeans as Di, WorkerSpawnContext as Dl, freeSlots as Dn, sampleThenRefine as Do, ReservationTicket as Dr, Pipeline as Ds, GraphResult as Dt, McpTransport as Du, CopyOptions as E, runPersonified as Ea, Leaderboard as Ec, DelegateUiAuditConfig as Ed, watchTrace as Ef, StrategyEvolutionConfig as Ei, WorkerResumeContext as El, effectiveConcurrency as En, sample as Eo, ReservationRejection as Er, PanelVerdict as Es, GraphNode as Et, McpToolDescriptor$1 as Eu, gitWorkspace as F, selectValidWinner as Fa, renderLeaderboardHtml as Fc, DelegationProgress as Fd, SpawnForestInDoubtNode as Ff, strategyAuthorContract as Fi, createMcpServer as Fl, DriverAgentOptions as Fn, runAgentRounds as Fo, authoredWorker as Fr, TrajectoryNode as Fs, DeliverableResolutionInput as Ft, DelegateRunCtx as Fu, workerTraceAnalysisStore as G, McpEnvironmentOptions as Ga, AnytimeStrategySummary as Gc, UiAuditorDelegationOutput as Gd, AgentProfileMaterializationAxis as Gf, OpenSandboxRunBeforeStartContext as Gi, BridgeSeam as Gl, StopDecision as Gn, inlineSandboxClient as Go, CheckSourceCtx as Gr, WinnerStrategy as Gs, ResolveDriveHarness as Gt, FleetWorkspaceExecutorOptions as Gu, WorkerToolTraceArtifact as H, createScopeAnalyst as Ha, auditIntent as Hc, ResearchOutputShape as Hd, replaySpawnTree as Hf, connectStdioMcp as Hi, DelegateResult as Hl, ProgressTracker as Hn, resolveMcpServerLaunch as Ho, CheckRunContext as Hr, WidenDecision as Hs, DriveHarness as Ht, settleDetachedCoderTurn as Hu, jjWorkspace as I, verify as Ia, renderLeaderboardMarkdown as Ic, DelegationResultPayload as Id, SpawnForestMissingTree as If, LocalMcpMaterialization as Ii, DELEGATE_DESCRIPTION as Il, driverAgent as In, LocalSandboxClientOptions as Io, canonicalizeAuthoredProfile as Ir, TrajectoryReport as Is, SuperviseOptions as It, DetachedSessionDelegateOptions as Iu, ScopeArgs as J, BenchmarkCell as Ja, areaUnderCurve as Jc, DELEGATION_TRACE_MAX_SPANS as Jd, DefineProfileMaterializationContractOptions as Jf, SandboxRun as Ji, CliWorktreeSeam as Jl, allWorkersStalled as Jn, InProcessSandboxClientOptions as Jo, StructuralRolloutMessage as Jr, LoopShape as Js, SupervisorAgentDeps as Jt, createSiblingSandboxExecutor as Ju, createRootHandle as K, createMcpEnvironment as Ka, AnytimeTaskCurve as Kc, CappedDelegationTrace as Kd, AssertProfileMaterializationOptions as Kf, OpenSandboxRunOptions as Ki, CliSeam as Kl, StopRule as Kn, InProcessOnPrompt as Ko, RepairStop as Kr, DefinePersona as Ks, ResolveSupervisorTools as Kt, SiblingSandboxExecutorOptions as Ku, localShell as L, widen as La, renderLeaderboardSvg as Lc, DelegationStatus as Ld, SpawnForestNode as Lf, MaterializeLocalMcpOptions as Li, DELEGATE_INPUT_SCHEMA as Ll, finalizeBestDelivered as Ln, localSandboxClient as Lo, defaultProfileRichnessThresholds as Lr, TrajectoryReportFn as Ls, SuperviseRegistry as Lt, DetachedWinnerSelection as Lu, Workspace as M, loopUntil as Ma, ScoreOf as Mc, DelegationHistoryEntry as Md, InMemorySpawnJournal as Mf, AuthoredStrategy as Mi, McpServer as Ml, delegate as Mn, loopDispatch as Mo, ProfileRichnessThresholds as Mr, ScopeAnalyzeInput as Ms, AuthorizedSpawn as Mt, CoderDelegate as Mu, WorkspaceCommit as N, panel as Na, leaderboard as Nc, DelegationHistoryResult as Nd, SpawnForest as Nf, assertStrategyContract as Ni, McpServerOptions as Nl, CoordinationMcpHandle as Nn, RunAgentRoundsOptions as No, asAuthoredProfile as Nr, ScopeWidenGate as Ns, AuthorizedSpawnContext as Nt, CoderReview as Nu, copyUntrackedIntoClone as O, InMemoryCorpus as Oa, LeaderboardRow as Oc, DelegateUiAuditRoute as Od, gateOnDeliverable as Of, pickChampion as Oi, WorkerWatchOptions as Ol, queueOf as On, LoopCampaignDispatchOptions as Oo, createBudgetPool as Or, PipelineStage as Os, RunGraphOptions as Ot, FeedbackEvent as Ou, WorkspaceRun as P, pipeline as Pa, pairwiseSignificance as Pc, DelegationProfile as Pd, SpawnForestEvent as Pf, authorStrategy as Pi, createInProcessTransport as Pl, serveCoordinationMcp as Pn, defaultSelectWinner as Po, assessAuthoredProfile as Pr, SteerContext as Ps, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as Pt, CoderReviewer as Pu, legacySupervisorRunDir as Q, BenchmarkStrategySummary as Qa, WaterfallCollector as Qc, buildDelegationTraceSpans as Qd, ValidateProfileMaterializationOptions as Qf, CheckpointCapableBox as Qi, RouterToolsSeam as Ql, plateau as Qn, HarvestReport as Qo, canDisplace as Qr, PersonaExecutors as Qs, SupervisorToolDescriptor as Qt, DriveTurnCapableBox as Qu, runInWorkspace as R, CreateScopeAnalystOptions as Ra, renderPairwiseMarkdown as Rc, DelegationStatusArgs as Rd, SpawnForestTree as Rf, McpSpawnFault as Ri, DELEGATE_TOOL_NAME as Rl, AllWorkersStalledOptions as Rn, KeyProvider as Ro, profileRichnessFinding as Rr, TrajectoryReportOptions as Rs, SuperviseRegistryTable as Rt, SettleDetachedCoderTurnOptions as Ru, WorkerEvidenceInput as S, builtinShapes as Sa, stopSentinel as Sc, DelegateResearchArgs as Sd, PublishOptions as Sf, EvolutionCandidate as Si, QuestionPolicy as Sl, DispatchReport as Sn, defineStrategy as So, createChatSessionStore as Sr, LoopUntilState as Ss, EdgeDeliveryOutcome as St, createWorktree as Su, settledWorkerOut as T, definePersona as Ta, Interval as Tc, DelegateUiAuditArgs as Td, defaultToolDetectors as Tf, ReproductionCheck as Ti, SettledWorker as Tl, RollingDispatchOptions as Tn, runAgentic as To, BudgetReadout as Tr, PanelSpec as Ts, GraphEdgeCapError as Tt, JsonRpcResponse as Tu, captureWorkerTraceEvidence as U, registryScopeAnalyst as Ua, defaultAuditorInstruction as Uc, ResearchSource as Ud, contentAddress as Uf, materializeLocalMcp as Ui, createDelegateHandler as Ul, ProgressTrackerOptions as Un, resolveSecretEnv as Uo, CheckRunner as Ur, WidenLineage as Us, DriveHarnessOwnerContext as Ut, DelegationExecutor as Uu, WORKER_TOOL_TRACE_SCHEMA_VERSION as V, buildSteerContext as Va, IntentAudit as Vc, FeedbackRefersTo as Vd, pendingWaits as Vf, StdioMcpServerSpec as Vi, DelegateHandlerOptions as Vl, ProgressSample as Vn, mcpSecretEnvMetadataKey as Vo, CheckOutcome as Vr, Widen as Vs, CoordinationBinding as Vt, detachedSessionDelegate as Vu, parseWorkerToolTraceArtifact as W, McpEndpoint as Wa, AnytimeReport as Wc, UiAuditLensFilter as Wd, AGENT_PROFILE_MATERIALIZATION_AXES as Wf, Deliverable as Wi, validateDelegateArgs as Wl, ProgressView as Wn, secretEnvOfMcpServer as Wo, CheckSource as Wr, WidenSpec as Ws, ObserveSupervisorNodeEvent as Wt, FleetHandle as Wu, settledToIteration as X, BenchmarkLift as Xa, plateauLength as Xc, DelegationTraceCollector as Xd, ProfileMaterializationContract as Xf, TurnResult as Xi, ProviderSeam as Xl, createProgressTracker as Xn, HarvestCorpusOptions as Xo, StructuralRolloutResult as Xr, Persona as Xs, SupervisorNodeContextSeed as Xt, DetachedTurn as Xu, createScope as Y, BenchmarkConfig as Ya, bestSoFar as Yc, DelegationTraceCaps as Yd, KnownAgentProfileMaterializationAxis as Yf, SandboxRunAbortError as Yi, ExecutorConfig as Yl, anyOf as Yn, inProcessSandboxClient as Yo, StructuralRolloutPolicy as Yr, Outcome as Ys, SupervisorNodeContext as Yt, DetachedSessionRefParts as Yu, WorkerSteerRequest as Z, BenchmarkReport as Za, renderAnytimeTable as Zc, DelegationTraceSpan as Zd, ProfileMaterializationIssue as Zf, openSandboxRun as Zi, RouterSeam as Zl, noProgressFor as Zn, HarvestFailure as Zo, VisibleCheck as Zr, PersonaContext as Zs, SupervisorProfile as Zt, DetachedTurnResumeDriverOptions as Zu, WorktreeFanoutOptions as _, PromotionGateOptions as _a, CompletionPolicy as _c, DelegateCodeArgs as _d, CoderOutput as _f, ChampionPick as _i, MakeWorkerAgent as _l, kernelPromptRegistry as _n, StrategyResult as _o, ChatTransportTool as _r, FanoutSynthesis as _s, WorktreePatchArtifact as _t, DiffResult as _u, SandboxInstance$1 as a, createSandboxToolPartState as aa, LeaderboardBenchScore as ac, runDetachedTurn as ad, FileDelegationStore as af, officialChecksFromMeta as ai, AuthorizeDownMessage as al, SupervisorSpanOutcome as an, AgenticSurface as ao, promptModelProfileMaterialization as ap, collectDelivered as ar, renderReport as as, workerControlLogFile as at, SteerableSandboxArgs as au, NOTE_MAX_CHARS as b, equalKOnCost as ba, deterministicCompletion as bc, DelegateFeedbackArgs as bd, BusStats as bf, EvolutionAuthor as bi, QuestionLevel as bl, supervisorPolicyPrompt as bn, adaptiveRefine as bo, chatTransportExecutor as br, LoopUntil as bs, assertProfileModelsAllowed as bt, WorktreeHandle as bu, VerifierEnvironmentOptions as c, mapSandboxToolEvent as ca, LeaderboardFlagSpec as cc, DelegationResumeContext as cd, AgentEvalError$1 as cf, selectBestIndex as ci, ContinuityMode as cl, PromptHandle as cn, ArtifactHandle as co, renderProfileMaterializationIssues as cp, runTree as cr, Corpus as cs, writeWorkerSteer as ct, Inbox as cu, SuperviseSurfaceResult as d, SandboxCapabilities as da, LeaderboardScenario as dc, DelegationRunContext as dd, ConfigError as df, AgentTurnBackend as di, CoordinationToolsOptions as dl, analyzesFindingsReportPrompt as dn, ShotPersona as do, worktreeCliProfileMaterialization as dp, CoordinationOwnerId as dr, EqualKArm as ds, RunContext as dt, WorktreeCheckRunner as du, SandboxLineage as ea, RunPersonifiedOptions as ec, RunDetachedTurnOptions as ed, composeLoopTraceEmitters as ef, composeCheckSources as ei, WaterfallSpan as el, assertCoordinationBinding as en, Environment as eo, controlProfileMaterialization as ep, DeliveredOutput as er, Observation as es, readWorkerSteerRequests as et, cliWorktreeExecutor as eu, SurfaceWorkerConfig as f, probeSandboxCapabilities as fa, LeaderboardScore as fc, DelegationTaskQueue as fd, JudgeError as ff, AgentTurnUsage as fi, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as fl, createPromptRegistry as fn, ShotSpec as fo, FileCoordinationLog as fr, EqualKOnCost as fs, createFileRunContext as ft, WorktreeCommandResult as fu, AuthoredHarness as g, resolveSandboxClient as ga, CompletionEvidence as gc, hashIdempotencyInput as gd, ValidationError as gf, streamAgentTurn as gi, DownMessageEvent as gl, formatPromptHandle as gn, StrategyMessage as go, ChatTransportExecutorOptions as gr, FanoutOptions as gs, WorktreeCliExecutorOptions as gt, DiffOptions as gu, superviseSurface as h, ResolveSandboxClientOptions as ha, CompletionAnalyst as hc, SubmitOutput as hd, RuntimeRunStateError as hf, collectAgentTurn as hi, DownMessageDeliveryOutcome as hl, dumbContinuationPassPrompt as hn, StrategyCtx as ho, ChatSessionStore as hr, Fanout as hs, patchDelivered as ht, CreateWorktreeOptions as hu, SandboxEvent$1 as i, SandboxToolPartState as ia, DefinedLeaderboard as ic, parseDetachedSessionRef as id, DelegationStore as if, modelAuthoredChecks as ii, AnalyzeOnSettleRoute as il, SupervisorSpanOptions as in, AgenticRunResult as io, promptControlProfileMaterialization as ip, bestDelivered as ir, observe as is, supervisorWorkersDir as it, SandboxSteeringOptions as iu, Shell as j, flatWidenGate as ja, ProfileKeyOf as jc, DelegationHistoryArgs as jd, InMemoryResultBlobStore as jf, AuthorStrategyOptions as ji, normalizeAnalyzeOnSettle as jl, defaultDelegateBudget as jn, loopCampaignDispatch as jo, ProfileRichness as jr, ScopeAnalyst as js, runGraph as jt, eventToSnapshot as ju, withUntrackedArtifacts as k, renderCorpusToInstructions as ka, PairwiseOptions as kc, DelegationError as kd, FileResultBlobStore as kf, runStrategyEvolution as ki, canonicalFindingEvent as kl, rollingDispatch as kn, LoopDispatchOptions as ko, spendFromUsageEvents as kr, RenderCorpusToInstructions as ks, TraversalContinuity as kt, FeedbackStore as ku, createVerifierEnvironment as l, sumSandboxUsage as la, LeaderboardIterationInfo as lc, DelegationResumeDriver as ld, AgentEvalErrorCode as lf, structuralRollout as li, CoordinationEvent as ll, PromptRegistry as ln, CorpusReadbackOptions as lo, sandboxActProfileMaterialization as lp, CoordinationDeliveryEvidence as lr, CorpusFilter as ls, InMemoryRunContext as lt, InboxMessage as lu, failuresAnalyst as m, acquireSandbox as ma, defineLeaderboard as mc, SubmitInput as md, PlannerError as mf, StreamAgentTurnOptions as mi, DownMessageDeliveryAttempt as ml, dumbContinuationFailPrompt as mn, StrategyArtifacts as mo, ChatCompletionsTransport as mr, EqualKVerdict as ms, PatchDeliverableOptions as mt, WorktreeProfileMaterializationReceipt as mu, AnalystFinding$1 as n, SessionCapableBox as na, ShapeContext as nc, detachedTurnEvents as nd, DelegationPersistenceError as nf, defaultStructuralRolloutPolicy as ni, AnalystFindingEvent as nl, supervisorAgent as nn, runBenchmark as no, fullProfileMaterialization as np, FinalizerSettled as nr, ObserveOptions as ns, supervisorRunDir as nt, createExecutorRegistry as nu, computeFindingId$1 as o, extractLlmCallEvent as oa, LeaderboardBenchTask as oc, DelegationArgs as od, FileDelegationStoreOptions as of, resolveEntrySymbol as oi, AuthorizedDownMessage as ol, SupervisorSpanRecorder as on, AgenticTask as oo, promptOnlyProfileMaterialization as op, pickBestDelivered as or, AssertTraceDerivedFindings as os, workerInboxFile as ot, SteerableSandboxSession as ou, SurfaceWorkerOut as p, AcquireOptions as pa, LeaderboardSpec as pc, DelegationTaskQueueOptions as pd, NotFoundError as pf, CollectedAgentTurn as pi, DownMessageAuthorizationInput as pl, delegatesWorkerBriefPrompt as pn, Strategy as po, PriorCoordination as pr, EqualKOnCostOptions as ps, createInMemoryRunContext as pt, WorktreeHarnessResult as pu, createSupervisor as q, sanitizeMcpToolSchema as qa, anytimeReport as qc, DELEGATION_TRACE_MAX_BYTES as qd, CanonicalAgentProfileMaterializationAxis as qf, OpenSandboxRunPromptOptions as qi, CliWorktreeBridgeSeam as ql, allOf as qn, InProcessPromptCtx as qo, StructuralRolloutConfig as qr, DefinePersonaInput as qs, ResolvedSupervisorProfile as qt, createFleetWorkspaceExecutor as qu, CreateSandboxOptions$1 as r, createSandboxLineage as ra, ShapeRegistry as rc, formatDetachedSessionRef as rd, DelegationStateCorruptError as rf, filterAuthoredAsserts as ri, AnalystRegistry as rl, SupervisorSpanAttributes as rn, AgenticOptions as ro, profileMaterializationAxes as rp, SupervisorFinalizer as rr, defaultAnalystInstruction as rs, supervisorRunsRoot as rt, DEFAULT_SANDBOX_STEERING_MAX_TURNS as ru, makeFinding$1 as s, mapSandboxEvent as sa, LeaderboardBenchmarkAdapter as sc, DelegationRecord as sd, InMemoryDelegationStore as sf, sandboxCheckRunner as si, ContinuationInstruction as sl, createSupervisorSpanRecorder as sn, AgenticTool as so, promptResourceProfileMaterialization as sp, runFinalizer as sr, CombinatorShape as ss, workerInboxFileFromEventDir as st, createSteerableSandboxSession as su, AgentProfile$2 as t, SandboxLineageHandle as ta, ShapeBudget as tc, createDetachedTurnResumeDriver as td, createDelegationTraceCollector as tf, defaultExtractCandidate as ti, createWaterfallCollector as tl, resolveSupervisorProfile as tn, printBenchmarkReport as to, defineProfileMaterializationContract as tp, FinalizeContext as tr, ObserveInput as ts, safeWorkerFile as tt, createExecutor as tu, SuperviseSurfaceOptions as u, CriuCapableClient as ua, LeaderboardRunContext as uc, DelegationResumeTick as ud, BackendTransportError as uf, visibleCheckScore as ui, CoordinationTools as ul, RegisteredPrompt as un, RunAgenticOptions as uo, validateProfileMaterialization as up, CoordinationLog as ur, CorpusRecord as us, InMemoryRunContextOptions as ut, createInbox as uu, worktreeFanout as v, PromotionVerdict as va, CompletionVerdict as vc, DelegateCodeConfig as vd, BusEvent as vf, ChampionPolicy as vi, Question as vl, naiveContinuationPrompt as vn, StrategyShotResult as vo, ChatWorkerSeamOptions as vr, FanoutWinnerSelector as vs, createWorktreeCliExecutor as vt, GitRunner as vu, composeWorkerEvidence as w, registerShape as wa, GroupOf as wc, DelegateResearchResult as wd, WatchTraceOptions as wf, EvolutionReport as wi, QuestionUrgency as wl, DispatchUnit as wn, refine as wo, BudgetPoolRestore as wr, PanelJudge as ws, GraphEdge as wt, JsonRpcMessage as wu, VERIFY_TAIL_CHARS as x, trajectoryReport as xa, sentinelCompletion as xc, DelegateFeedbackResult as xd, EventBus as xf, EvolutionBandInfo as xi, QuestionOption as xl, ConcurrencyCaps as xn, breadthStrategy as xo, chatWorkerSeam as xr, LoopUntilSpec as xs, AgentGraph as xt, captureWorktreeDiff as xu, EVIDENCE_MAX_CHARS as y, promotionGate as ya, completionAuthorizes as yc, DelegateCodeResult as yd, BusRecord as yf, EvolutionArchiveNode as yi, QuestionDecision as yl, promptHandle as yn, SurfaceScore as yo, chatCompletionsTransport as yr, FlatWidenGate as ys, assertModelAllowed as yt, RemoveWorktreeOptions as yu, TrajectoryAnalysis as z, RegistryAnalyzeProjection as za, AuditIntentInput as zc, DelegationStatusResult as zd, loadSpawnForest as zf, McpToolDescriptor as zi, DelegateArgs as zl, NoProgressForOptions as zn, ResolvedMcpServerLaunch as zo, supervisorInstructions as zr, Verify as zs, supervise as zt, UiAuditorDelegate as zu };
+//# sourceMappingURL=index-BhZhQw77.d.ts.map