@tangle-network/agent-runtime 0.126.0 → 0.128.0

package/README.md

@@ -207,7 +207,7 @@ There is no local fallback.
 Install its optional Python process before using it:
 
 ```bash
-python -m pip install "agent-eval-rpc==0.133.0"
+python -m pip install "agent-eval-rpc==0.143.0"
 python -m pip install "gepa[full]==0.1.4"
 ```
 
@@ -221,7 +221,7 @@ python -m pip install "gepa[full] @ git+https://github.com/gepa-ai/gepa.git@f919
 Use `officialSkillOpt(...)` for Microsoft's SkillOpt:
 
 ```bash
-python -m pip install "agent-eval-rpc==0.133.0"
+python -m pip install "agent-eval-rpc==0.143.0"
 python -m pip install "skillopt @ git+https://github.com/microsoft/SkillOpt.git@61735e3922efc2b90c6d6cab561e62e98452ca90"
 ```
 

package/dist/agent.d.ts

@@ -1,6 +1,6 @@
 import { x as RuntimeStreamEvent } from "./types-C9j4qg6l.js";
 import { a as createSurfaceImprovementProposer, c as SurfaceValidationIssue, d as validateSurfaces, i as SurfaceImprovementEdit, l as renderSurfaceIssues, n as DraftPatchInput, o as AgentSurfaces, r as DraftPatchOutput, s as ResolvedSurface, t as CreateSurfaceImprovementProposerOptions, u as resolveSubjectPath } from "./improvement-adapter-D5gwwoXQ.js";
-import { $f as sandboxActProfileMaterialization, Bf as ProfileMaterializationContract, Ff as AgentProfileMaterializationAxis, Gf as defineProfileMaterializationContract, Hf as ValidateProfileMaterializationOptions, If as AssertProfileMaterializationOptions, Jf as promptControlProfileMaterialization, Kf as fullProfileMaterialization, Lf as CanonicalAgentProfileMaterializationAxis, Pf as AGENT_PROFILE_MATERIALIZATION_AXES, Qf as renderProfileMaterializationIssues, Rf as DefineProfileMaterializationContractOptions, Uf as assertProfileMaterialization, Vf as ProfileMaterializationIssue, Wf as controlProfileMaterialization, Xf as promptOnlyProfileMaterialization, Yf as promptModelProfileMaterialization, Zf as promptResourceProfileMaterialization, ep as validateProfileMaterialization, qf as profileMaterializationAxes, tp as worktreeCliProfileMaterialization, zf as KnownAgentProfileMaterializationAxis } from "./index-EdjCQBV9.js";
+import { $f as assertProfileMaterialization, Gf as AgentProfileMaterializationAxis, Jf as DefineProfileMaterializationContractOptions, Kf as AssertProfileMaterializationOptions, Qf as ValidateProfileMaterializationOptions, Wf as AGENT_PROFILE_MATERIALIZATION_AXES, Xf as ProfileMaterializationContract, Yf as KnownAgentProfileMaterializationAxis, Zf as ProfileMaterializationIssue, ap as promptModelProfileMaterialization, cp as renderProfileMaterializationIssues, dp as worktreeCliProfileMaterialization, ep as controlProfileMaterialization, ip as promptControlProfileMaterialization, lp as sandboxActProfileMaterialization, np as fullProfileMaterialization, op as promptOnlyProfileMaterialization, qf as CanonicalAgentProfileMaterializationAxis, rp as profileMaterializationAxes, sp as promptResourceProfileMaterialization, tp as defineProfileMaterializationContract, up as validateProfileMaterialization } from "./index-BhZhQw77.js";
 import { E as SandboxClient, t as AgentRunSpec, w as OutputAdapter } from "./types-DnNGJ5Gz.js";
 import { TraceAnalystDefinition } from "@tangle-network/agent-eval";
 import { AgentProfile as AgentProfile$1, AgentProfileFileMount, AgentProfileMcpServer } from "@tangle-network/agent-interface";

package/dist/agent.js

@@ -1,7 +1,7 @@
 import { At as controlProfileMaterialization, Bt as validateProfileMaterialization, Ft as promptModelProfileMaterialization, It as promptOnlyProfileMaterialization, Lt as promptResourceProfileMaterialization, Mt as fullProfileMaterialization, Nt as profileMaterializationAxes, Ot as AGENT_PROFILE_MATERIALIZATION_AXES, Pt as promptControlProfileMaterialization, Rt as renderProfileMaterializationIssues, Vt as worktreeCliProfileMaterialization, jt as defineProfileMaterializationContract, kt as assertProfileMaterialization, zt as sandboxActProfileMaterialization } from "./supervisor-DpjO0Gmy.js";
-import "./runtime-BzXz7OjS.js";
+import "./runtime-5uDVVfER.js";
 import { r as mapSandboxEvent } from "./sandbox-events-Yhd1GYWl.js";
-import { At as createSandboxForSpec } from "./supervise-Ds8FtyI9.js";
+import { Mt as createSandboxForSpec } from "./supervise-CsTKbH9R.js";
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";

package/dist/{environment-provider-PM9PeW_J.d.ts → environment-provider-CUFsyymu.d.ts}

