@tangle-network/agent-runtime 0.109.2 → 0.110.0

package/dist/{index-BwY61sh3.d.ts → index-C-Zn0VrN.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 { Et as SupervisorProfile, H as SuperviseOptions, Od as DeliverableSpec, Tc as ExecutorConfig } from "./index-D_OdNLe0.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-C-Zn0VrN.d.ts.map

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

package/dist/{index-HsQm1Rrr.d.ts → index-WODlt7iz.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 { An as StructuralRolloutPolicy, fd as ConfigError } from "./index-D_OdNLe0.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-C-Zn0VrN.js";
+import "./loop-runner-bin-BUm83y1g.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-WODlt7iz.d.ts.map