@tangle-network/agent-runtime 0.109.2 → 0.111.0

package/dist/{index-BwY61sh3.d.ts → index-BmI2uxy5.d.ts}

@@ -1,5 +1,5 @@
-import { R as Budget, ut as SupervisedResult } from "./environment-provider-CMqSAp-O.js";
-import { Rc as DeliverableSpec, ac as ExecutorConfig, ct as SupervisorProfile, j as SuperviseOptions } from "./index-CFJ_1m1U.js";
+import { R as Budget, ut as SupervisedResult } from "./environment-provider-CTEMEP9u.js";
+import { Ad as DeliverableSpec, Dc as ExecutorConfig, H as SuperviseOptions, Ot as SupervisorProfile } from "./index-DlLPNELY.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-BwY61sh3.d.ts.map
+//# sourceMappingURL=index-BmI2uxy5.d.ts.map

package/dist/{index-CFJ_1m1U.d.ts → index-DlLPNELY.d.ts}

@@ -1,8 +1,8 @@
 import { d as AgentTaskStatus, f as BackendErrorDetail, i as AgentExecutionBackend, x as RuntimeStreamEvent } from "./types-C9j4qg6l.js";
-import { n as AnalystRegistryLike } from "./types-CfGKhIuj.js";
+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 { $ as RootHandle, B as Executor, H as ExecutorFactory, I as Agent, K as NodeId, L as AgentSpec, Mt as TraceSource, R as Budget, U as ExecutorRegistry, Vt as WorkerProgress, X as ResultBlobStore, Z as ResumedKeyState, _t as PendingWait, at as SpawnJournal, bt as WaitProbeRegistry, dt as Supervisor, i as AgentEnvironmentProvider, it as SpawnEvent, lt as Spend, mt as UsageEvent, nt as Scope, o as AgentEnvironmentProviderRegistry, ot as SpawnOpts, pt as TreeView, rt as Settled, tt as Runtime, ut as SupervisedResult, w as ProviderExecutorOptions, z as DefaultVerdict, zt as ExecutorProgress } from "./environment-provider-CMqSAp-O.js";
+import { $ as RootHandle, B as Executor, H as ExecutorFactory, I as Agent, K as NodeId, L as AgentSpec, Mt as TraceSource, R as Budget, U as ExecutorRegistry, Vt as WorkerProgress, X as ResultBlobStore, Z as ResumedKeyState, _t as PendingWait, at as SpawnJournal, bt as WaitProbeRegistry, dt as Supervisor, i as AgentEnvironmentProvider, it as SpawnEvent, lt as Spend, mt as UsageEvent, nt as Scope, o as AgentEnvironmentProviderRegistry, ot as SpawnOpts, pt as TreeView, rt as Settled, tt as Runtime, ut as SupervisedResult, w as ProviderExecutorOptions, z as DefaultVerdict, zt as ExecutorProgress } from "./environment-provider-CTEMEP9u.js";
 import { o as UiLens, r as UiFinding, s as CoderTask } from "./substrate-BcnuSHXm.js";
 import { D as RuntimeTelemetryOptions, c as runLocalHarness, d as RouterConfig, i as LocalHarness, m as ToolSpec, n as CodexExecutionPolicy, r as CodexTokenUsage, x as ToolLoopCompactionOptions, y as ToolLoopChat } from "./local-harness-Dh8PJ0ot.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, ValidationError, buildTrajectory, computeFindingId as computeFindingId$1, makeFinding as makeFinding$1 } from "@tangle-network/agent-eval";
@@ -99,6 +99,27 @@ declare function materializeTreeView(events: SpawnEvent[]): TreeView;
  */
 declare function pendingWaits(events: SpawnEvent[]): PendingWait[];
 //#endregion
+//#region src/runtime/supervise/completion-gate.d.ts
+/**
+ * The deployable completion oracle passed to {@link gateOnDeliverable}: a `check` that
+ * decides DELIVERED (settles `valid` ⟺ it resolves true) plus an optional `describe` of
+ * what the spawn was supposed to produce. The check reads the child's output — never the
+ * model judging itself.
+ */
+interface DeliverableSpec<Out = unknown> {
+  /** The deployable check that decides DELIVERED. `settled.valid ⟺ this resolves true`. */
+  check: (out: Out) => boolean | Promise<boolean>;
+  /** What the spawn was supposed to produce — surfaced in traces/reports. */
+  describe?: string;
+}
+/**
+ * Wrap an `Executor` so its settlement `valid` reflects the deliverable check, not the
+ * inner verdict. Handles both `execute` shapes (one-shot `Promise<ExecutorResult>` and
+ * streaming `AsyncIterable<UsageEvent>` + `resultArtifact()`); the check runs once the inner
+ * executor has produced its output. The inner `score` is preserved; only `valid` is gated.
+ */
+declare function gateOnDeliverable<Out>(inner: Executor<Out>, deliverable: DeliverableSpec<Out>): Executor<Out>;
+//#endregion
 //#region src/runtime/supervise/detector-monitor.d.ts
 interface WatchTraceOptions {
   /** The detectors to run online. Defaults to a stuck-loop + error-streak panel. */
@@ -1730,27 +1751,6 @@ interface JsonRpcResponse {
   };
 }
 //#endregion
-//#region src/runtime/supervise/completion-gate.d.ts
-/**
- * The deployable completion oracle passed to {@link gateOnDeliverable}: a `check` that
- * decides DELIVERED (settles `valid` ⟺ it resolves true) plus an optional `describe` of
- * what the spawn was supposed to produce. The check reads the child's output — never the
- * model judging itself.
- */
-interface DeliverableSpec<Out = unknown> {
-  /** The deployable check that decides DELIVERED. `settled.valid ⟺ this resolves true`. */
-  check: (out: Out) => boolean | Promise<boolean>;
-  /** What the spawn was supposed to produce — surfaced in traces/reports. */
-  describe?: string;
-}
-/**
- * Wrap an `Executor` so its settlement `valid` reflects the deliverable check, not the
- * inner verdict. Handles both `execute` shapes (one-shot `Promise<ExecutorResult>` and
- * streaming `AsyncIterable<UsageEvent>` + `resultArtifact()`); the check runs once the inner
- * executor has produced its output. The inner `score` is preserved; only `valid` is gated.
- */
-declare function gateOnDeliverable<Out>(inner: Executor<Out>, deliverable: DeliverableSpec<Out>): Executor<Out>;
-//#endregion
 //#region src/mcp/worktree.d.ts
 /**
  *
@@ -1955,7 +1955,7 @@ interface PiSeam {
   model?: string;
   cwd?: string;
   env?: Record<string, string>;
-  /** Wall-clock ceiling for one `prompt` (the wait for `agent_end`). Omit = no timeout. */
+  /** Wall-clock ceiling for one `prompt` (the wait for `agent_settled`). Omit = no timeout. */
   turnTimeoutMs?: number;
   /** Newest-last activity window `progress()` reports. Default 12. */
   activityWindow?: number;