@@ -1548,6 +1548,12 @@ type SpawnEvent = {
   /** 1-based traversal ordinal for THIS edge within the run. */
   traversal: number;
   outcome: 'delivered' | 'stripped' | 'empty' | 'unpropagated';
+  /** How the hop CONTINUED the node's work: spawn traversals stamp their effective mode
+   *  (`'fresh'` = new session, `'resume'` = re-attached to the node's prior settled session),
+   *  and every mid-run delivery into an already-live recipient — a driver steer leg and every
+   *  analyzes delivery — stamps `'steer'`. Optional only so journals written before
+   *  continuity stamping remain replayable; every new event carries it. */
+  continuity?: 'fresh' | 'resume' | 'steer';
   /** Bytes of directive + payload that actually crossed the edge (0 for `empty`). */
   bytes: number;
   /** Why a non-`delivered` outcome happened, when the runtime knows. */
@@ -1857,4 +1863,4 @@ interface ProviderExecutorOptions {
 declare function providerAsExecutor(provider: AgentEnvironmentProvider, options?: ProviderExecutorOptions): ExecutorFactory<unknown>;
 //#endregion
 export { MaterializedModelIdentity as $, RuntimeEventOtelOptions as $t, providerAsSandboxClient as A, isWaitOutcome as An, WidenGate as At, DefaultVerdict as B, decodeToolPart as Bn, mergeTraceEnv as Bt, ProviderAsSandboxClientOptions as C, PendingWait as Cn, SupervisedResult as Ct, WorkspaceRequest as D, WaitRejection as Dn, UnknownMaterializationReason as Dt, SandboxClientProviderOptions as E, WaitProbeRegistry as En, TreeView as Et, createTangleSandboxExactProcessProvider as F, SessionMessageLike as Fn, readWorkerTraceContext as Ft, ExecutorExecutionBinding as G, ExecutorProgress as Gn, EvalRunsExportConfig as Gt, Executor as H, ActivityLog as Hn, traceContextToEnv as Ht, Agent as I, SessionTraceBox as In, workerTraceEnv as It, ExecutorNodeContext as J, createActivityLog as Jn, LoopSpanNode as Jt, ExecutorFactory as K, ScopeProgressInput as Kn, EvalRunsExportResult as Kt, AgentExecutionRef as L, ToolStepInput as Ln, workerTraceSeamKey as Lt, sandboxClientAsProvider as M, timerAt as Mn, WorkerTraceUnavailableReason as Mt, CreateTangleSandboxExactProcessProviderOptions as N, validateWaitSpec as Nn, WorkerTraceResolver as Nt, createAgentEnvironmentProviderRegistry as O, WaitSpec as On, UsageEvent as Ot, SandboxControlClient as P, waitUntil as Pn, WorkerTraceSeamCarrier as Pt, MaterializedExecutionIdentity as Q, OtelSpan as Qt, AgentSpec as R, TraceSource as Rn, TraceContext as Rt, PlacementInfo as S, sanitizeRuntimeStreamEvent as Sn, SteerableRootHandle as St, ResourceRequest as T, WaitProbe as Tn, SupervisorOpts as Tt, ExecutorAccounting as U, ActivityNote as Un, EvalRunEvent as Ut, ExecutionBindingReceipt as V, sandboxSessionTraceSource as Vn, readTraceContextFromEnv as Vt, ExecutorContext as W, DEFAULT_STALL_AFTER_MS as Wn, EvalRunGeneration as Wt, ExecutorResult as X, OtelExportConfig as Xt, ExecutorRegistry as Y, readWorkerProgress as Yn, OtelAttribute as Yt, Handle as Z, OtelExporter as Zt, CheckpointRequest as _, SanitizedKnowledgeRequirement as _n, SpawnJournal as _t, AgentEnvironmentProviderRef as a, exportEvalRuns as an, ProfileMaterializationReceipt as at, ExecResult as b, sanitizeAgentRuntimeEvent as bn, SpawnRejection as bt, AgentEnvironmentStatus as c, padSpanId as cn, ResumedKeyState as ct, AgentSession as d, RuntimeEventCollector as dn, RootMaterialization as dt, buildLoopOtelSpans as en, NoWinnerError as et, AgentSessionRef as f, RuntimeStreamEventCollector as fn, RootSignal as ft, CheckpointRef as g, SanitizedKnowledgeReadinessReport as gn, SpawnEvent as gt, AgentTurnResult as h, RuntimeTelemetryOptions as hn, Settled as ht, AgentEnvironmentProvider$1 as i, createOtelExporter as in, NodeStatus as it, resolveAgentEnvironmentProvider as j, pollFor as jn, WorkerTraceEvidence as jt, providerAsExecutor as k, createWaitProbes as kn, WaitOpts as kt, AgentEnvironmentSummary as l, padTraceId as ln, ResumedWork as lt, AgentTurnInput$1 as m, RuntimeStreamEventSummary as mn, Scope as mt, AgentEnvironmentCapabilities$1 as n, buildRuntimeEventOtelSpans as nn, NodeId as nt, AgentEnvironmentProviderRegistry as o, generateSpanId as on, Restart as ot, AgentSessionStatus as p, RuntimeStreamEventSink as pn, Runtime as pt, ExecutorMaterialization as q, WorkerProgress as qn, INTELLIGENCE_WIRE_VERSION as qt, AgentEnvironmentEvent as r, createOpenInferenceFileExporter as rn, NodeSnapshot as rt, AgentEnvironmentQuery as s, loopEventToOtelSpan as sn, ResultBlobStore as st, AgentEnvironment as t, buildLoopSpanNodes as tn, NodeExecutionIdentity as tt, AgentProfileRef$1 as u, toOtelAttributes as un, RootHandle as ut, CreateAgentEnvironmentInput$1 as v, createRuntimeEventCollector as vn, SpawnOpts as vt, ProviderExecutorOptions as w, WaitOutcome as wn, Supervisor as wt, ForkRequest as x, sanitizeKnowledgeReadinessReport as xn, Spend as xt, ExecRequest as y, createRuntimeStreamEventCollector as yn, SpawnPrior as yt, Budget as z, createPushTraceSource as zn, createPropagatingTraceEmitter as zt };
-//# sourceMappingURL=environment-provider-PM9PeW_J.d.ts.map
+//# sourceMappingURL=environment-provider-CUFsyymu.d.ts.map

package/dist/environment-provider.d.ts

@@ -1,2 +1,2 @@
-import { A as providerAsSandboxClient, C as ProviderAsSandboxClientOptions, D as WorkspaceRequest, E as SandboxClientProviderOptions, F as createTangleSandboxExactProcessProvider, M as sandboxClientAsProvider, N as CreateTangleSandboxExactProcessProviderOptions, O as createAgentEnvironmentProviderRegistry, S as PlacementInfo, T as ResourceRequest, _ as CheckpointRequest, a as AgentEnvironmentProviderRef, b as ExecResult, c as AgentEnvironmentStatus, d as AgentSession, f as AgentSessionRef, g as CheckpointRef, h as AgentTurnResult, i as AgentEnvironmentProvider, j as resolveAgentEnvironmentProvider, k as providerAsExecutor, l as AgentEnvironmentSummary, m as AgentTurnInput, n as AgentEnvironmentCapabilities, o as AgentEnvironmentProviderRegistry, p as AgentSessionStatus, r as AgentEnvironmentEvent, s as AgentEnvironmentQuery, t as AgentEnvironment, u as AgentProfileRef, v as CreateAgentEnvironmentInput, w as ProviderExecutorOptions, x as ForkRequest, y as ExecRequest } from "./environment-provider-PM9PeW_J.js";
+import { A as providerAsSandboxClient, C as ProviderAsSandboxClientOptions, D as WorkspaceRequest, E as SandboxClientProviderOptions, F as createTangleSandboxExactProcessProvider, M as sandboxClientAsProvider, N as CreateTangleSandboxExactProcessProviderOptions, O as createAgentEnvironmentProviderRegistry, S as PlacementInfo, T as ResourceRequest, _ as CheckpointRequest, a as AgentEnvironmentProviderRef, b as ExecResult, c as AgentEnvironmentStatus, d as AgentSession, f as AgentSessionRef, g as CheckpointRef, h as AgentTurnResult, i as AgentEnvironmentProvider, j as resolveAgentEnvironmentProvider, k as providerAsExecutor, l as AgentEnvironmentSummary, m as AgentTurnInput, n as AgentEnvironmentCapabilities, o as AgentEnvironmentProviderRegistry, p as AgentSessionStatus, r as AgentEnvironmentEvent, s as AgentEnvironmentQuery, t as AgentEnvironment, u as AgentProfileRef, v as CreateAgentEnvironmentInput, w as ProviderExecutorOptions, x as ForkRequest, y as ExecRequest } from "./environment-provider-CUFsyymu.js";
 export { type AgentEnvironment, type AgentEnvironmentCapabilities, type AgentEnvironmentEvent, type AgentEnvironmentProvider, AgentEnvironmentProviderRef, AgentEnvironmentProviderRegistry, type AgentEnvironmentQuery, type AgentEnvironmentStatus, type AgentEnvironmentSummary, type AgentProfileRef, type AgentSession, type AgentSessionRef, type AgentSessionStatus, type AgentTurnInput, type AgentTurnResult, type CheckpointRef, type CheckpointRequest, type CreateAgentEnvironmentInput, type CreateTangleSandboxExactProcessProviderOptions, type ExecRequest, type ExecResult, type ForkRequest, type PlacementInfo, ProviderAsSandboxClientOptions, ProviderExecutorOptions, type ResourceRequest, SandboxClientProviderOptions, type WorkspaceRequest, createAgentEnvironmentProviderRegistry, createTangleSandboxExactProcessProvider, providerAsExecutor, providerAsSandboxClient, resolveAgentEnvironmentProvider, sandboxClientAsProvider };

package/dist/{index-EdjCQBV9.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. */
@@ -2528,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`.
@@ -2635,6 +2656,13 @@ interface WorkerSpawnContext {
    *  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 {
@@ -2713,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 {
@@ -4334,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
@@ -6369,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. */
@@ -6662,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);
@@ -6808,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>;
@@ -7328,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
@@ -7536,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;
   /**
@@ -7667,6 +7829,15 @@ 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 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
@@ -7696,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>`. */
@@ -7708,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;
@@ -8481,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 $, CorpusReadbackOptions as $a, ContinuationInstruction as $c, AgentEvalErrorCode as $d, sandboxActProfileMaterialization as $f, sumSandboxUsage as $i, InboxMessage as $l, DeliveredOutput as $n, CombinatorShape as $o, structuralRollout as $r, LeaderboardBenchmarkAdapter as $s, assertCoordinationBinding as $t, DelegationResumeDriver as $u, GitWorkspaceOptions as A, assertTraceDerivedFindings as Aa, renderPairwiseMarkdown as Ac, FeedbackRating as Ad, materializeTreeView as Af, StdioMcpConnection as Ai, DelegateError as Al, defaultDelegateBudget as An, KeyProvider as Ao, CheckExecChannel as Ar, TrajectoryReportOptions as As, runGraph as At, coderTaskFromArgs as Au, analyzeTrace as B, BenchmarkLift as Ba, areaUnderCurve as Bc, DelegationTraceCollector as Bd, ProfileMaterializationContract as Bf, TurnResult as Bi, ProviderSeam as Bl, ProgressSample as Bn, InProcessSandboxClientOptions as Bo, StructuralRolloutResult as Br, LoopShape as Bs, CoordinationBinding as Bt, DetachedTurn as Bu, closingWorkerNote as C, panel as Ca, ProfileKeyOf as Cc, DelegationHistoryResult as Cd, SpawnForest as Cf, assertStrategyContract as Ci, McpServerOptions as Cl, DispatchUnit as Cn, RunAgentRoundsOptions as Co, asAuthoredProfile as Cr, ScopeAnalyst as Cs, EdgeTraversal as Ct, CoderReview as Cu, UntrackedCopyStats as D, widen as Da, renderLeaderboardHtml as Dc, DelegationStatus as Dd, SpawnForestNode as Df, MaterializeLocalMcpOptions as Di, DELEGATE_INPUT_SCHEMA as Dl, queueOf as Dn, runLoop as Do, defaultProfileRichnessThresholds as Dr, TrajectoryNode as Ds, GraphResult as Dt, DetachedWinnerSelection as Du, CopyOptions as E, verify as Ea, pairwiseSignificance as Ec, DelegationResultPayload as Ed, SpawnForestMissingTree as Ef, LocalMcpMaterialization as Ei, DELEGATE_DESCRIPTION as El, freeSlots as En, runAgentRounds as Eo, canonicalizeAuthoredProfile as Er, SteerContext as Es, GraphNode as Et, DetachedSessionDelegateOptions as Eu, gitWorkspace as F, McpEnvironmentOptions as Fa, defaultAuditorInstruction as Fc, UiAuditorDelegationOutput as Fd, AgentProfileMaterializationAxis as Ff, OpenSandboxRunBeforeStartContext as Fi, BridgeSeam as Fl, driverAgent as Fn, resolveSecretEnv as Fo, CheckSourceCtx as Fr, WidenLineage as Fs, SuperviseOptions as Ft, FleetWorkspaceExecutorOptions as Fu, workerTraceAnalysisStore as G, printBenchmarkReport as Ga, WaterfallReport as Gc, createDelegationTraceCollector as Gd, defineProfileMaterializationContract as Gf, SandboxLineageHandle as Gi, createExecutor as Gl, StopRule as Gn, harvestCorpus as Go, defaultExtractCandidate as Gr, RunPersonified as Gs, ResolveSupervisorTools as Gt, createDetachedTurnResumeDriver as Gu, WorkerToolTraceArtifact as H, BenchmarkStrategySummary as Ha, plateauLength as Hc, buildDelegationTraceSpans as Hd, ValidateProfileMaterializationOptions as Hf, CheckpointCapableBox as Hi, RouterToolsSeam as Hl, ProgressTrackerOptions as Hn, HarvestCorpusOptions as Ho, canDisplace as Hr, Persona as Hs, DriveHarnessOwnerContext as Ht, DriveTurnCapableBox as Hu, jjWorkspace as I, createMcpEnvironment as Ia, AnytimeReport as Ic, CappedDelegationTrace as Id, AssertProfileMaterializationOptions as If, OpenSandboxRunOptions as Ii, CliSeam as Il, finalizeBestDelivered as In, secretEnvOfMcpServer as Io, RepairStop as Ir, WidenSpec as Is, SuperviseRegistry as It, SiblingSandboxExecutorOptions as Iu, ScopeArgs as J, AgenticRunResult as Ja, AnalystFindingEvent as Jc, DelegationStore as Jd, promptControlProfileMaterialization as Jf, SandboxToolPartState as Ji, SandboxSteeringOptions as Jl, anyOf as Jn, ObserveOptions as Jo, modelAuthoredChecks as Jr, ShapeContext as Js, SupervisorNodeContext as Jt, parseDetachedSessionRef as Ju, createRootHandle as K, runBenchmark as Ka, WaterfallSpan as Kc, DelegationPersistenceError as Kd, fullProfileMaterialization as Kf, SessionCapableBox as Ki, createExecutorRegistry as Kl, allOf as Kn, Observation as Ko, defaultStructuralRolloutPolicy as Kr, RunPersonifiedOptions as Ks, ResolvedSupervisorProfile as Kt, detachedTurnEvents as Ku, localShell as L, sanitizeMcpToolSchema as La, AnytimeStrategySummary as Lc, DELEGATION_TRACE_MAX_BYTES as Ld, CanonicalAgentProfileMaterializationAxis as Lf, OpenSandboxRunPromptOptions as Li, CliWorktreeBridgeSeam as Ll, AllWorkersStalledOptions as Ln, inlineSandboxClient as Lo, StructuralRolloutConfig as Lr, WinnerStrategy as Ls, SuperviseRegistryTable as Lt, createFleetWorkspaceExecutor as Lu, Workspace as M, createScopeAnalyst as Ma, AuditIntentOptions as Mc, ResearchOutputShape as Md, replaySpawnTree as Mf, connectStdioMcp as Mi, DelegateResult as Ml, CoordinationMcpHandle as Mn, envKeyProvider as Mo, CheckRunContext as Mr, VerifySpec as Ms, AuthorizedSpawnContext as Mt, settleDetachedCoderTurn as Mu, WorkspaceCommit as N, registryScopeAnalyst as Na, IntentAudit as Nc, ResearchSource as Nd, contentAddress as Nf, materializeLocalMcp as Ni, createDelegateHandler as Nl, serveCoordinationMcp as Nn, mcpSecretEnvMetadataKey as No, CheckRunner as Nr, Widen as Ns, DEFAULT_AUTHORED_PROFILE_SECURITY_POLICY as Nt, DelegationExecutor as Nu, copyUntrackedIntoClone as O, CreateScopeAnalystOptions as Oa, renderLeaderboardMarkdown as Oc, DelegationStatusArgs as Od, SpawnForestTree as Of, McpSpawnFault as Oi, DELEGATE_TOOL_NAME as Ol, rollingDispatch as On, LocalSandboxClientOptions as Oo, profileRichnessFinding as Or, TrajectoryReport as Os, RunGraphOptions as Ot, SettleDetachedCoderTurnOptions as Ou, WorkspaceRun as P, McpEndpoint as Pa, auditIntent as Pc, UiAuditLensFilter as Pd, AGENT_PROFILE_MATERIALIZATION_AXES as Pf, Deliverable as Pi, validateDelegateArgs as Pl, DriverAgentOptions as Pn, resolveMcpServerLaunch as Po, CheckSource as Pr, WidenDecision as Ps, DeliverableResolutionInput as Pt, FleetHandle as Pu, legacySupervisorRunDir as Q, ArtifactHandle as Qa, AuthorizedDownMessage as Qc, AgentEvalError$1 as Qd, renderProfileMaterializationIssues as Qf, mapSandboxToolEvent as Qi, Inbox as Ql, sampleFromSettled as Qn, AssertTraceDerivedFindings as Qo, selectBestIndex as Qr, LeaderboardBenchTask as Qs, SupervisorToolInvocationContext as Qt, DelegationResumeContext as Qu, runInWorkspace as R, BenchmarkCell as Ra, AnytimeTaskCurve as Rc, DELEGATION_TRACE_MAX_SPANS as Rd, DefineProfileMaterializationContractOptions as Rf, SandboxRun as Ri, CliWorktreeSeam as Rl, NoProgressForOptions as Rn, InProcessOnPrompt as Ro, StructuralRolloutMessage as Rr, DefinePersona as Rs, supervise as Rt, createSiblingSandboxExecutor as Ru, WorkerEvidenceInput as S, loopUntil as Sa, PairwiseVerdict as Sc, DelegationHistoryEntry as Sd, InMemorySpawnJournal as Sf, AuthoredStrategy as Si, McpServer as Sl, DispatchStopReason as Sn, loopDispatch as So, ProfileRichnessThresholds as Sr, RenderCorpusToInstructionsOptions as Ss, EdgeDeliveryOutcome as St, CoderDelegate as Su, settledWorkerOut as T, selectValidWinner as Ta, leaderboard as Tc, DelegationProgress as Td, SpawnForestInDoubtNode as Tf, strategyAuthorContract as Ti, createMcpServer as Tl, effectiveConcurrency as Tn, defaultSelectWinner as To, authoredWorker as Tr, ScopeWidenGate as Ts, GraphEdgeCapError as Tt, DelegateRunCtx as Tu, captureWorkerTraceEvidence as U, BenchmarkTaskRow as Ua, renderAnytimeTable as Uc, capDelegationTrace as Ud, assertProfileMaterialization as Uf, ForkCapableBox as Ui, SandboxSeam as Ul, ProgressView as Un, HarvestFailure as Uo, compareCheckOutcomes as Ur, PersonaContext as Us, ObserveSupervisorNodeEvent as Ut, DriveTurnTick as Uu, WORKER_TOOL_TRACE_SCHEMA_VERSION as V, BenchmarkReport as Va, bestSoFar as Vc, DelegationTraceSpan as Vd, ProfileMaterializationIssue as Vf, openSandboxRun as Vi, RouterSeam as Vl, ProgressTracker as Vn, inProcessSandboxClient as Vo, VisibleCheck as Vr, Outcome as Vs, DriveHarness as Vt, DetachedTurnResumeDriverOptions as Vu, parseWorkerToolTraceArtifact as W, Environment as Wa, WaterfallCollector as Wc, composeLoopTraceEmitters as Wd, controlProfileMaterialization as Wf, SandboxLineage as Wi, cliWorktreeExecutor as Wl, StopDecision as Wn, HarvestReport as Wo, composeCheckSources as Wr, PersonaExecutors as Ws, ResolveDriveHarness as Wt, RunDetachedTurnOptions as Wu, settledToIteration as X, AgenticTask as Xa, AnalyzeOnSettleRoute as Xc, FileDelegationStoreOptions as Xd, promptOnlyProfileMaterialization as Xf, extractLlmCallEvent as Xi, SteerableSandboxSession as Xl, noProgressFor as Xn, observe as Xo, resolveEntrySymbol as Xr, DefinedLeaderboard as Xs, SupervisorProfile as Xt, DelegationArgs as Xu, createScope as Y, AgenticSurface as Ya, AnalystRegistry as Yc, FileDelegationStore as Yd, promptModelProfileMaterialization as Yf, createSandboxToolPartState as Yi, SteerableSandboxArgs as Yl, createProgressTracker as Yn, defaultAnalystInstruction as Yo, officialChecksFromMeta as Yr, ShapeRegistry as Ys, SupervisorNodeContextSeed as Yt, runDetachedTurn as Yu, WorkerSteerRequest as Z, AgenticTool as Za, AuthorizeDownMessage as Zc, InMemoryDelegationStore as Zd, promptResourceProfileMaterialization as Zf, mapSandboxEvent as Zi, createSteerableSandboxSession as Zl, plateau as Zn, renderReport as Zo, sandboxCheckRunner as Zr, LeaderboardBenchScore as Zs, SupervisorToolDescriptor as Zt, DelegationRecord as Zu, WorktreeFanoutOptions as _, FileCorpus as _a, Interval as _c, DelegateUiAuditResult as _d, DeliverableSpec as _f, discriminatingMeans as _i, WorkerSpawnContext as _l, naiveContinuationPrompt as _n, sampleThenRefine as _o, ReservationTicket as _r, PanelSpec as _s, WorktreePatchArtifact as _t, McpTransport as _u, SandboxInstance$1 as a, ResolveSandboxClientOptions as aa, LeaderboardSpec as ac, SubmitOutput as ad, RuntimeRunStateError as af, collectAgentTurn as ai, DownMessageDeliveryAttempt as al, SupervisorSpanRecorder as an, StrategyCtx as ao, pickBestDelivered as ar, EqualKOnCostOptions as as, workerControlLogFile as at, CreateWorktreeOptions as au, NOTE_MAX_CHARS as b, fanout as ba, LeaderboardRow as bc, DelegationFeedbackSnapshot as bd, FileSpawnJournal as bf, selectChampion as bi, createCoordinationTools as bl, ConcurrencyCaps as bn, LoopOptionsForDispatch as bo, AuthoredProfile as br, PipelineStage as bs, assertProfileModelsAllowed as bt, InMemoryFeedbackStore as bu, VerifierEnvironmentOptions as c, PromotionVerdict as ca, CompletionEvidence as cc, DelegateCodeConfig as cd, BusEvent as cf, ChampionPolicy as ci, MakeWorkerAgent as cl, PromptRegistry as cn, StrategyShotResult as co, CoordinationDeliveryEvidence as cr, FanoutOptions as cs, writeWorkerSteer as ct, GitRunner as cu, SuperviseSurfaceResult as d, trajectoryReport as da, completionAuthorizes as dc, DelegateFeedbackResult as dd, EventBus as df, EvolutionBandInfo as di, QuestionLevel as dl, createPromptRegistry as dn, breadthStrategy as do, FileCoordinationLog as dr, FlatWidenGate as ds, RunContext as dt, captureWorktreeDiff as du, CriuCapableClient as ea, LeaderboardFlagSpec as ec, DelegationResumeTick as ed, BackendTransportError as ef, visibleCheckScore as ei, CoordinationEvent as el, resolveSupervisorProfile as en, RunAgenticOptions as eo, validateProfileMaterialization as ep, FinalizeContext as er, Corpus as es, readWorkerSteerRequests as et, createInbox as eu, SurfaceWorkerConfig as f, builtinShapes as fa, deterministicCompletion as fc, DelegateResearchArgs as fd, PublishOptions as ff, EvolutionCandidate as fi, QuestionOption as fl, delegatesWorkerBriefPrompt as fn, defineStrategy as fo, PriorCoordination as fr, LoopUntil as fs, createFileRunContext as ft, createWorktree as fu, AuthoredHarness as g, runPersonified as ga, GroupOf as gc, DelegateUiAuditConfig as gd, watchTrace as gf, StrategyEvolutionConfig as gi, SettledWorker as gl, kernelPromptRegistry as gn, sample as go, ReservationRejection as gr, PanelJudge as gs, WorktreeCliExecutorOptions as gt, McpToolDescriptor$1 as gu, superviseSurface as h, definePersona as ha, AxisScoresOf as hc, DelegateUiAuditArgs as hd, defaultToolDetectors as hf, ReproductionCheck as hi, QuestionUrgency as hl, formatPromptHandle as hn, runAgentic as ho, BudgetReadout as hr, Panel as hs, patchDelivered as ht, JsonRpcResponse as hu, SandboxEvent$1 as i, acquireSandbox as ia, LeaderboardScore as ic, SubmitInput as id, PlannerError as if, StreamAgentTurnOptions as ii, DownMessageAuthorizationInput as il, SupervisorSpanOutcome as in, StrategyArtifacts as io, collectDelivered as ir, EqualKOnCost as is, supervisorWorkersDir as it, WorktreeProfileMaterializationReceipt as iu, Shell as j, buildSteerContext as ja, AuditIntentInput as jc, FeedbackRefersTo as jd, pendingWaits as jf, StdioMcpServerSpec as ji, DelegateHandlerOptions as jl, delegate as jn, ResolvedMcpServerLaunch as jo, CheckOutcome as jr, Verify as js, AuthorizedSpawn as jt, detachedSessionDelegate as ju, withUntrackedArtifacts as k, RegistryAnalyzeProjection as ka, renderLeaderboardSvg as kc, DelegationStatusResult as kd, loadSpawnForest as kf, McpToolDescriptor as ki, DelegateArgs as kl, DelegateOptions as kn, localSandboxClient as ko, supervisorInstructions as kr, TrajectoryReportFn as ks, defaultEdgeTraversalCap as kt, UiAuditorDelegate as ku, createVerifierEnvironment as l, promotionGate as la, CompletionPolicy as lc, DelegateCodeResult as ld, BusRecord as lf, EvolutionArchiveNode as li, Question as ll, RegisteredPrompt as ln, SurfaceScore as lo, CoordinationLog as lr, FanoutSynthesis as ls, InMemoryRunContext as lt, RemoveWorktreeOptions as lu, failuresAnalyst as m, registerShape as ma, stopSentinel as mc, DelegateResearchResult as md, WatchTraceOptions as mf, EvolutionReport as mi, QuestionRecord as ml, dumbContinuationPassPrompt as mn, refine as mo, BudgetPoolRestore as mr, LoopUntilState as ms, PatchDeliverableOptions as mt, JsonRpcMessage as mu, AnalystFinding$1 as n, probeSandboxCapabilities as na, LeaderboardRunContext as nc, DelegationTaskQueue as nd, JudgeError as nf, AgentTurnUsage as ni, CoordinationToolsOptions as nl, SupervisorSpanAttributes as nn, ShotSpec as no, SupervisorFinalizer as nr, CorpusRecord as ns, supervisorRunDir as nt, WorktreeCommandResult as nu, computeFindingId$1 as o, resolveSandboxClient as oa, defineLeaderboard as oc, hashIdempotencyInput as od, ValidationError as of, streamAgentTurn as oi, DownMessageDeliveryOutcome as ol, createSupervisorSpanRecorder as on, StrategyMessage as oo, runFinalizer as or, EqualKVerdict as os, workerInboxFile as ot, DiffOptions as ou, SurfaceWorkerOut as p, createShapeRegistry as pa, sentinelCompletion as pc, DelegateResearchConfig as pd, createEventBus as pf, EvolutionGeneration as pi, QuestionPolicy as pl, dumbContinuationFailPrompt as pn, depthStrategy as po, BudgetPool as pr, LoopUntilSpec as ps, createInMemoryRunContext as pt, removeWorktree as pu, createSupervisor as q, AgenticOptions as qa, createWaterfallCollector as qc, DelegationStateCorruptError as qd, profileMaterializationAxes as qf, createSandboxLineage as qi, DEFAULT_SANDBOX_STEERING_MAX_TURNS as ql, allWorkersStalled as qn, ObserveInput as qo, filterAuthoredAsserts as qr, ShapeBudget as qs, SupervisorAgentDeps as qt, formatDetachedSessionRef as qu, CreateSandboxOptions$1 as r, AcquireOptions as ra, LeaderboardScenario as rc, DelegationTaskQueueOptions as rd, NotFoundError as rf, CollectedAgentTurn as ri, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as rl, SupervisorSpanOptions as rn, Strategy as ro, bestDelivered as rr, EqualKArm as rs, supervisorRunsRoot as rt, WorktreeHarnessResult as ru, makeFinding$1 as s, PromotionGateOptions as sa, CompletionAnalyst as sc, DelegateCodeArgs as sd, CoderOutput as sf, ChampionPick as si, DownMessageEvent as sl, PromptHandle as sn, StrategyResult as so, runTree as sr, Fanout as ss, workerInboxFileFromEventDir as st, DiffResult as su, AgentProfile$2 as t, SandboxCapabilities as ta, LeaderboardIterationInfo as tc, DelegationRunContext as td, ConfigError as tf, AgentTurnBackend as ti, CoordinationTools as tl, supervisorAgent as tn, ShotPersona as to, worktreeCliProfileMaterialization as tp, FinalizerSettled as tr, CorpusFilter as ts, safeWorkerFile as tt, WorktreeCheckRunner as tu, SuperviseSurfaceOptions as u, equalKOnCost as ua, CompletionVerdict as uc, DelegateFeedbackArgs as ud, BusStats as uf, EvolutionAuthor as ui, QuestionDecision as ul, analyzesFindingsReportPrompt as un, adaptiveRefine as uo, CoordinationOwnerId as ur, FanoutWinnerSelector as us, InMemoryRunContextOptions as ut, WorktreeHandle as uu, worktreeFanout as v, InMemoryCorpus as va, Leaderboard as vc, DelegateUiAuditRoute as vd, gateOnDeliverable as vf, pickChampion as vi, WorkerWatchOptions as vl, promptHandle as vn, LoopCampaignDispatchOptions as vo, createBudgetPool as vr, PanelVerdict as vs, createWorktreeCliExecutor as vt, FeedbackEvent as vu, composeWorkerEvidence as w, pipeline as wa, ScoreOf as wc, DelegationProfile as wd, SpawnForestEvent as wf, authorStrategy as wi, createInProcessTransport as wl, RollingDispatchOptions as wn, RunLoopOptions as wo, assessAuthoredProfile as wr, ScopeAnalyzeInput as ws, GraphEdge as wt, CoderReviewer as wu, VERIFY_TAIL_CHARS as x, flatWidenGate as xa, PairwiseOptions as xc, DelegationHistoryArgs as xd, InMemoryResultBlobStore as xf, AuthorStrategyOptions as xi, normalizeAnalyzeOnSettle as xl, DispatchReport as xn, loopCampaignDispatch as xo, ProfileRichness as xr, RenderCorpusToInstructions as xs, AgentGraph as xt, eventToSnapshot as xu, EVIDENCE_MAX_CHARS as y, renderCorpusToInstructions as ya, LeaderboardOptions as yc, DelegationError as yd, FileResultBlobStore as yf, runStrategyEvolution as yi, canonicalFindingEvent as yl, supervisorPolicyPrompt as yn, LoopDispatchOptions as yo, spendFromUsageEvents as yr, Pipeline as ys, assertModelAllowed as yt, FeedbackStore as yu, TrajectoryAnalysis as z, BenchmarkConfig as za, anytimeReport as zc, DelegationTraceCaps as zd, KnownAgentProfileMaterializationAxis as zf, SandboxRunAbortError as zi, ExecutorConfig as zl, PlateauOptions as zn, InProcessPromptCtx as zo, StructuralRolloutPolicy as zr, DefinePersonaInput as zs, workerFromBackend as zt, DetachedSessionRefParts as zu };
-//# sourceMappingURL=index-EdjCQBV9.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

package/dist/{index-DIV33AF5.d.ts → index-BhuzfG2r.d.ts}

@@ -1,5 +1,5 @@
-import { Ft as SuperviseOptions, Xt as SupervisorProfile, _f as DeliverableSpec, zl as ExecutorConfig } from "./index-EdjCQBV9.js";
-import { Ct as SupervisedResult, z as Budget } from "./environment-provider-PM9PeW_J.js";
+import { Df as DeliverableSpec, It as SuperviseOptions, Yl as ExecutorConfig, Zt as SupervisorProfile } from "./index-BhZhQw77.js";
+import { Ct as SupervisedResult, z as Budget } from "./environment-provider-CUFsyymu.js";
 import { y as AgentCandidateOutputArtifactPort } from "./types-BaIpb0XT.js";
 import { i as AgentImprovementActivationTransition, n as AgentImprovementActivationResultStore, t as AgentImprovementActivationReconciliation } from "./activation-DyWB0K6E.js";
 import { AgentCandidateBundle, AgentCandidateCapturedArtifact, AgentCandidateKnowledge } from "@tangle-network/agent-interface";
@@ -137,4 +137,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-DIV33AF5.d.ts.map
+//# sourceMappingURL=index-BhuzfG2r.d.ts.map

package/dist/{index-D_M4d1_B.d.ts → index-DLM0W1h1.d.ts}

@@ -1,15 +1,15 @@
 import { _ as RunAgentTaskOptions, b as RuntimeSessionStore, g as OpenAIChatToolChoice, h as OpenAIChatTool, i as AgentExecutionBackend, l as AgentTaskRunResult, m as OpenAIChatResponseFormat, n as AgentBackendContext, p as KnowledgeReadinessDecision, r as AgentBackendInput, v as RunAgentTaskStreamOptions, x as RuntimeStreamEvent, y as RuntimeSession } from "./types-C9j4qg6l.js";
 import { i as SurfaceImprovementEdit } from "./improvement-adapter-D5gwwoXQ.js";
 import { o as ImprovementProposalSource } from "./types-zWfqDjeL.js";
-import { tf as ConfigError, zr as StructuralRolloutPolicy } from "./index-EdjCQBV9.js";
+import { Yr as StructuralRolloutPolicy, df as ConfigError } from "./index-BhZhQw77.js";
 import "./types-DnNGJ5Gz.js";
-import { hn as RuntimeTelemetryOptions } from "./environment-provider-PM9PeW_J.js";
+import { hn as RuntimeTelemetryOptions } from "./environment-provider-CUFsyymu.js";
 import { f as runLocalHarness, o as LocalHarness, w as ToolLoopChat } from "./local-harness-BIajef4A.js";
 import "./index-B3bHsVLw.js";
 import "./index-Efjb3nrQ.js";
 import { H as CandidateGenerator, L as Verifier, a as ImproveCandidateValidationInput, j as ReadonlyAgentProfile, p as ImproveMethodFactory, t as Redactor } from "./redact-PQzmE1Jn.js";
-import "./index-DIV33AF5.js";
-import "./loop-runner-bin-Bo29_fiD.js";
+import "./index-BhuzfG2r.js";
+import "./loop-runner-bin-Ckp_9tmD.js";
 import "./openai-tools-B68JaOCx.js";
 import { ControlBudget as ControlBudget$1, ControlDecision as ControlDecision$1, ControlEvalResult, ControlEvalResult as ControlEvalResult$1, ControlRunResult as ControlRunResult$1, ControlStep as ControlStep$1, DataAcquisitionPlan as DataAcquisitionPlan$1, KnowledgeReadinessReport, KnowledgeReadinessReport as KnowledgeReadinessReport$1, KnowledgeRequirement as KnowledgeRequirement$1, ProposalFinding, RunRecord, RunRecord as RunRecord$1 } from "@tangle-network/agent-eval";
 import { GepaOptimizationMethodConfig, SkillOptOptimizationMethodConfig } from "@tangle-network/agent-eval/campaign";
@@ -542,4 +542,4 @@ declare function readinessServerSentEvent(report: KnowledgeReadinessReport, opti
 declare function runtimeStreamServerSentEvent(event: RuntimeStreamEvent, options?: RuntimeTelemetryOptions & ServerSentEventOptions): string;
 //#endregion
 export { McpServeSpec as $, resolveRouterBaseUrl as A, RawTraceDistillerOptions as B, DEFAULT_ROUTER_BASE_URL as C, cleanModelId as D, RouterEnv as E, parseRolloutPolicy as F, strategyAuthorMethod as G, buildDriverSystem as H, serializeRolloutPolicy as I, OfficialOptimizerUnavailableError as J, OfficialGepaOptions as K, structuralRolloutPolicyFromProfile as L, ROLLOUT_POLICY_EXTENSION as M, applyRolloutPolicyToProfile as N, getModels as O, normalizeRolloutPolicy as P, officialSkillOpt as Q, ReflectiveGeneratorOptions as R, ChatModelValidation as S, ResolvedChatModel as T, optimizerMethod as U, rawTraceDistiller as V, researchDriverNote as W, OfficialSkillOptOptions as X, OfficialSensitiveCandidateInput as Y, officialGepa as Z, AgentBackendKind as _, ControlStep$1 as a, mcpBuildPrompt as at, decideKnowledgeReadiness as b, KnowledgeRequirement$1 as c, createIterableBackend as ct, readinessServerSentEvent as d, mcpServeVerifier as et, runtimeStreamServerSentEvent as f, runAgentTaskStream as g, runAgentTask as h, ControlRunResult$1 as i, findingLines as it, validateChatModelId as j, resolveChatModel as k, RunRecord$1 as l, createOpenAICompatibleBackend as lt, applyRunRecordDefaults as m, ControlDecision$1 as n, driverLoopGenerator as nt, DataAcquisitionPlan$1 as o, toolBuildPrompt as ot, InMemoryRuntimeSessionStore as p, OfficialOptimizerContextOptions as q, ControlEvalResult$1 as r, BuildPromptFindingsInput as rt, KnowledgeReadinessReport$1 as s, BackendRetryPolicy as st, ControlBudget$1 as t, DriverLoopGeneratorOptions as tt, ServerSentEventOptions as u, createSandboxPromptBackend as ut, ResolveAgentBackendOptions as v, ModelInfo as w, ChatModelCandidate as x, resolveAgentBackend as y, reflectiveGenerator as z };
-//# sourceMappingURL=index-D_M4d1_B.d.ts.map
+//# sourceMappingURL=index-DLM0W1h1.d.ts.map