@@ -2490,6 +2490,12 @@ interface CoordinationToolsOptions {
   readonly blobs: ResultBlobStore;
   readonly makeWorkerAgent: MakeWorkerAgent;
   readonly perWorker: Budget;
+  /**
+   * The same independent completion check used for workers. When present, the driver receives a
+   * `submit_result` tool and may finish work itself instead of being forced to delegate it. The
+   * first passing submission is retained; a false or throwing check fails closed.
+   */
+  readonly deliverable?: DeliverableSpec<unknown>;
   readonly analysts?: AnalystRegistry;
   readonly onEvent?: (event: CoordinationEvent) => void | Promise<void>;
   readonly questionPolicy?: QuestionPolicy;
@@ -2564,6 +2570,10 @@ interface CoordinationTools {
   readonly tools: McpToolDescriptor$1[];
   isStopped(): boolean;
   stopReason(): string | undefined;
+  /** The first result whose injected independent check passed, if the driver submitted one. */
+  submittedResult(): {
+    readonly result: unknown;
+  } | undefined;
   settled(): ReadonlyArray<SettledWorker>;
   questions(): ReadonlyArray<QuestionRecord>;
   /** The full ordered log of every bus event — UP (settled / question / finding) and DOWN
@@ -4023,6 +4033,32 @@ declare function secretEnvOfMcpServer(server: AgentProfileMcpServer): Record<str
  * server for the error (e.g. `profile.mcp['exa']`).
  */
 declare function resolveSecretEnv(secretEnv: Record<string, string>, keys: KeyProvider | undefined, label: string): Promise<Record<string, string>>;
+/** The spawn-ready strings for one stdio MCP server: profile config values
+ *  resolved, secrets separated so the client can redact them. */
+interface ResolvedMcpServerLaunch {
+  args?: string[];
+  /** Public env, safe to appear in diagnostics. */
+  env?: Record<string, string>;
+  /** Resolved secret env. Reaches only the child process; redacted everywhere else. */
+  protectedEnv?: Record<string, string>;
+}
+/**
+ * Resolve a profile MCP server's `args`/`env` config values (interface ≥0.40
+ * `AgentProfileConfigValue`) plus the legacy `metadata.secretEnv` channel into
+ * the plain strings a spawn needs.
+ *
+ * Rules, all fail-closed:
+ * - `args` must be public values. A secret-ref in argv is refused: argv is
+ *   readable by every host process (/proc/PID/cmdline) and outside the
+ *   protected-value redaction channel, so a secret there cannot be contained.
+ * - `env` secret-refs resolve through the KeyProvider (missing provider or key
+ *   throws, naming the KEY NAME only) and land in `protectedEnv`.
+ * - An env var declared secret on BOTH channels (env secret-ref and
+ *   metadata.secretEnv) is ambiguous configuration and throws.
+ * - A public `env` entry shadowed by a legacy metadata secret keeps the
+ *   pre-0.40 spawn precedence: the secret value wins in the child env.
+ */
+declare function resolveMcpServerLaunch(server: AgentProfileMcpServer, keys: KeyProvider | undefined, label: string): Promise<ResolvedMcpServerLaunch>;
 //#endregion
 //#region src/runtime/local-sandbox-client.d.ts
 interface LocalSandboxClientOptions {
@@ -4621,7 +4657,7 @@ declare function createScopeAnalyst<D>(scope: Scope<Outcome<D>>, options: Create
 interface RegistryAnalyzeProjection {
   readonly runId: string;
   readonly inputs: AnalystRunInputs;
-  /** Optional `run` opts (e.g. `priorFindings`) forwarded verbatim to the registry. */
+  /** Optional `run` opts (e.g. `priorFindings`, `chainFindings`) forwarded verbatim to the registry. */
   readonly opts?: Parameters<AnalystRegistryLike['run']>[2];
 }
 /**
@@ -5381,11 +5417,12 @@ interface MaterializeLocalMcpOptions {
   timeoutMs?: number;
   /** Cap on a tool result's text fed back to the worker. Default 2000 chars. */
   maxResultChars?: number;
-  /** Resolves a server's DECLARED secrets (`metadata.secretEnv`: env var name →
-   *  provider key name) at spawn time. The resolved values reach ONLY the child
-   *  process env — never the profile, the logs, or an error message. Fail-closed:
-   *  a server declaring secrets without a provider (or with a missing key)
-   *  throws instead of booting keyless. */
+  /** Resolves a server's DECLARED secrets at spawn time — env entries of kind
+   *  `secret-ref` (interface ≥0.40) and the legacy `metadata.secretEnv` map
+   *  (env var name → provider key name). The resolved values reach ONLY the
+   *  child process env — never the profile, the logs, or an error message.
+   *  Fail-closed: a server declaring secrets without a provider (or with a
+   *  missing key) throws instead of booting keyless. */
   keys?: KeyProvider;
   /** Required trust decision for profiles that declare local MCP processes.
    * Omit to refuse all profile-controlled host execution. Passing
@@ -6435,6 +6472,9 @@ interface DriverAgentOptions {
   readonly makeWorkerAgent: MakeWorkerAgent;
   /** Per-child budget reserved from the conserved pool on each spawn. */
   readonly perWorker: Budget;
+  /** Independent completion check for work the driver performs itself. When present, the driver
+   *  receives `submit_result`; the first passing submission ends the loop and becomes the output. */
+  readonly deliverable?: DeliverableSpec<unknown>;
   /** Hard cap on simultaneously-LIVE workers — `spawn_agent` fails closed once this many are in
    *  flight (a concurrency fence on top of the conserved-pool fence). Omit/`<= 0` = no cap. */
   readonly maxLiveWorkers?: number;
@@ -6541,6 +6581,8 @@ interface CoordinationMcpHandle {
   readonly port: number;
   /** The coordination tools' settled-worker ledger (for the driver's finalize). */
   settled(): ReadonlyArray<SettledWorker>;
+  /** The first driver-authored result whose injected independent check passed. */
+  submittedResult: CoordinationTools['submittedResult'];
   /** Post-loop drain of already-settled, unpulled children into the ledger — call before reading
    *  `settled()` for a finalize, so a delivered child the harness never awaited is not lost. */
   drainResolved: CoordinationTools['drainResolved'];
@@ -6560,6 +6602,8 @@ declare function serveCoordinationMcp(opts: {
   blobs: ResultBlobStore;
   makeWorkerAgent: MakeWorkerAgent;
   perWorker: Budget;
+  /** Independent completion check exposed to the driver as `submit_result`. */
+  deliverable?: DeliverableSpec<unknown>;
   /** Hard cap on simultaneously-LIVE workers — `spawn_agent` fails closed once this many are in
    *  flight (a concurrency fence on top of the conserved-pool fence). Omit/`<= 0` = no cap. */
   maxLiveWorkers?: number;
@@ -6612,6 +6656,8 @@ interface SupervisorAgentDeps {
   readonly makeWorkerAgent: MakeWorkerAgent;
   /** Per-child budget reserved from the conserved pool on each spawn. */
   readonly perWorker: Budget;
+  /** Independent completion check for direct driver work (`submit_result`). */
+  readonly deliverable?: DeliverableSpec<unknown>;
   /** Hard cap on simultaneously-LIVE workers across both arms — `spawn_agent` fails closed once
    *  this many are in flight (a concurrency fence on top of the conserved-pool fence; bounds live
    *  boxes/sandboxes, not total work). Omit/`<= 0` = no cap. */
@@ -6966,6 +7012,81 @@ declare function createInMemoryRunContext(opts?: InMemoryRunContextOptions): InM
  */
 declare function createFileRunContext(dir: string, opts?: InMemoryRunContextOptions): RunContext;
 //#endregion
+//#region src/runtime/supervise/run-layout.d.ts
+/**
+ * The on-disk supervisor-run layout: `<root>/.agent/supervisor/<id>`.
+ *
+ * This is the durable, cross-process face of a supervisor run — the counterpart to the in-process
+ * `Inbox` seam in `./inbox`. A run persists its state under one directory so that any OTHER process
+ * can find it after the fact: `@tangle-network/traces` reads exactly this layout via
+ * `traces analyze --supervisor-run-dir`, a restarted host can rehydrate a run it no longer holds
+ * handles to, and a human can steer a live worker by appending one NDJSON line. Until now the
+ * layout was defined only in the unpublished `loops` repo (`src/supervisor-control.ts`) — a
+ * published reader depending on an unpublished writer's convention — so the contract is promoted
+ * here, names preserved.
+ *
+ * `.agent` is the one dot-dir for ALL agent-owned state (skills already write
+ * `.agent/hypotheses/`, `.agent/skill-runs.jsonl`); supervisor runs live beside them rather than
+ * under a product-branded dir. Runs written by older writers used `.loops/supervisor/<id>` —
+ * readers that must see those keep a legacy fallback; this writer never creates `.loops` again.
+ *
+ * Layout, relative to `supervisorRunDir(root, id)`:
+ *
+ *   workers/<label>.inbox.ndjson   down-leg steer/answer requests for one worker (durable inbox);
+ *                                  each line is a {@link WorkerSteerRequest}
+ *   workers/<label>.ndjson         best-effort per-worker control-event log (delivery bookkeeping)
+ *
+ * Reads are tolerant by contract: a partial trailing line (a writer mid-append) or a corrupt line
+ * never poisons the rest of the file — later valid lines still matter.
+ *
+ * Promoted from `loops/src/supervisor-control.ts`. The one deliberate difference: the loops version
+ * resolved a worker id to its label through the run journal before writing a steer; that resolution
+ * stays with the caller (it is journal-format-specific), so `writeWorkerSteer` here takes the worker
+ * LABEL directly.
+ *
+ * @experimental
+ */
+/** One durable down-leg request appended to a worker's inbox file. */
+interface WorkerSteerRequest {
+  readonly id: string;
+  /** ISO timestamp of the append. */
+  readonly at: string;
+  /** Who asked — 'human', a brain label, a tool name. Provenance, not authorization. */
+  readonly source: string;
+  /** The worker LABEL the request targets (already resolved by the caller). */
+  readonly worker: string;
+  readonly message: string;
+}
+/** The root every supervisor run of one workspace lives under. */
+declare function supervisorRunsRoot(rootDir: string): string;
+/** The run directory every artifact of one supervisor run lives under. */
+declare function supervisorRunDir(rootDir: string, id: string): string;
+/**
+ * Where a pre-rename writer put the same run (`<root>/.loops/supervisor/<id>`). Readers that must
+ * see historical runs check {@link supervisorRunDir} first and fall back to this; nothing writes
+ * here anymore.
+ */
+declare function legacySupervisorRunDir(rootDir: string, id: string): string;
+/** A worker label reduced to a safe filename stem. Empty labels get a stable fallback. */
+declare function safeWorkerFile(label: string): string;
+/** The durable inbox file for one worker of one run. */
+declare function workerInboxFile(rootDir: string, supervisorId: string, worker: string): string;
+/** Same, addressed from an already-known run directory (the reader's usual entry point). */
+declare function workerInboxFileFromEventDir(eventDir: string, worker: string): string;
+/**
+ * Durably append one steer request to a worker's inbox and log the delivery attempt.
+ *
+ * The inbox append is the durable act; the control-event log is best-effort bookkeeping and may
+ * silently fail without voiding the steer.
+ */
+declare function writeWorkerSteer(rootDir: string, supervisorId: string, worker: string, message: string, source?: string): {
+  worker: string;
+  file: string;
+  request: WorkerSteerRequest;
+};
+/** Read every valid steer request in a worker's inbox. Corrupt or partial lines are skipped. */
+declare function readWorkerSteerRequests(eventDir: string, worker: string): WorkerSteerRequest[];
+//#endregion
 //#region src/runtime/supervise/scope.d.ts
 /** Construction args for `createScope`. The supervisor threads the shared pool, journal,
  *  blob store, and executor registry through; `depth`/`maxDepth` pair the runtime
@@ -7054,9 +7175,9 @@ interface SuperviseOptions {
   readonly budget: Budget;
   /** WHERE workers run — derives the worker seam. Provide this OR an explicit `makeWorkerAgent`. */
   readonly backend?: ExecutorConfig;
-  /** The completion oracle for backend-derived workers (settled ⟺ delivered). Strongly recommended:
-   *  without it the supervisor trusts a worker's self-report — exactly the "ran but didn't deliver"
-   *  failure mode of a static orchestrator. */
+  /** The independent completion check for backend-derived workers and direct supervisor
+   *  submissions. Strongly recommended: without it the supervisor cannot submit its own work and
+   *  backend-derived workers fall back to their own validity signal. */
   readonly deliverable?: DeliverableSpec<unknown>;
   /** Override the worker seam directly (tests / advanced) instead of deriving it from `backend`. */
   readonly makeWorkerAgent?: MakeWorkerAgent;
@@ -7187,6 +7308,148 @@ interface TrajectoryAnalysis {
 /** Collect the source's spans and run the agent-eval batch analyzers over them under one `runId`. */
 declare function analyzeTrace(source: TraceSource, runId?: string): Promise<TrajectoryAnalysis>;
 //#endregion
+//#region src/runtime/workspace.d.ts
+/** Command runner seam. Host code can use `localShell`; sandbox code can wrap `box.exec`. */
+type Shell = (args: ReadonlyArray<string>, cwd?: string) => Promise<{
+  stdout: string;
+  stderr: string;
+  code: number;
+}>;
+type WorkspaceCommit = {
+  readonly ok: true;
+  readonly rev: string;
+} | {
+  readonly ok: false;
+  readonly conflict: string;
+};
+interface Workspace {
+  readonly ref: string;
+  materialize(dir: string): Promise<void>;
+  commit(dir: string, message: string): Promise<WorkspaceCommit>;
+  head(): Promise<string>;
+}
+/** Host-process `Shell`: run a command via `execFile`, resolving `{ stdout, stderr, code }` (never throws on non-zero exit). */
+declare function localShell(): Shell;
+interface GitWorkspaceOptions {
+  readonly ref: string;
+  readonly shell?: Shell;
+  readonly branch?: string;
+  readonly noHooks?: boolean;
+}
+/** A `Workspace` over a git checkout: materialize an isolated worktree at `ref`, commit produced changes (conflict-aware), and read `head` — hooks disabled, identity pinned. */
+declare function gitWorkspace(opts: GitWorkspaceOptions): Workspace;
+/** A jj-backed `Workspace` (Jujutsu, colocated with git for the durable remote).
+ *  Same port, same `Shell` — a drop-in for `gitWorkspace`. jj suits agent loops:
+ *  no staging area, and a first-class operation log (native resume/undo). Live use
+ *  requires `jj` on the `Shell`'s host. */
+declare function jjWorkspace(opts: GitWorkspaceOptions): Workspace;
+interface WorkspaceRun<T> {
+  readonly valid: boolean;
+  readonly value: T;
+  /** Present when a commit was attempted (valid, or `commitOnInvalid`). */
+  readonly commit?: WorkspaceCommit;
+}
+/**
+ * Run a worker `body` inside a FRESH clone of a shared `Workspace`, then commit its work back
+ * so the next worker (or the supervisor) builds on it. This is the seam that turns isolated
+ * per-worker cwds into one compounding artifact — `body` gets a real materialized dir, its
+ * delivery is committed to the shared ref iff it's valid (a conflict is returned, never thrown).
+ * The clone is removed after; durable state lives only in the ref.
+ */
+declare function runInWorkspace<T>(ws: Workspace, body: (cwd: string) => Promise<{
+  valid: boolean;
+  value: T;
+  message?: string;
+}>, opts?: {
+  tmpPrefix?: string;
+  commitOnInvalid?: boolean;
+}): Promise<WorkspaceRun<T>>;
+//#endregion
+//#region src/runtime/supervise/untracked-clone.d.ts
+interface UntrackedCopyStats {
+  /** Files + symlinks that landed in the clone. */
+  copied: number;
+  /** Total regular-file bytes enumerated (pre-copy, so the size warning fires first). */
+  bytes: number;
+}
+interface CopyOptions {
+  warnBytes?: number;
+  log?: (message: string) => void;
+}
+/**
+ * Copy every untracked file of `sourceDir`'s working tree — including git-ignored
+ * build outputs (`git ls-files --others` with NO exclude flags lists both) — into
+ * `cloneDir`, then shield the copied paths from the clone's `git add -A` via
+ * `.git/info/exclude`. Nested git repos (listed as bare `dir/` entries), any path
+ * containing a `.git` segment, and loop-infra dirs are skipped.
+ */
+declare function copyUntrackedIntoClone(sourceDir: string, cloneDir: string, opts?: CopyOptions): UntrackedCopyStats;
+/**
+ * Wrap a `Workspace` so every `materialize` (the per-worker `git clone` inside
+ * `runInWorkspace`) is followed by the untracked-artifact copy above — the clone
+ * the worker starts in matches the source WORKING TREE, not just its history.
+ * `commit`/`head` pass through untouched, so delivery semantics are unchanged.
+ */
+declare function withUntrackedArtifacts(ws: Workspace, sourceDir: string, log?: (message: string) => void): Workspace;
+//#endregion
+//#region src/runtime/supervise/worker-evidence.d.ts
+/**
+ * Evidence-rich worker settlement.
+ *
+ * The supervisor BRAIN decides respawn/steer/stop from what a settled worker
+ * shows it. A bare `finished passed=false patchBytes=6138` starves that
+ * decision: the brain cannot quote the failing assertion, so its next worker
+ * goal is authored blind. This module composes the bounded evidence block a
+ * settling worker appends to its event stream and — on failure — returns as
+ * its output artifact, so `observe_agent` hands the brain the failing verify
+ * tail, a diff summary, and the worker's final note instead of counters.
+ */
+/** Hard cap on one worker's evidence block so the brain's context cannot blow up. */
+declare const EVIDENCE_MAX_CHARS = 3000;
+/** Tail of the verify output — the failing assertion lives at the END of a test log. */
+declare const VERIFY_TAIL_CHARS = 1200;
+/** Cap on the worker's closing note inside the evidence block. */
+declare const NOTE_MAX_CHARS = 300;
+interface WorkerEvidenceInput {
+  readonly passed: boolean;
+  readonly testPassed: boolean;
+  readonly typecheckPassed: boolean;
+  /** Combined stdout+stderr of the verify/test command (already backend-capped). */
+  readonly testOutput: string;
+  readonly typecheckOutput: string;
+  readonly patch: string;
+  /** The worker's own closing commentary, when the backend surfaces one. */
+  readonly reviewerNotes?: string;
+}
+/**
+ * Compose the settle evidence block. Section order is priority order under the
+ * hard cap: the verify tail (what failed) survives before the diff head (what
+ * was tried) and the worker note — a truncated diff is recoverable from the
+ * persisted patch file, a truncated failing assertion is not recoverable at all.
+ */
+declare function composeWorkerEvidence(input: WorkerEvidenceInput): string;
+/**
+ * What a settled worker exposes as its output artifact (the blob the brain's
+ * `observe_agent` reads). A passing worker's output is its patch — the
+ * deliverable. A failing worker's output is its evidence block. A passing
+ * worker with NO edits — the post-delivery read-only reviewer: the workspace
+ * already holds a delivered fix, so the gate stays green under an empty diff —
+ * would otherwise settle with an EMPTY output and its review would be lost, so
+ * it exposes its evidence block instead (the worker note carries the review).
+ */
+declare function settledWorkerOut(input: {
+  readonly passed: boolean;
+  readonly patch: string;
+  readonly evidence: string;
+}): string;
+/**
+ * The worker's closing commentary off a local harness run: the TAIL of its
+ * stdout (falling back to stderr), bounded to the note cap so a reviewer's
+ * final verdict line — written last — survives into the evidence block
+ * (`composeWorkerEvidence` keeps the note's FIRST `NOTE_MAX_CHARS` chars).
+ */
+declare function closingWorkerNote(stdout: string, stderr: string): string | undefined;
+//#endregion
 //#region src/runtime/supervise/worktree-fanout.d.ts
 /** @experimental One authored harness profile in a worktree fanout: the §1.5 profile + which local
  *  harness CLI drives it. The supervisor authors `profile` per sub-task; `harness` chooses the leaf. */
@@ -7313,62 +7576,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
-//#region src/runtime/workspace.d.ts
-/** Command runner seam. Host code can use `localShell`; sandbox code can wrap `box.exec`. */
-type Shell = (args: ReadonlyArray<string>, cwd?: string) => Promise<{
-  stdout: string;
-  stderr: string;
-  code: number;
-}>;
-type WorkspaceCommit = {
-  readonly ok: true;
-  readonly rev: string;
-} | {
-  readonly ok: false;
-  readonly conflict: string;
-};
-interface Workspace {
-  readonly ref: string;
-  materialize(dir: string): Promise<void>;
-  commit(dir: string, message: string): Promise<WorkspaceCommit>;
-  head(): Promise<string>;
-}
-/** Host-process `Shell`: run a command via `execFile`, resolving `{ stdout, stderr, code }` (never throws on non-zero exit). */
-declare function localShell(): Shell;
-interface GitWorkspaceOptions {
-  readonly ref: string;
-  readonly shell?: Shell;
-  readonly branch?: string;
-  readonly noHooks?: boolean;
-}
-/** A `Workspace` over a git checkout: materialize an isolated worktree at `ref`, commit produced changes (conflict-aware), and read `head` — hooks disabled, identity pinned. */
-declare function gitWorkspace(opts: GitWorkspaceOptions): Workspace;
-/** A jj-backed `Workspace` (Jujutsu, colocated with git for the durable remote).
- *  Same port, same `Shell` — a drop-in for `gitWorkspace`. jj suits agent loops:
- *  no staging area, and a first-class operation log (native resume/undo). Live use
- *  requires `jj` on the `Shell`'s host. */
-declare function jjWorkspace(opts: GitWorkspaceOptions): Workspace;
-interface WorkspaceRun<T> {
-  readonly valid: boolean;
-  readonly value: T;
-  /** Present when a commit was attempted (valid, or `commitOnInvalid`). */
-  readonly commit?: WorkspaceCommit;
-}
-/**
- * Run a worker `body` inside a FRESH clone of a shared `Workspace`, then commit its work back
- * so the next worker (or the supervisor) builds on it. This is the seam that turns isolated
- * per-worker cwds into one compounding artifact — `body` gets a real materialized dir, its
- * delivery is committed to the shared ref iff it's valid (a conflict is returned, never thrown).
- * The clone is removed after; durable state lives only in the ref.
- */
-declare function runInWorkspace<T>(ws: Workspace, body: (cwd: string) => Promise<{
-  valid: boolean;
-  value: T;
-  message?: string;
-}>, opts?: {
-  tmpPrefix?: string;
-  commitOnInvalid?: boolean;
-}): Promise<WorkspaceRun<T>>;
-//#endregion
-export { effectiveConcurrency as $, RenderCorpusToInstructionsOptions as $a, DetachedWinnerSelection as $c, LoopOptionsForDispatch as $i, DelegationStatus as $l, ApplyContinuation as $n, PairwiseVerdict as $o, fanout as $r, createDelegateHandler as $s, authoredWorker as $t, ValidationError as $u, createSupervisor as A, CombinatorShape as Aa, DiffOptions as Ac, AgenticTool as Ai, SubmitInput as Al, CollectedAgentTurn as An, LeaderboardBenchmarkAdapter as Ao, mapSandboxEvent as Ar, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as As, sampleFromSettled as At, DELEGATION_TRACE_MAX_BYTES as Au, createFileRunContext as B, FanoutSynthesis as Ba, JsonRpcMessage as Bc, StrategyResult as Bi, DelegateResearchResult as Bl, EvolutionGeneration as Bn, CompletionPolicy as Bo, PromotionGateOptions as Br, SettledWorker as Bs, CoordinationLog as Bt, DelegationStateCorruptError as Bu, failuresAnalyst as C, Observation as Ca, piExecutor as Cc, Environment as Ci, DelegationRecord as Cl, resolveEntrySymbol as Cn, RunPersonifiedOptions as Co, SandboxLineage as Cr, WaterfallSpan as Cs, StopRule as Ct, buildLoopOtelSpans as Cu, worktreeFanout as D, observe as Da, WorktreeHarnessResult as Dc, AgenticRunResult as Di, DelegationRunContext as Dl, visibleCheckScore as Dn, DefinedLeaderboard as Do, SandboxToolPartState as Dr, CoordinationEvent as Ds, createProgressTracker as Dt, exportEvalRuns as Du, WorktreeFanoutOptions as E, defaultAnalystInstruction as Ea, WorktreeCommandResult as Ec, AgenticOptions as Ei, DelegationResumeTick as El, structuralRollout as En, ShapeRegistry as Eo, createSandboxLineage as Er, AnalystRegistry as Es, anyOf as Et, createOtelExporter as Eu, createScope as F, EqualKOnCost as Fa, captureWorktreeDiff as Fc, ShotSpec as Fi, DelegateCodeResult as Fl, ChampionPolicy as Fn, LeaderboardScore as Fo, probeSandboxCapabilities as Fr, QuestionLevel as Fs, bestDelivered as Ft, buildDelegationTraceSpans as Fu, WorktreePatchArtifact as G, LoopUntilState as Ga, FeedbackStore as Gc, defineStrategy as Gi, DelegationError as Gl, pickChampion as Gn, stopSentinel as Go, builtinShapes as Gr, createInProcessTransport as Gs, ReservationTicket as Gt, AgentEvalError$1 as Gu, PatchDeliverableOptions as H, FlatWidenGate as Ha, McpToolDescriptor$1 as Hc, SurfaceScore as Hi, DelegateUiAuditConfig as Hl, ReproductionCheck as Hn, completionAuthorizes as Ho, promotionGate as Hr, createCoordinationTools as Hs, PriorCoordination as Ht, FileDelegationStore as Hu, settledToIteration as I, EqualKOnCostOptions as Ia, createWorktree as Ic, Strategy as Ii, DelegateFeedbackArgs as Il, EvolutionArchiveNode as In, LeaderboardSpec as Io, AcquireOptions as Ir, QuestionOption as Is, collectDelivered as It, capDelegationTrace as Iu, ConcurrencyCaps as J, PanelSpec as Ja, CoderDelegate as Jc, runAgentic as Ji, DelegationHistoryEntry as Jl, AuthorStrategyOptions as Jn, Interval as Jo, definePersona as Jr, DELEGATE_INPUT_SCHEMA as Js, AuthoredProfile as Jt, ConfigError as Ju, createWorktreeCliExecutor as K, Panel as Ka, InMemoryFeedbackStore as Kc, depthStrategy as Ki, DelegationFeedbackSnapshot as Kl, runStrategyEvolution as Kn, AxisScoresOf as Ko, createShapeRegistry as Kr, createMcpServer as Ks, createBudgetPool as Kt, AgentEvalErrorCode as Ku, InMemoryRunContext as L, EqualKVerdict as La, removeWorktree as Lc, StrategyArtifacts as Li, DelegateFeedbackResult as Ll, EvolutionAuthor as Ln, defineLeaderboard as Lo, acquireSandbox as Lr, QuestionPolicy as Ls, pickBestDelivered as Lt, composeLoopTraceEmitters as Lu, supervise as M, CorpusFilter as Ma, GitRunner as Mc, CorpusReadbackOptions as Mi, hashIdempotencyInput as Ml, collectAgentTurn as Mn, LeaderboardIterationInfo as Mo, sumSandboxUsage as Mr, MakeWorkerAgent as Ms, FinalizeContext as Mt, DelegationTraceCaps as Mu, workerFromBackend as N, CorpusRecord as Na, RemoveWorktreeOptions as Nc, RunAgenticOptions as Ni, DelegateCodeArgs as Nl, streamAgentTurn as Nn, LeaderboardRunContext as No, CriuCapableClient as Nr, Question as Ns, FinalizerSettled as Nt, DelegationTraceCollector as Nu, TrajectoryAnalysis as O, renderReport as Oa, WorktreeProfileMaterializationReceipt as Oc, AgenticSurface as Oi, DelegationTaskQueue as Ol, AgentTurnBackend as On, LeaderboardBenchScore as Oo, createSandboxToolPartState as Or, CoordinationTools as Os, noProgressFor as Ot, loopEventToOtelSpan as Ou, ScopeArgs as P, EqualKArm as Pa, WorktreeHandle as Pc, ShotPersona as Pi, DelegateCodeConfig as Pl, ChampionPick as Pn, LeaderboardScenario as Po, SandboxCapabilities as Pr, QuestionDecision as Ps, SupervisorFinalizer as Pt, DelegationTraceSpan as Pu, RollingDispatchOptions as Q, RenderCorpusToInstructions as Qa, DetachedSessionDelegateOptions as Qc, LoopDispatchOptions as Qi, DelegationResultPayload as Ql, strategyAuthorContract as Qn, PairwiseOptions as Qo, renderCorpusToInstructions as Qr, DelegateResult as Qs, assessAuthoredProfile as Qt, RuntimeRunStateError as Qu, InMemoryRunContextOptions as R, Fanout as Ra, DeliverableSpec as Rc, StrategyCtx as Ri, DelegateResearchArgs as Rl, EvolutionBandInfo as Rn, CompletionAnalyst as Ro, ResolveSandboxClientOptions as Rr, QuestionRecord as Rs, runFinalizer as Rt, createDelegationTraceCollector as Ru, SurfaceWorkerOut as S, harvestCorpus as Sa, PiSeam as Sc, BenchmarkTaskRow as Si, DelegationArgs as Sl, officialChecksFromMeta as Sn, RunPersonified as So, ForkCapableBox as Sr, WaterfallReport as Ss, StopDecision as St, RuntimeEventOtelOptions as Su, AuthoredHarness as T, ObserveOptions as Ta, WorktreeCheckRunner as Tc, runBenchmark as Ti, DelegationResumeDriver as Tl, selectBestIndex as Tn, ShapeContext as To, SessionCapableBox as Tr, AnalystFindingEvent as Ts, allWorkersStalled as Tt, buildRuntimeEventOtelSpans as Tu, patchDelivered as U, LoopUntil as Ua, McpTransport as Uc, adaptiveRefine as Ui, DelegateUiAuditResult as Ul, StrategyEvolutionConfig as Un, deterministicCompletion as Uo, equalKOnCost as Ur, McpServer as Us, BudgetPool as Ut, FileDelegationStoreOptions as Uu, createInMemoryRunContext as V, FanoutWinnerSelector as Va, JsonRpcResponse as Vc, StrategyShotResult as Vi, DelegateUiAuditArgs as Vl, EvolutionReport as Vn, CompletionVerdict as Vo, PromotionVerdict as Vr, WorkerWatchOptions as Vs, FileCoordinationLog as Vt, DelegationStore as Vu, WorktreeCliExecutorOptions as W, LoopUntilSpec as Wa, FeedbackEvent as Wc, breadthStrategy as Wi, DelegateUiAuditRoute as Wl, discriminatingMeans as Wn, sentinelCompletion as Wo, trajectoryReport as Wr, McpServerOptions as Ws, BudgetReadout as Wt, InMemoryDelegationStore as Wu, DispatchStopReason as X, Pipeline as Xa, CoderReviewer as Xc, sampleThenRefine as Xi, DelegationProfile as Xl, assertStrategyContract as Xn, LeaderboardOptions as Xo, FileCorpus as Xr, DelegateArgs as Xs, ProfileRichnessThresholds as Xt, NotFoundError as Xu, DispatchReport as Y, PanelVerdict as Ya, CoderReview as Yc, sample as Yi, DelegationHistoryResult as Yl, AuthoredStrategy as Yn, Leaderboard as Yo, runPersonified as Yr, DELEGATE_TOOL_NAME as Ys, ProfileRichness as Yt, JudgeError as Yu, DispatchUnit as Z, PipelineStage as Za, DelegateRunCtx as Zc, LoopCampaignDispatchOptions as Zi, DelegationProgress as Zl, authorStrategy as Zn, LeaderboardRow as Zo, InMemoryCorpus as Zr, DelegateHandlerOptions as Zs, asAuthoredProfile as Zt, PlannerError as Zu, VerifierEnvironmentOptions as _, InProcessSandboxClientOptions as _a, createSteerableSandboxSession as _c, replaySpawnTree as _d, BenchmarkCell as _i, createDetachedTurnResumeDriver as _l, composeCheckSources as _n, LoopShape as _o, SandboxRun as _r, areaUnderCurve as _s, PlateauOptions as _t, LoopSpanNode as _u, SandboxInstance$1 as a, runAgentRounds as aa, ExecutorConfig as ac, PublishOptions as ad, verify as ai, DelegationExecutor as al, CheckRunContext as an, TrajectoryReport as ao, LocalMcpMaterialization as ar, renderLeaderboardMarkdown as as, delegate as at, ResearchSource as au, SuperviseSurfaceResult as b, HarvestFailure as ba, createInbox as bc, BenchmarkReport as bi, parseDetachedSessionRef as bl, filterAuthoredAsserts as bn, PersonaContext as bo, openSandboxRun as br, renderAnytimeTable as bs, ProgressTrackerOptions as bt, OtelExporter as bu, GitWorkspaceOptions as c, localSandboxClient as ca, RouterToolsSeam as cc, defaultToolDetectors as cd, RegistryAnalyzeProjection as ci, SiblingSandboxExecutorOptions as cl, CheckSourceCtx as cn, Verify as co, McpToolDescriptor as cr, AuditIntentInput as cs, SupervisorProfile as ct, TraceContext as cu, WorkspaceCommit as d, mcpSecretEnvMetadataKey as da, createExecutor as dc, FileSpawnJournal as dd, createScopeAnalyst as di, DetachedSessionRefParts as dl, StructuralRolloutMessage as dn, WidenDecision as do, connectStdioMcp as dr, auditIntent as ds, serveCoordinationMcp as dt, traceContextToEnv as du, loopCampaignDispatch as ea, validateDelegateArgs as ec, CoderOutput as ed, flatWidenGate as ei, SettleDetachedCoderTurnOptions as el, defaultProfileRichnessThresholds as en, ScopeAnalyst as eo, DumbDriverOptions as er, ProfileKeyOf as es, freeSlots as et, DelegationStatusArgs as eu, WorkspaceRun as f, resolveSecretEnv as fa, createExecutorRegistry as fc, InMemoryResultBlobStore as fd, registryScopeAnalyst as fi, DetachedTurn as fl, StructuralRolloutPolicy as fn, WidenLineage as fo, materializeLocalMcp as fr, defaultAuditorInstruction as fs, DriverAgentOptions as ft, EvalRunEvent as fu, runInWorkspace as g, InProcessPromptCtx as ga, SteerableSandboxSession as gc, pendingWaits as gd, sanitizeMcpToolSchema as gi, RunDetachedTurnOptions as gl, compareCheckOutcomes as gn, DefinePersonaInput as go, OpenSandboxRunPromptOptions as gr, anytimeReport as gs, NoProgressForOptions as gt, INTELLIGENCE_WIRE_VERSION as gu, localShell as h, InProcessOnPrompt as ha, SteerableSandboxArgs as hc, materializeTreeView as hd, createMcpEnvironment as hi, DriveTurnTick as hl, canDisplace as hn, DefinePersona as ho, OpenSandboxRunOptions as hr, AnytimeTaskCurve as hs, AllWorkersStalledOptions as ht, EvalRunsExportResult as hu, SandboxEvent$1 as i, defaultSelectWinner as ia, CliWorktreeSeam as ic, EventBus as id, selectValidWinner as ii, settleDetachedCoderTurn as il, CheckOutcome as in, TrajectoryNode as io, naiveDriver as ir, renderLeaderboardHtml as is, defaultDelegateBudget as it, ResearchOutputShape as iu, SuperviseOptions as j, Corpus as ja, DiffResult as jc, ArtifactHandle as ji, SubmitOutput as jl, StreamAgentTurnOptions as jn, LeaderboardFlagSpec as jo, mapSandboxToolEvent as jr, DownMessageEvent as js, DeliveredOutput as jt, DELEGATION_TRACE_MAX_SPANS as ju, analyzeTrace as k, AssertTraceDerivedFindings as ka, CreateWorktreeOptions as kc, AgenticTask as ki, DelegationTaskQueueOptions as kl, AgentTurnUsage as kn, LeaderboardBenchTask as ko, extractLlmCallEvent as kr, CoordinationToolsOptions as ks, plateau as kt, CappedDelegationTrace as ku, Shell as l, KeyProvider as la, SandboxSeam as lc, watchTrace as ld, assertTraceDerivedFindings as li, createFleetWorkspaceExecutor as ll, RepairStop as ln, VerifySpec as lo, StdioMcpConnection as lr, AuditIntentOptions as ls, supervisorAgent as lt, createPropagatingTraceEmitter as lu, jjWorkspace as m, inlineSandboxClient as ma, SandboxSteeringOptions as mc, contentAddress as md, McpEnvironmentOptions as mi, DriveTurnCapableBox as ml, VisibleCheck as mn, WinnerStrategy as mo, OpenSandboxRunBeforeStartContext as mr, AnytimeStrategySummary as ms, finalizeBestDelivered as mt, EvalRunsExportConfig as mu, AnalystFinding$1 as n, RunAgentRoundsOptions as na, CliSeam as nc, BusRecord as nd, panel as ni, coderTaskFromArgs as nl, supervisorInstructions as nn, ScopeWidenGate as no, SteeringDecision as nr, leaderboard as ns, rollingDispatch as nt, FeedbackRating as nu, computeFindingId$1 as o, runLoop as oa, ProviderSeam as oc, createEventBus as od, widen as oi, FleetHandle as ol, CheckRunner as on, TrajectoryReportFn as oo, MaterializeLocalMcpOptions as or, renderLeaderboardSvg as os, DriveHarness as ot, UiAuditLensFilter as ou, gitWorkspace as p, secretEnvOfMcpServer as pa, DEFAULT_SANDBOX_STEERING_MAX_TURNS as pc, InMemorySpawnJournal as pd, McpEndpoint as pi, DetachedTurnResumeDriverOptions as pl, StructuralRolloutResult as pn, WidenSpec as po, Deliverable as pr, AnytimeReport as ps, driverAgent as pt, EvalRunGeneration as pu, assertModelAllowed as q, PanelJudge as qa, eventToSnapshot as qc, refine as qi, DelegationHistoryArgs as ql, selectChampion as qn, GroupOf as qo, registerShape as qr, DELEGATE_DESCRIPTION as qs, spendFromUsageEvents as qt, BackendTransportError as qu, CreateSandboxOptions$1 as r, RunLoopOptions as ra, CliWorktreeBridgeSeam as rc, BusStats as rd, pipeline as ri, detachedSessionDelegate as rl, CheckExecChannel as rn, SteerContext as ro, dumbDriver as rr, pairwiseSignificance as rs, DelegateOptions as rt, FeedbackRefersTo as ru, makeFinding$1 as s, LocalSandboxClientOptions as sa, RouterSeam as sc, WatchTraceOptions as sd, CreateScopeAnalystOptions as si, FleetWorkspaceExecutorOptions as sl, CheckSource as sn, TrajectoryReportOptions as so, McpSpawnFault as sr, renderPairwiseMarkdown as ss, SupervisorAgentDeps as st, UiAuditorDelegationOutput as su, AgentProfile$2 as t, loopDispatch as ta, BridgeSeam as tc, BusEvent as td, loopUntil as ti, UiAuditorDelegate as tl, profileRichnessFinding as tn, ScopeAnalyzeInput as to, NaiveDriverOptions as tr, ScoreOf as ts, queueOf as tt, DelegationStatusResult as tu, Workspace as u, envKeyProvider as ua, cliWorktreeExecutor as uc, FileResultBlobStore as ud, buildSteerContext as ui, createSiblingSandboxExecutor as ul, StructuralRolloutConfig as un, Widen as uo, StdioMcpServerSpec as ur, IntentAudit as us, CoordinationMcpHandle as ut, readTraceContextFromEnv as uu, createVerifierEnvironment as v, inProcessSandboxClient as va, Inbox as vc, BenchmarkConfig as vi, detachedTurnEvents as vl, defaultExtractCandidate as vn, Outcome as vo, SandboxRunAbortError as vr, bestSoFar as vs, ProgressSample as vt, OtelAttribute as vu, superviseSurface as w, ObserveInput as wa, piSeamKey as wc, printBenchmarkReport as wi, DelegationResumeContext as wl, sandboxCheckRunner as wn, ShapeBudget as wo, SandboxLineageHandle as wr, createWaterfallCollector as ws, allOf as wt, buildLoopSpanNodes as wu, SurfaceWorkerConfig as x, HarvestReport as xa, PI_RUNTIME as xc, BenchmarkStrategySummary as xi, runDetachedTurn as xl, modelAuthoredChecks as xn, PersonaExecutors as xo, CheckpointCapableBox as xr, WaterfallCollector as xs, ProgressView as xt, OtelSpan as xu, SuperviseSurfaceOptions as y, HarvestCorpusOptions as ya, InboxMessage as yc, BenchmarkLift as yi, formatDetachedSessionRef as yl, defaultStructuralRolloutPolicy as yn, Persona as yo, TurnResult as yr, plateauLength as ys, ProgressTracker as yt, OtelExportConfig as yu, RunContext as z, FanoutOptions as za, gateOnDeliverable as zc, StrategyMessage as zi, DelegateResearchConfig as zl, EvolutionCandidate as zn, CompletionEvidence as zo, resolveSandboxClient as zr, QuestionUrgency as zs, runTree as zt, DelegationPersistenceError as zu };
-//# sourceMappingURL=index-CFJ_1m1U.d.ts.map
+export { supervisorRunsRoot as $, Corpus as $a, DiffResult as $c, RunAgenticOptions as $i, DelegateCodeArgs as $l, streamAgentTurn as $n, LeaderboardFlagSpec as $o, CriuCapableClient as $r, DownMessageEvent as $s, FinalizerSettled as $t, DelegationTraceCollector as $u, GitWorkspaceOptions as A, ResolvedMcpServerLaunch as Aa, RouterToolsSeam as Ac, DeliverableSpec as Ad, buildSteerContext as Ai, createSiblingSandboxExecutor as Al, StructuralRolloutConfig as An, Verify as Ao, StdioMcpServerSpec as Ar, AuditIntentInput as As, CoordinationMcpHandle as At, readTraceContextFromEnv as Au, analyzeTrace as B, inProcessSandboxClient as Ba, Inbox as Bc, BenchmarkReport as Bi, parseDetachedSessionRef as Bl, filterAuthoredAsserts as Bn, Outcome as Bo, openSandboxRun as Br, bestSoFar as Bs, ProgressTrackerOptions as Bt, OtelExporter as Bu, closingWorkerNote as C, RunLoopOptions as Ca, BridgeSeam as Cc, BusStats as Cd, pipeline as Ci, detachedSessionDelegate as Cl, CheckExecChannel as Cn, ScopeAnalyzeInput as Co, dumbDriver as Cr, ScoreOf as Cs, DelegateOptions as Ct, FeedbackRefersTo as Cu, UntrackedCopyStats as D, LocalSandboxClientOptions as Da, ExecutorConfig as Dc, WatchTraceOptions as Dd, CreateScopeAnalystOptions as Di, FleetWorkspaceExecutorOptions as Dl, CheckSource as Dn, TrajectoryReport as Do, McpSpawnFault as Dr, renderLeaderboardMarkdown as Ds, SupervisorAgentDeps as Dt, UiAuditorDelegationOutput as Du, CopyOptions as E, runLoop as Ea, CliWorktreeSeam as Ec, createEventBus as Ed, widen as Ei, FleetHandle as El, CheckRunner as En, TrajectoryNode as Eo, MaterializeLocalMcpOptions as Er, renderLeaderboardHtml as Es, DriveHarness as Et, UiAuditLensFilter as Eu, gitWorkspace as F, secretEnvOfMcpServer as Fa, DEFAULT_SANDBOX_STEERING_MAX_TURNS as Fc, InMemorySpawnJournal as Fd, createMcpEnvironment as Fi, DriveTurnTick as Fl, canDisplace as Fn, WidenSpec as Fo, OpenSandboxRunOptions as Fr, AnytimeReport as Fs, AllWorkersStalledOptions as Ft, EvalRunsExportResult as Fu, ScopeArgs as G, Observation as Ga, piExecutor as Gc, runBenchmark as Gi, DelegationResumeDriver as Gl, selectBestIndex as Gn, RunPersonifiedOptions as Go, SessionCapableBox as Gr, WaterfallSpan as Gs, allWorkersStalled as Gt, buildRuntimeEventOtelSpans as Gu, SuperviseOptions as H, HarvestFailure as Ha, createInbox as Hc, BenchmarkTaskRow as Hi, DelegationArgs as Hl, officialChecksFromMeta as Hn, PersonaContext as Ho, ForkCapableBox as Hr, renderAnytimeTable as Hs, StopDecision as Ht, RuntimeEventOtelOptions as Hu, jjWorkspace as I, inlineSandboxClient as Ia, SandboxSteeringOptions as Ic, contentAddress as Id, sanitizeMcpToolSchema as Ii, RunDetachedTurnOptions as Il, compareCheckOutcomes as In, WinnerStrategy as Io, OpenSandboxRunPromptOptions as Ir, AnytimeStrategySummary as Is, NoProgressForOptions as It, INTELLIGENCE_WIRE_VERSION as Iu, WorkerSteerRequest as J, defaultAnalystInstruction as Ja, WorktreeCommandResult as Jc, AgenticSurface as Ji, DelegationTaskQueue as Jl, AgentTurnBackend as Jn, ShapeRegistry as Jo, createSandboxToolPartState as Jr, AnalystRegistry as Js, noProgressFor as Jt, loopEventToOtelSpan as Ju, createScope as K, ObserveInput as Ka, piSeamKey as Kc, AgenticOptions as Ki, DelegationResumeTick as Kl, structuralRollout as Kn, ShapeBudget as Ko, createSandboxLineage as Kr, createWaterfallCollector as Ks, anyOf as Kt, createOtelExporter as Ku, localShell as L, InProcessOnPrompt as La, SteerableSandboxArgs as Lc, materializeTreeView as Ld, BenchmarkCell as Li, createDetachedTurnResumeDriver as Ll, composeCheckSources as Ln, DefinePersona as Lo, SandboxRun as Lr, AnytimeTaskCurve as Ls, PlateauOptions as Lt, LoopSpanNode as Lu, Workspace as M, mcpSecretEnvMetadataKey as Ma, cliWorktreeExecutor as Mc, FileResultBlobStore as Md, registryScopeAnalyst as Mi, DetachedTurn as Ml, StructuralRolloutPolicy as Mn, Widen as Mo, materializeLocalMcp as Mr, IntentAudit as Ms, DriverAgentOptions as Mt, EvalRunEvent as Mu, WorkspaceCommit as N, resolveMcpServerLaunch as Na, createExecutor as Nc, FileSpawnJournal as Nd, McpEndpoint as Ni, DetachedTurnResumeDriverOptions as Nl, StructuralRolloutResult as Nn, WidenDecision as No, Deliverable as Nr, auditIntent as Ns, driverAgent as Nt, EvalRunGeneration as Nu, copyUntrackedIntoClone as O, localSandboxClient as Oa, ProviderSeam as Oc, defaultToolDetectors as Od, RegistryAnalyzeProjection as Oi, SiblingSandboxExecutorOptions as Ol, CheckSourceCtx as On, TrajectoryReportFn as Oo, McpToolDescriptor as Or, renderLeaderboardSvg as Os, SupervisorProfile as Ot, TraceContext as Ou, WorkspaceRun as P, resolveSecretEnv as Pa, createExecutorRegistry as Pc, InMemoryResultBlobStore as Pd, McpEnvironmentOptions as Pi, DriveTurnCapableBox as Pl, VisibleCheck as Pn, WidenLineage as Po, OpenSandboxRunBeforeStartContext as Pr, defaultAuditorInstruction as Ps, finalizeBestDelivered as Pt, EvalRunsExportConfig as Pu, supervisorRunDir as Q, CombinatorShape as Qa, DiffOptions as Qc, CorpusReadbackOptions as Qi, hashIdempotencyInput as Ql, collectAgentTurn as Qn, LeaderboardBenchmarkAdapter as Qo, sumSandboxUsage as Qr, DEFAULT_AWAIT_EVENT_TIMEOUT_MS as Qs, FinalizeContext as Qt, DelegationTraceCaps as Qu, runInWorkspace as R, InProcessPromptCtx as Ra, SteerableSandboxSession as Rc, pendingWaits as Rd, BenchmarkConfig as Ri, detachedTurnEvents as Rl, defaultExtractCandidate as Rn, DefinePersonaInput as Ro, SandboxRunAbortError as Rr, anytimeReport as Rs, ProgressSample as Rt, OtelAttribute as Ru, WorkerEvidenceInput as S, RunAgentRoundsOptions as Sa, validateDelegateArgs as Sc, BusRecord as Sd, panel as Si, coderTaskFromArgs as Sl, supervisorInstructions as Sn, ScopeAnalyst as So, SteeringDecision as Sr, ProfileKeyOf as Ss, rollingDispatch as St, FeedbackRating as Su, settledWorkerOut as T, runAgentRounds as Ta, CliWorktreeBridgeSeam as Tc, PublishOptions as Td, verify as Ti, DelegationExecutor as Tl, CheckRunContext as Tn, SteerContext as To, LocalMcpMaterialization as Tr, pairwiseSignificance as Ts, delegate as Tt, ResearchSource as Tu, supervise as U, HarvestReport as Ua, PI_RUNTIME as Uc, Environment as Ui, DelegationRecord as Ul, resolveEntrySymbol as Un, PersonaExecutors as Uo, SandboxLineage as Ur, WaterfallCollector as Us, StopRule as Ut, buildLoopOtelSpans as Uu, createSupervisor as V, HarvestCorpusOptions as Va, InboxMessage as Vc, BenchmarkStrategySummary as Vi, runDetachedTurn as Vl, modelAuthoredChecks as Vn, Persona as Vo, CheckpointCapableBox as Vr, plateauLength as Vs, ProgressView as Vt, OtelSpan as Vu, workerFromBackend as W, harvestCorpus as Wa, PiSeam as Wc, printBenchmarkReport as Wi, DelegationResumeContext as Wl, sandboxCheckRunner as Wn, RunPersonified as Wo, SandboxLineageHandle as Wr, WaterfallReport as Ws, allOf as Wt, buildLoopSpanNodes as Wu, readWorkerSteerRequests as X, renderReport as Xa, WorktreeProfileMaterializationReceipt as Xc, AgenticTool as Xi, SubmitInput as Xl, CollectedAgentTurn as Xn, LeaderboardBenchScore as Xo, mapSandboxEvent as Xr, CoordinationTools as Xs, sampleFromSettled as Xt, DELEGATION_TRACE_MAX_BYTES as Xu, legacySupervisorRunDir as Y, observe as Ya, WorktreeHarnessResult as Yc, AgenticTask as Yi, DelegationTaskQueueOptions as Yl, AgentTurnUsage as Yn, DefinedLeaderboard as Yo, extractLlmCallEvent as Yr, CoordinationEvent as Ys, plateau as Yt, CappedDelegationTrace as Yu, safeWorkerFile as Z, AssertTraceDerivedFindings as Za, CreateWorktreeOptions as Zc, ArtifactHandle as Zi, SubmitOutput as Zl, StreamAgentTurnOptions as Zn, LeaderboardBenchTask as Zo, mapSandboxToolEvent as Zr, CoordinationToolsOptions as Zs, DeliveredOutput as Zt, DELEGATION_TRACE_MAX_SPANS as Zu, WorktreeFanoutOptions as _, LoopCampaignDispatchOptions as _a, DELEGATE_TOOL_NAME as _c, PlannerError as _d, InMemoryCorpus as _i, DelegateRunCtx as _l, asAuthoredProfile as _n, PanelVerdict as _o, authorStrategy as _r, Leaderboard as _s, DispatchUnit as _t, DelegationProgress as _u, SandboxInstance$1 as a, StrategyMessage as aa, QuestionPolicy as ac, DelegationPersistenceError as ad, resolveSandboxClient as ai, removeWorktree as al, runTree as an, EqualKVerdict as ao, EvolutionCandidate as ar, defineLeaderboard as as, RunContext as at, DelegateResearchConfig as au, NOTE_MAX_CHARS as b, loopCampaignDispatch as ba, DelegateResult as bc, CoderOutput as bd, flatWidenGate as bi, SettleDetachedCoderTurnOptions as bl, defaultProfileRichnessThresholds as bn, RenderCorpusToInstructions as bo, DumbDriverOptions as br, PairwiseOptions as bs, freeSlots as bt, DelegationStatusArgs as bu, VerifierEnvironmentOptions as c, SurfaceScore as ca, SettledWorker as cc, FileDelegationStore as cd, promotionGate as ci, McpToolDescriptor$1 as cl, PriorCoordination as cn, FanoutSynthesis as co, ReproductionCheck as cr, CompletionPolicy as cs, PatchDeliverableOptions as ct, DelegateUiAuditConfig as cu, SuperviseSurfaceResult as d, defineStrategy as da, McpServer as dc, AgentEvalError$1 as dd, builtinShapes as di, FeedbackStore as dl, ReservationTicket as dn, LoopUntil as do, pickChampion as dr, deterministicCompletion as ds, WorktreePatchArtifact as dt, DelegationError as du, ShotPersona as ea, MakeWorkerAgent as ec, DelegationTraceSpan as ed, SandboxCapabilities as ei, GitRunner as el, SupervisorFinalizer as en, CorpusFilter as eo, ChampionPick as er, LeaderboardIterationInfo as es, workerInboxFile as et, DelegateCodeConfig as eu, SurfaceWorkerConfig as f, depthStrategy as fa, McpServerOptions as fc, AgentEvalErrorCode as fd, createShapeRegistry as fi, InMemoryFeedbackStore as fl, createBudgetPool as fn, LoopUntilSpec as fo, runStrategyEvolution as fr, sentinelCompletion as fs, createWorktreeCliExecutor as ft, DelegationFeedbackSnapshot as fu, AuthoredHarness as g, sampleThenRefine as ga, DELEGATE_INPUT_SCHEMA as gc, NotFoundError as gd, FileCorpus as gi, CoderReviewer as gl, ProfileRichnessThresholds as gn, PanelSpec as go, assertStrategyContract as gr, Interval as gs, DispatchStopReason as gt, DelegationProfile as gu, superviseSurface as h, sample as ha, DELEGATE_DESCRIPTION as hc, JudgeError as hd, runPersonified as hi, CoderReview as hl, ProfileRichness as hn, PanelJudge as ho, AuthoredStrategy as hr, GroupOf as hs, DispatchReport as ht, DelegationHistoryResult as hu, SandboxEvent$1 as i, StrategyCtx as ia, QuestionOption as ic, createDelegationTraceCollector as id, ResolveSandboxClientOptions as ii, createWorktree as il, runFinalizer as in, EqualKOnCostOptions as io, EvolutionBandInfo as ir, LeaderboardSpec as is, InMemoryRunContextOptions as it, DelegateResearchArgs as iu, Shell as j, envKeyProvider as ja, SandboxSeam as jc, gateOnDeliverable as jd, createScopeAnalyst as ji, DetachedSessionRefParts as jl, StructuralRolloutMessage as jn, VerifySpec as jo, connectStdioMcp as jr, AuditIntentOptions as js, serveCoordinationMcp as jt, traceContextToEnv as ju, withUntrackedArtifacts as k, KeyProvider as ka, RouterSeam as kc, watchTrace as kd, assertTraceDerivedFindings as ki, createFleetWorkspaceExecutor as kl, RepairStop as kn, TrajectoryReportOptions as ko, StdioMcpConnection as kr, renderPairwiseMarkdown as ks, supervisorAgent as kt, createPropagatingTraceEmitter as ku, createVerifierEnvironment as l, adaptiveRefine as la, WorkerWatchOptions as lc, FileDelegationStoreOptions as ld, equalKOnCost as li, McpTransport as ll, BudgetPool as ln, FanoutWinnerSelector as lo, StrategyEvolutionConfig as lr, CompletionVerdict as ls, patchDelivered as lt, DelegateUiAuditResult as lu, failuresAnalyst as m, runAgentic as ma, createMcpServer as mc, ConfigError as md, definePersona as mi, CoderDelegate as ml, AuthoredProfile as mn, Panel as mo, AuthorStrategyOptions as mr, AxisScoresOf as ms, ConcurrencyCaps as mt, DelegationHistoryEntry as mu, AnalystFinding$1 as n, Strategy as na, QuestionDecision as nc, capDelegationTrace as nd, AcquireOptions as ni, WorktreeHandle as nl, collectDelivered as nn, EqualKArm as no, EvolutionArchiveNode as nr, LeaderboardScenario as ns, writeWorkerSteer as nt, DelegateFeedbackArgs as nu, computeFindingId$1 as o, StrategyResult as oa, QuestionRecord as oc, DelegationStateCorruptError as od, PromotionGateOptions as oi, JsonRpcMessage as ol, CoordinationLog as on, Fanout as oo, EvolutionGeneration as or, CompletionAnalyst as os, createFileRunContext as ot, DelegateResearchResult as ou, SurfaceWorkerOut as p, refine as pa, createInProcessTransport as pc, BackendTransportError as pd, registerShape as pi, eventToSnapshot as pl, spendFromUsageEvents as pn, LoopUntilState as po, selectChampion as pr, stopSentinel as ps, assertModelAllowed as pt, DelegationHistoryArgs as pu, settledToIteration as q, ObserveOptions as qa, WorktreeCheckRunner as qc, AgenticRunResult as qi, DelegationRunContext as ql, visibleCheckScore as qn, ShapeContext as qo, SandboxToolPartState as qr, AnalystFindingEvent as qs, createProgressTracker as qt, exportEvalRuns as qu, CreateSandboxOptions$1 as r, StrategyArtifacts as ra, QuestionLevel as rc, composeLoopTraceEmitters as rd, acquireSandbox as ri, captureWorktreeDiff as rl, pickBestDelivered as rn, EqualKOnCost as ro, EvolutionAuthor as rr, LeaderboardScore as rs, InMemoryRunContext as rt, DelegateFeedbackResult as ru, makeFinding$1 as s, StrategyShotResult as sa, QuestionUrgency as sc, DelegationStore as sd, PromotionVerdict as si, JsonRpcResponse as sl, FileCoordinationLog as sn, FanoutOptions as so, EvolutionReport as sr, CompletionEvidence as ss, createInMemoryRunContext as st, DelegateUiAuditArgs as su, AgentProfile$2 as t, ShotSpec as ta, Question as tc, buildDelegationTraceSpans as td, probeSandboxCapabilities as ti, RemoveWorktreeOptions as tl, bestDelivered as tn, CorpusRecord as to, ChampionPolicy as tr, LeaderboardRunContext as ts, workerInboxFileFromEventDir as tt, DelegateCodeResult as tu, SuperviseSurfaceOptions as u, breadthStrategy as ua, createCoordinationTools as uc, InMemoryDelegationStore as ud, trajectoryReport as ui, FeedbackEvent as ul, BudgetReadout as un, FlatWidenGate as uo, discriminatingMeans as ur, completionAuthorizes as us, WorktreeCliExecutorOptions as ut, DelegateUiAuditRoute as uu, worktreeFanout as v, LoopDispatchOptions as va, DelegateArgs as vc, RuntimeRunStateError as vd, renderCorpusToInstructions as vi, DetachedSessionDelegateOptions as vl, assessAuthoredProfile as vn, Pipeline as vo, strategyAuthorContract as vr, LeaderboardOptions as vs, RollingDispatchOptions as vt, DelegationResultPayload as vu, composeWorkerEvidence as w, defaultSelectWinner as wa, CliSeam as wc, EventBus as wd, selectValidWinner as wi, settleDetachedCoderTurn as wl, CheckOutcome as wn, ScopeWidenGate as wo, naiveDriver as wr, leaderboard as ws, defaultDelegateBudget as wt, ResearchOutputShape as wu, VERIFY_TAIL_CHARS as x, loopDispatch as xa, createDelegateHandler as xc, BusEvent as xd, loopUntil as xi, UiAuditorDelegate as xl, profileRichnessFinding as xn, RenderCorpusToInstructionsOptions as xo, NaiveDriverOptions as xr, PairwiseVerdict as xs, queueOf as xt, DelegationStatusResult as xu, EVIDENCE_MAX_CHARS as y, LoopOptionsForDispatch as ya, DelegateHandlerOptions as yc, ValidationError as yd, fanout as yi, DetachedWinnerSelection as yl, authoredWorker as yn, PipelineStage as yo, ApplyContinuation as yr, LeaderboardRow as ys, effectiveConcurrency as yt, DelegationStatus as yu, TrajectoryAnalysis as z, InProcessSandboxClientOptions as za, createSteerableSandboxSession as zc, replaySpawnTree as zd, BenchmarkLift as zi, formatDetachedSessionRef as zl, defaultStructuralRolloutPolicy as zn, LoopShape as zo, TurnResult as zr, areaUnderCurve as zs, ProgressTracker as zt, OtelExportConfig as zu };
+//# sourceMappingURL=index-DlLPNELY.d.ts.map

package/dist/{index-HsQm1Rrr.d.ts → index-sLuBoGud.d.ts}

@@ -1,14 +1,14 @@
 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-BaAdfJKT.js";
-import { o as ImprovementProposalSource } from "./types-CfGKhIuj.js";
+import { i as SurfaceImprovementEdit } from "./improvement-adapter-D5gwwoXQ.js";
+import { o as ImprovementProposalSource } from "./types-zWfqDjeL.js";
 import "./types-DnNGJ5Gz.js";
-import { Ju as ConfigError, fn as StructuralRolloutPolicy } from "./index-CFJ_1m1U.js";
+import { Mn as StructuralRolloutPolicy, md as ConfigError } from "./index-DlLPNELY.js";
 import { D as RuntimeTelemetryOptions, c as runLocalHarness, i as LocalHarness, y as ToolLoopChat } from "./local-harness-Dh8PJ0ot.js";
 import "./index-C-FYUuFG.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-BkasKlyd.js";
-import "./index-BwY61sh3.js";
-import "./loop-runner-bin-DUQF0bYz.js";
+import "./index-BmI2uxy5.js";
+import "./loop-runner-bin-vRo5TZt_.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";
@@ -541,4 +541,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-HsQm1Rrr.d.ts.map
+//# sourceMappingURL=index-sLuBoGud.d.ts.map