@tangle-network/agent-runtime 0.89.0 → 0.90.0

package/dist/{coordination-CuDLO8wj.d.ts → coordination-DxHduZg7.d.ts}

@@ -1,16 +1,234 @@
-import { E as ExecutorFactory, b as ExecutorRegistry, h as Spend, c as Agent, i as Scope, d as ResultBlobStore, B as Budget } from './types-Driepl87.js';
+import { E as ExecutorFactory, e as ExecutorRegistry, i as Spend, A as Agent, S as Scope, a as ResultBlobStore, B as Budget } from './types-DAJQRIUD.js';
 import { AgentProfile } from '@tangle-network/agent-interface';
 import { U as UiLens, a as UiFinding, C as CoderTask } from './substrate-DO2GHNg2.js';
-import { e as LoopTraceEmitter, c as LoopTraceEvent, S as SandboxClient, A as AgentRunSpec, E as ExecCtx } from './types-ESeMOj94.js';
-import { SandboxEvent, SandboxInstance, BackendType } from '@tangle-network/sandbox';
+import { S as SandboxClient, E as ExecCtx, e as LoopTraceEmitter, c as LoopTraceEvent, A as AgentRunSpec } from './types-Dnk189QA.js';
+import { BackendType, SandboxEvent, SandboxInstance } from '@tangle-network/sandbox';
 import { AgentEvalError } from '@tangle-network/agent-eval';
-import { O as OtelExporter } from './otel-export-BKmNwiCb.js';
-import { T as ToolSpec, R as RouterConfig } from './router-client-r8y_VFVM.js';
-import { G as GitRunner, a as WorktreeCheckRunner, D as DeliverableSpec } from './worktree-harness-CX_McRLp.js';
+import { b as ToolSpec, R as RouterConfig } from './router-client-DJImUDlm.js';
+import { G as GitRunner, a as WorktreeCheckRunner, D as DeliverableSpec } from './completion-gate-BDaBP8dd.js';
 import { L as LocalHarness } from './local-harness-sI0S_XNA.js';
 import { ProviderExecutorOptions, AgentEnvironmentProviderRegistry } from './environment-provider.js';
 import { AgentEnvironmentProvider } from '@tangle-network/agent-interface/environment-provider';
 
+/**
+ *
+ * The leaf runtime — the built-in `Executor` IMPLEMENTATIONS behind the ONE
+ * open interface frozen in `./types`, plus the open resolver/registry that maps
+ * an `AgentSpec` to one of them OR accepts a bring-your-own executor verbatim.
+ *
+ * The interface is the extension point, not a closed `inline|sandbox|cli` union:
+ *   - router/inline : a direct OpenAI-compatible Router call, no box (one-shot).
+ *   - sandbox       : COMPOSES the existing `runLoop` kernel as a single-task
+ *                     leaf and surfaces its token/cost usage as `UsageEvent`s;
+ *                     forwards PR #150's optional `lineage` passthrough WITHOUT
+ *                     reinventing checkpoint/fork (streaming).
+ *   - cli           : a Halo/RLM subprocess; `budgetExempt` (no token accounting),
+ *                     excluded from the equal-k arms by construction (streaming).
+ * Every metered runtime reports through the SAME normalized `UsageEvent` channel
+ * so the conserved budget pool meters them identically. A user's own agent is
+ * first-class the moment it implements `Executor` — register it by name or
+ * pass it as `AgentSpec.executor`.
+ *
+ * Layering: `estimateCost`/`isModelPriced` are substrate primitives from
+ * `@tangle-network/agent-eval`; `runLoop`/`acquireSandbox` are runtime kernels
+ * from this package. No per-vendor adapters live here.
+ *
+ * @experimental
+ */
+
+/**
+ * Router/inline connection seam. A direct OpenAI-compatible Router endpoint —
+ * the cheapest leaf, no box, no tools. `model` overrides the profile's model
+ * hint when present; otherwise the profile's `model.default` is required.
+ */
+interface RouterSeam {
+    routerBaseUrl: string;
+    routerKey: string;
+    model?: string;
+}
+/**
+ * Sandbox executor seam. The `sandboxClient` the composed `runLoop` creates
+ * boxes through, plus the optional trace/run/lineage wiring forwarded into the
+ * loop. `lineage` is opaque here (PR #150's `RunLoopOptions.lineage`): forwarded
+ * forward-compatibly, never inspected — this executor does NOT reinvent
+ * checkpoint/fork.
+ */
+interface SandboxSeam {
+    sandboxClient: SandboxClient;
+    /** Forwarded into the composed `runLoop`'s `ctx` (trace emitter, run handle, etc.). */
+    loopCtx?: Partial<Omit<ExecCtx, 'sandboxClient' | 'signal'>>;
+    /** PR #150 `RunLoopOptions.lineage` passthrough — opaque; forwarded, not parsed. */
+    lineage?: unknown;
+    /** Hard cap on the composed loop's iterations. The budget pool reserves against
+     *  the spawn `Budget.maxIterations`; this is the leaf's own ceiling. Default 1. */
+    maxIterations?: number;
+}
+/** CLI subprocess seam. `bin` + `args` describe the Halo/RLM process to spawn. */
+interface CliSeam {
+    bin: string;
+    args?: string[];
+    /** Extra environment for the subprocess (merged over `process.env`). */
+    env?: Record<string, string>;
+    /** Working directory for the subprocess. */
+    cwd?: string;
+}
+/**
+ * cli-worktree seam. A supervisor-authored `AgentProfile` driving a local coding-harness CLI
+ * (claude / codex / opencode) on its own git worktree — the leaf `createWorktreeCliExecutor`
+ * named as data. `harness` + `repoRoot` + `taskPrompt` are required; the authored
+ * `profile.prompt.systemPrompt` + `profile.model.default` reach the harness via the §1.5
+ * `harnessInvocation` mapper. Everything else mirrors `WorktreeCliExecutorOptions`.
+ */
+interface CliWorktreeSeam {
+    repoRoot: string;
+    /** Local CLI harness transport. Omit when `bridge` is set. */
+    harness?: LocalHarness;
+    taskPrompt: string;
+    runId?: string;
+    baseRef?: string;
+    harnessTimeoutMs?: number;
+    testCmd?: string;
+    typecheckCmd?: string;
+    checkTimeoutMs?: number;
+    checkOutputCap?: number;
+    budgetExempt?: boolean;
+    /** Live cli-bridge transport inside the worktree. When set, the worktree leaf accepts
+     *  `deliver()` messages and resumes the same bridge session in this worktree cwd. */
+    bridge?: CliWorktreeBridgeSeam;
+    /** Test seam — forwarded to worktree helpers. */
+    runGit?: GitRunner;
+    /** Test seam — forwarded to verification checks. */
+    runCommand?: WorktreeCheckRunner;
+}
+interface CliWorktreeBridgeSeam {
+    bridgeUrl: string;
+    bridgeBearer: string;
+    /** Bridge model/harness id. Defaults to the profile's model hint when omitted. */
+    model?: string;
+    agentProfile?: Record<string, unknown>;
+    timeoutMs?: number;
+    /** Stable cli-bridge session id. Defaults to `bridge-worktree-${runId}`. */
+    sessionId?: string;
+    maxTurns?: number;
+}
+/**
+ * cli-bridge seam. A local OpenAI-compatible bridge that fronts harness CLIs
+ * (claude-code / opencode / kimi / pi) behind one HTTP surface; `model` doubles
+ * as the harness selector (e.g. `claude-code/sonnet`, `opencode/<provider>/<model>`).
+ * `agentProfile` is the bridge-dialect profile (metadata.disallowedTools, mcp)
+ * forwarded verbatim per request — how an arm disables native tools or injects
+ * a provider search MCP.
+ *
+ * The executor opens a RESUMABLE cli-bridge session — structurally identical to the
+ * sandbox executor's persistent box, just local. `sessionId` is the stable
+ * caller-owned id cli-bridge maps to the harness's internal conversation id; a
+ * follow-up steer/resume on the SAME id continues the SAME harness session (opencode
+ * `-s`, claude `--resume`, …). Omit it and the executor mints a stable one per spawn.
+ */
+interface BridgeSeam {
+    bridgeUrl: string;
+    bridgeBearer: string;
+    model: string;
+    /** Optional working directory forwarded to cli-bridge and persisted with the session. */
+    cwd?: string;
+    agentProfile?: Record<string, unknown>;
+    timeoutMs?: number;
+    /** Stable, caller-owned cli-bridge session id for harness-side resume. Defaults
+     *  to a freshly minted per-spawn id so each worker is its own resumable session. */
+    sessionId?: string;
+    /** Per-resume-turn inference cap before the worker settles on its last output.
+     *  Mirrors `routerToolsInlineExecutor.maxTurns`; default 200 (runaway backstop). */
+    maxTurns?: number;
+}
+/** Generic environment provider executor config. External packages implement
+ *  `AgentEnvironmentProvider`; this built-in wrapper lets `createExecutor`
+ *  consume them as backend data while preserving the existing usage channel. */
+interface ProviderSeam extends ProviderExecutorOptions {
+    provider: AgentEnvironmentProvider | string;
+    registry?: AgentEnvironmentProviderRegistry;
+}
+/**
+ * Router seam WITH tool use — the tool-using router backend. Same direct
+ * OpenAI-compatible endpoint as `RouterSeam`, but each turn passes `tools`; when
+ * the model emits tool_calls they run via `executeToolCall` ON THIS HOST and the
+ * results fold back as `tool` messages, repeating until the model answers without
+ * a tool or `maxTurns` is hit. A real agentic loop, OFF-BOX — no sandbox, so it
+ * is unaffected by a box's egress allowlist. One turn = one completion = the
+ * equal-compute unit. `executeToolCall` receives the task so per-task tool
+ * surfaces (e.g. a gym keyed by task) can dispatch correctly.
+ */
+interface RouterToolsSeam {
+    routerBaseUrl: string;
+    routerKey: string;
+    model?: string;
+    tools: ReadonlyArray<ToolSpec>;
+    executeToolCall: (name: string, args: Record<string, unknown>, task: unknown) => Promise<string>;
+    /** Online observer of each tool step — the seam a `DetectorMonitor` taps to watch the live pipe
+     *  (raise a `finding` when the worker loops/errors). Called after every tool call resolves, with
+     *  real per-call wall-clock (`startedAt`/`endedAt`/`durationMs`) so a push `TraceSource` can carry
+     *  non-zero span durations onto the unified timeline. */
+    onToolStep?: (step: {
+        toolName: string;
+        args: Record<string, unknown>;
+        status: 'ok' | 'error';
+        startedAt?: number;
+        endedAt?: number;
+        durationMs?: number;
+    }) => void;
+    /** Max inference turns. Default 200 (runaway backstop — set far above any
+     *  legitimate workflow). For tighter per-workflow limits use a cost budget
+     *  or wall-clock deadline at the call site. */
+    maxTurns?: number;
+}
+/**
+ * The leaf `createWorktreeCliExecutor` as a backend-as-data factory: a supervisor-authored
+ * `AgentProfile` driving claude / codex / opencode on its own worktree. `budgetExempt` like
+ * the other CLI leaves; the authored systemPrompt + model reach the harness via §1.5.
+ */
+declare const cliWorktreeExecutor: ExecutorFactory<unknown>;
+/**
+ * Config for {@link createExecutor}: the backend is DATA — the cost dial a profile,
+ * an experiment config, or a replay journal can name — not an import choice. Each
+ * variant carries its backend's seam (router/router-tools/bridge/cli/cli-worktree/sandbox).
+ */
+type ExecutorConfig = ({
+    backend: 'router';
+} & RouterSeam) | ({
+    backend: 'router-tools';
+} & RouterToolsSeam) | ({
+    backend: 'bridge';
+} & BridgeSeam) | ({
+    backend: 'cli';
+} & CliSeam) | ({
+    backend: 'cli-worktree';
+} & CliWorktreeSeam) | ({
+    backend: 'provider';
+} & ProviderSeam) | ({
+    backend: 'sandbox';
+    harness?: BackendType;
+} & SandboxSeam);
+/**
+ * The single built-in executor factory. Picks a leaf backend by data (`config.backend`),
+ * injects the matching seam, and delegates to that backend's built-in implementation.
+ * The `Executor` port stays OPEN: bring-your-own agents implement `Executor` directly
+ * and never pass through here. Use this (or `createExecutorRegistry`) instead of a
+ * per-vendor adapter or a closed `inline|sandbox|cli` switch — those bypass the
+ * `UsageEvent` reporting channel.
+ */
+declare function createExecutor(config: ExecutorConfig): ExecutorFactory<unknown>;
+/**
+ * The open resolver/registry. Pre-registers the three built-ins under their
+ * runtime tags (`'router'`, `'sandbox'`, `'cli'`) and accepts `register(name,
+ * factory)` for any additional runtime — and a BYO `AgentSpec.executor` resolves
+ * without touching the registry at all. NOT a closed switch; registration + BYO
+ * ARE the extension points.
+ *
+ * `resolve` precedence (frozen in `ExecutorRegistry`): a BYO `spec.executor` →
+ * `harness === null` → the `'router'` factory; else a registered factory for the
+ * harness-derived runtime (`'sandbox'` for any `BackendType`); else fail loud.
+ */
+declare function createExecutorRegistry(): ExecutorRegistry;
+
 /**
  *
  * The child→parent message bus: the ONE pipe carrying every message a worker, sub-driver, or
@@ -342,6 +560,185 @@ declare function createDelegationTraceCollector(onSpans: (spans: DelegationTrace
  */
 declare function composeLoopTraceEmitters(...emitters: ReadonlyArray<LoopTraceEmitter | undefined>): LoopTraceEmitter | undefined;
 
+/**
+ * OTEL span exporter — streams LoopTraceEvents to an OTLP/HTTP collector.
+ *
+ * Reads OTEL_EXPORTER_OTLP_ENDPOINT + OTEL_EXPORTER_OTLP_HEADERS from env
+ * when no explicit config is given. Keeps the runtime dep-free from
+ * @opentelemetry/sdk-trace-base — minimal OTLP/JSON serializer.
+ *
+ * The exporter accepts both raw OtelSpan objects and LoopTraceEvents
+ * (which get converted to OTLP spans automatically).
+ */
+interface OtelExportConfig {
+    /** OTLP endpoint. Reads OTEL_EXPORTER_OTLP_ENDPOINT env by default. */
+    endpoint?: string;
+    /** OTLP headers. Reads OTEL_EXPORTER_OTLP_HEADERS env by default. */
+    headers?: Record<string, string>;
+    /** Batch size before flush. Default 64. */
+    batchSize?: number;
+    /** Flush interval ms. Default 5000. */
+    flushIntervalMs?: number;
+    /** Resource attributes stamped on every export. */
+    resourceAttributes?: Record<string, string | number | boolean>;
+    /** Service name. Default 'agent-runtime'. */
+    serviceName?: string;
+}
+interface OtelExporter {
+    /** Export a span. */
+    exportSpan(span: OtelSpan): void;
+    /** Force flush pending spans. */
+    flush(): Promise<void>;
+    /** Shutdown cleanly. */
+    shutdown(): Promise<void>;
+}
+interface OtelSpan {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    kind?: number;
+    startTimeUnixNano: string;
+    endTimeUnixNano: string;
+    attributes?: OtelAttribute[];
+    status?: {
+        code: number;
+        message?: string;
+    };
+}
+interface OtelAttribute {
+    key: string;
+    value: {
+        stringValue?: string;
+        intValue?: string;
+        doubleValue?: number;
+        boolValue?: boolean;
+    };
+}
+/**
+ * Create an OTEL exporter. Returns undefined when no endpoint is configured.
+ */
+declare function createOtelExporter(config?: OtelExportConfig): OtelExporter | undefined;
+/**
+ * Convert a LoopTraceEvent into an OtelSpan for export.
+ */
+declare function loopEventToOtelSpan(event: {
+    kind: string;
+    runId: string;
+    timestamp: number;
+    payload: object;
+}, traceId: string, parentSpanId?: string): OtelSpan;
+/**
+ * Sink-neutral node in a reconstructed loop span tree. The root node's
+ * `parentSpanId` is `undefined` — sinks decide how to parent it (the OTEL
+ * mapper attaches the inherited delegation span; the delegation journal
+ * leaves it as the tree root).
+ */
+interface LoopSpanNode {
+    spanId: string;
+    parentSpanId?: string;
+    /** `'loop'` | `'loop.round'` | `'loop.iteration'`. */
+    name: string;
+    /** Topology level: loop root, plan round, or iteration branch. */
+    kind: 'loop' | 'round' | 'branch';
+    startMs: number;
+    endMs: number;
+    attrs: Record<string, string | number | boolean>;
+    /** True when the iteration carried an error — maps to OTEL status code 2. */
+    error: boolean;
+}
+/**
+ * Build a nested, real-duration OTLP span tree for ONE loop run from its full
+ * ordered `LoopTraceEvent` stream. Unlike `loopEventToOtelSpan` (one flat,
+ * zero-duration span per event), this reconstructs the topology hierarchy a
+ * GenAI trace viewer renders natively:
+ *
+ *   loop (invoke_workflow)
+ *     └─ loop.round[k] (invoke_workflow)   ← tangle.loop.move.{kind,width,rationale}
+ *          ├─ loop.iteration[i] (invoke_agent)  ← gen_ai.agent.name + usage + verdict + placement
+ *          └─ …
+ *
+ * Attributes follow the current GenAI semconv (`gen_ai.*`) where they apply and
+ * a namespaced `tangle.loop.*` / `tangle.cost.usd` extension for topology /
+ * verdict / placement / cost (not yet standardized). Pure: feed it a buffered
+ * per-runId event array (e.g. flushed on `loop.ended`) and export the result.
+ */
+declare function buildLoopOtelSpans(events: ReadonlyArray<{
+    kind: string;
+    runId: string;
+    timestamp: number;
+    payload: object;
+}>, traceId: string, rootParentSpanId?: string): OtelSpan[];
+/**
+ * Sink-neutral core behind {@link buildLoopOtelSpans}: reconstruct the
+ * loop → round → branch span tree from one run's ordered `LoopTraceEvent`
+ * stream. Consumed by the OTEL mapper above and by the MCP delegation
+ * journal's compact trace tee — one topology reconstruction, two sinks.
+ * Tolerates partial streams (a run that never reached `loop.ended` closes
+ * at the last observed event's timestamp).
+ */
+declare function buildLoopSpanNodes(events: ReadonlyArray<{
+    kind: string;
+    runId: string;
+    timestamp: number;
+    payload: object;
+}>): LoopSpanNode[];
+/** Wire version the eval-runs ingest enforces (X-Tangle-Wire-Version + body). */
+declare const INTELLIGENCE_WIRE_VERSION = "2026-05-26.v1";
+interface EvalRunGeneration {
+    /** 0-based ordinal of this generation within the run (required by ingest). */
+    index: number;
+    /** Identity of the proposed surface change (content-addressed hash). */
+    surfaceHash: string;
+    /** Arbitrary provenance for this generation (rationale, evidence, source). */
+    surface?: unknown;
+    /** Per-scenario results; empty until the generation is measured. */
+    cells?: unknown[];
+    /** Mean composite score (0 when unmeasured — pair with labels.measured). */
+    compositeMean: number;
+    costUsd: number;
+    durationMs: number;
+}
+interface EvalRunEvent {
+    runId: string;
+    runDir: string;
+    /** ISO timestamp. */
+    timestamp: string;
+    status: 'started' | 'baseline-complete' | 'generation-complete' | 'gate-decided' | 'finished' | 'errored';
+    labels?: Record<string, string>;
+    baseline?: EvalRunGeneration;
+    generations?: EvalRunGeneration[];
+    gateDecision?: 'ship' | 'hold' | 'need_more_work' | 'model_ceiling' | 'arch_ceiling';
+    holdoutLift?: number;
+    totalCostUsd: number;
+    totalDurationMs: number;
+    errorMessage?: string;
+}
+interface EvalRunsExportConfig {
+    /** Bearer key — tenant is resolved server-side from it. Reads TANGLE_API_KEY. */
+    apiKey?: string;
+    /** Intelligence base. Reads INTELLIGENCE_BASE env, else prod. */
+    base?: string;
+    /** Idempotency-Key header (e.g. the runId) — safe retries + upsert. */
+    idempotencyKey?: string;
+}
+interface EvalRunsExportResult {
+    ok: boolean;
+    status: number;
+    accepted: number;
+    rejected: Array<{
+        index: number;
+        reason: string;
+    }>;
+}
+/**
+ * Ship self-improvement eval-run events to Tangle Intelligence. Unlike the
+ * best-effort span exporter, this RESOLVES with the ingest verdict (accepted /
+ * rejected per event) so a consumer's loop can assert its provenance landed.
+ * Throws only on a missing key or network failure.
+ */
+declare function exportEvalRuns(events: EvalRunEvent[], config?: EvalRunsExportConfig): Promise<EvalRunsExportResult>;
+
 /**
  *
  * Trace context propagation for MCP subprocess.
@@ -1551,225 +1948,6 @@ declare class InMemoryFeedbackStore implements FeedbackStore {
  */
 declare function eventToSnapshot(event: FeedbackEvent): DelegationFeedbackSnapshot;
 
-/**
- *
- * The leaf runtime — the built-in `Executor` IMPLEMENTATIONS behind the ONE
- * open interface frozen in `./types`, plus the open resolver/registry that maps
- * an `AgentSpec` to one of them OR accepts a bring-your-own executor verbatim.
- *
- * The interface is the extension point, not a closed `inline|sandbox|cli` union:
- *   - router/inline : a direct OpenAI-compatible Router call, no box (one-shot).
- *   - sandbox       : COMPOSES the existing `runLoop` kernel as a single-task
- *                     leaf and surfaces its token/cost usage as `UsageEvent`s;
- *                     forwards PR #150's optional `lineage` passthrough WITHOUT
- *                     reinventing checkpoint/fork (streaming).
- *   - cli           : a Halo/RLM subprocess; `budgetExempt` (no token accounting),
- *                     excluded from the equal-k arms by construction (streaming).
- * Every metered runtime reports through the SAME normalized `UsageEvent` channel
- * so the conserved budget pool meters them identically. A user's own agent is
- * first-class the moment it implements `Executor` — register it by name or
- * pass it as `AgentSpec.executor`.
- *
- * Layering: `estimateCost`/`isModelPriced` are substrate primitives from
- * `@tangle-network/agent-eval`; `runLoop`/`acquireSandbox` are runtime kernels
- * from this package. No per-vendor adapters live here.
- *
- * @experimental
- */
-
-/**
- * Router/inline connection seam. A direct OpenAI-compatible Router endpoint —
- * the cheapest leaf, no box, no tools. `model` overrides the profile's model
- * hint when present; otherwise the profile's `model.default` is required.
- */
-interface RouterSeam {
-    routerBaseUrl: string;
-    routerKey: string;
-    model?: string;
-}
-/**
- * Sandbox executor seam. The `sandboxClient` the composed `runLoop` creates
- * boxes through, plus the optional trace/run/lineage wiring forwarded into the
- * loop. `lineage` is opaque here (PR #150's `RunLoopOptions.lineage`): forwarded
- * forward-compatibly, never inspected — this executor does NOT reinvent
- * checkpoint/fork.
- */
-interface SandboxSeam {
-    sandboxClient: SandboxClient;
-    /** Forwarded into the composed `runLoop`'s `ctx` (trace emitter, run handle, etc.). */
-    loopCtx?: Partial<Omit<ExecCtx, 'sandboxClient' | 'signal'>>;
-    /** PR #150 `RunLoopOptions.lineage` passthrough — opaque; forwarded, not parsed. */
-    lineage?: unknown;
-    /** Hard cap on the composed loop's iterations. The budget pool reserves against
-     *  the spawn `Budget.maxIterations`; this is the leaf's own ceiling. Default 1. */
-    maxIterations?: number;
-}
-/** CLI subprocess seam. `bin` + `args` describe the Halo/RLM process to spawn. */
-interface CliSeam {
-    bin: string;
-    args?: string[];
-    /** Extra environment for the subprocess (merged over `process.env`). */
-    env?: Record<string, string>;
-    /** Working directory for the subprocess. */
-    cwd?: string;
-}
-/**
- * cli-worktree seam. A supervisor-authored `AgentProfile` driving a local coding-harness CLI
- * (claude / codex / opencode) on its own git worktree — the leaf `createWorktreeCliExecutor`
- * named as data. `harness` + `repoRoot` + `taskPrompt` are required; the authored
- * `profile.prompt.systemPrompt` + `profile.model.default` reach the harness via the §1.5
- * `harnessInvocation` mapper. Everything else mirrors `WorktreeCliExecutorOptions`.
- */
-interface CliWorktreeSeam {
-    repoRoot: string;
-    /** Local CLI harness transport. Omit when `bridge` is set. */
-    harness?: LocalHarness;
-    taskPrompt: string;
-    runId?: string;
-    baseRef?: string;
-    harnessTimeoutMs?: number;
-    testCmd?: string;
-    typecheckCmd?: string;
-    checkTimeoutMs?: number;
-    checkOutputCap?: number;
-    budgetExempt?: boolean;
-    /** Live cli-bridge transport inside the worktree. When set, the worktree leaf accepts
-     *  `deliver()` messages and resumes the same bridge session in this worktree cwd. */
-    bridge?: CliWorktreeBridgeSeam;
-    /** Test seam — forwarded to worktree helpers. */
-    runGit?: GitRunner;
-    /** Test seam — forwarded to verification checks. */
-    runCommand?: WorktreeCheckRunner;
-}
-interface CliWorktreeBridgeSeam {
-    bridgeUrl: string;
-    bridgeBearer: string;
-    /** Bridge model/harness id. Defaults to the profile's model hint when omitted. */
-    model?: string;
-    agentProfile?: Record<string, unknown>;
-    timeoutMs?: number;
-    /** Stable cli-bridge session id. Defaults to `bridge-worktree-${runId}`. */
-    sessionId?: string;
-    maxTurns?: number;
-}
-/**
- * cli-bridge seam. A local OpenAI-compatible bridge that fronts harness CLIs
- * (claude-code / opencode / kimi / pi) behind one HTTP surface; `model` doubles
- * as the harness selector (e.g. `claude-code/sonnet`, `opencode/<provider>/<model>`).
- * `agentProfile` is the bridge-dialect profile (metadata.disallowedTools, mcp)
- * forwarded verbatim per request — how an arm disables native tools or injects
- * a provider search MCP.
- *
- * The executor opens a RESUMABLE cli-bridge session — structurally identical to the
- * sandbox executor's persistent box, just local. `sessionId` is the stable
- * caller-owned id cli-bridge maps to the harness's internal conversation id; a
- * follow-up steer/resume on the SAME id continues the SAME harness session (opencode
- * `-s`, claude `--resume`, …). Omit it and the executor mints a stable one per spawn.
- */
-interface BridgeSeam {
-    bridgeUrl: string;
-    bridgeBearer: string;
-    model: string;
-    /** Optional working directory forwarded to cli-bridge and persisted with the session. */
-    cwd?: string;
-    agentProfile?: Record<string, unknown>;
-    timeoutMs?: number;
-    /** Stable, caller-owned cli-bridge session id for harness-side resume. Defaults
-     *  to a freshly minted per-spawn id so each worker is its own resumable session. */
-    sessionId?: string;
-    /** Per-resume-turn inference cap before the worker settles on its last output.
-     *  Mirrors `routerToolsInlineExecutor.maxTurns`; default 200 (runaway backstop). */
-    maxTurns?: number;
-}
-/** Generic environment provider executor config. External packages implement
- *  `AgentEnvironmentProvider`; this built-in wrapper lets `createExecutor`
- *  consume them as backend data while preserving the existing usage channel. */
-interface ProviderSeam extends ProviderExecutorOptions {
-    provider: AgentEnvironmentProvider | string;
-    registry?: AgentEnvironmentProviderRegistry;
-}
-/**
- * Router seam WITH tool use — the tool-using router backend. Same direct
- * OpenAI-compatible endpoint as `RouterSeam`, but each turn passes `tools`; when
- * the model emits tool_calls they run via `executeToolCall` ON THIS HOST and the
- * results fold back as `tool` messages, repeating until the model answers without
- * a tool or `maxTurns` is hit. A real agentic loop, OFF-BOX — no sandbox, so it
- * is unaffected by a box's egress allowlist. One turn = one completion = the
- * equal-compute unit. `executeToolCall` receives the task so per-task tool
- * surfaces (e.g. a gym keyed by task) can dispatch correctly.
- */
-interface RouterToolsSeam {
-    routerBaseUrl: string;
-    routerKey: string;
-    model?: string;
-    tools: ReadonlyArray<ToolSpec>;
-    executeToolCall: (name: string, args: Record<string, unknown>, task: unknown) => Promise<string>;
-    /** Online observer of each tool step — the seam a `DetectorMonitor` taps to watch the live pipe
-     *  (raise a `finding` when the worker loops/errors). Called after every tool call resolves, with
-     *  real per-call wall-clock (`startedAt`/`endedAt`/`durationMs`) so a push `TraceSource` can carry
-     *  non-zero span durations onto the unified timeline. */
-    onToolStep?: (step: {
-        toolName: string;
-        args: Record<string, unknown>;
-        status: 'ok' | 'error';
-        startedAt?: number;
-        endedAt?: number;
-        durationMs?: number;
-    }) => void;
-    /** Max inference turns. Default 200 (runaway backstop — set far above any
-     *  legitimate workflow). For tighter per-workflow limits use a cost budget
-     *  or wall-clock deadline at the call site. */
-    maxTurns?: number;
-}
-/**
- * The leaf `createWorktreeCliExecutor` as a backend-as-data factory: a supervisor-authored
- * `AgentProfile` driving claude / codex / opencode on its own worktree. `budgetExempt` like
- * the other CLI leaves; the authored systemPrompt + model reach the harness via §1.5.
- */
-declare const cliWorktreeExecutor: ExecutorFactory<unknown>;
-/**
- * Config for {@link createExecutor}: the backend is DATA — the cost dial a profile,
- * an experiment config, or a replay journal can name — not an import choice. Each
- * variant carries its backend's seam (router/router-tools/bridge/cli/cli-worktree/sandbox).
- */
-type ExecutorConfig = ({
-    backend: 'router';
-} & RouterSeam) | ({
-    backend: 'router-tools';
-} & RouterToolsSeam) | ({
-    backend: 'bridge';
-} & BridgeSeam) | ({
-    backend: 'cli';
-} & CliSeam) | ({
-    backend: 'cli-worktree';
-} & CliWorktreeSeam) | ({
-    backend: 'provider';
-} & ProviderSeam) | ({
-    backend: 'sandbox';
-    harness?: BackendType;
-} & SandboxSeam);
-/**
- * The single built-in executor factory. Picks a leaf backend by data (`config.backend`),
- * injects the matching seam, and delegates to that backend's built-in implementation.
- * The `Executor` port stays OPEN: bring-your-own agents implement `Executor` directly
- * and never pass through here. Use this (or `createExecutorRegistry`) instead of a
- * per-vendor adapter or a closed `inline|sandbox|cli` switch — those bypass the
- * `UsageEvent` reporting channel.
- */
-declare function createExecutor(config: ExecutorConfig): ExecutorFactory<unknown>;
-/**
- * The open resolver/registry. Pre-registers the three built-ins under their
- * runtime tags (`'router'`, `'sandbox'`, `'cli'`) and accepts `register(name,
- * factory)` for any additional runtime — and a BYO `AgentSpec.executor` resolves
- * without touching the registry at all. NOT a closed switch; registration + BYO
- * ARE the extension points.
- *
- * `resolve` precedence (frozen in `ExecutorRegistry`): a BYO `spec.executor` →
- * `harness === null` → the `'router'` factory; else a registered factory for the
- * harness-derived runtime (`'sandbox'` for any `BackendType`); else fail loud.
- */
-declare function createExecutorRegistry(): ExecutorRegistry;
-
 /**
  *
  * `delegate` MCP tool — the ONE generic delegation verb, the agent-facing front door to
@@ -2089,6 +2267,16 @@ interface CoordinationToolsOptions {
      *  conserved-budget fence (the pool bounds total work; this bounds simultaneous work, e.g. live
      *  sandboxes/boxes). Omit or `<= 0` = no cap (the prior behavior; the pool stays the only fence). */
     readonly maxLiveWorkers?: number;
+    /** Max wall-clock ms a single `await_event` call may block waiting on a live worker to settle
+     *  before it returns a non-error `{ pending: true, live }` snapshot and lets the caller re-poll.
+     *  The underlying `scope.next()` blocks for the WHOLE (multi-minute) worker run; over a remote MCP
+     *  transport that block outlives the client's per-request timeout, so an unbounded await surfaces
+     *  to the supervisor as a hard tool ERROR on every call — the exact failure that leaves it flying
+     *  blind. Bounding the wait converts that error into a re-pollable liveness signal. The background
+     *  drain keeps running, so a settlement that lands after the bound is published to the bus and
+     *  pulled by the next call — nothing is lost. Omit = {@link DEFAULT_AWAIT_EVENT_TIMEOUT_MS}; `<= 0`
+     *  restores the prior UNBOUNDED block (only safe for in-process drivers with no transport timeout). */
+    readonly awaitTimeoutMs?: number;
 }
 /**
  * The supervisor-side toolbox returned by {@link createCoordinationTools}: the MCP tool
@@ -2126,4 +2314,4 @@ interface CoordinationTools {
 /** Build the driver's MCP tools over a live scope. */
 declare function createCoordinationTools(opts: CoordinationToolsOptions): CoordinationTools;
 
-export { type DelegationTaskQueueOptions as $, type AnalystRegistry as A, type DelegateResearchArgs as B, type CappedDelegationTrace as C, type DelegationExecutor as D, type DelegateResearchConfig as E, type FleetHandle as F, type DelegateResearchResult as G, type DelegateResult as H, type DelegateRunCtx as I, type DelegateUiAuditConfig as J, type DelegateUiAuditRoute as K, type DelegationError as L, type DelegationFeedbackSnapshot as M, type DelegationHistoryEntry as N, DelegationPersistenceError as O, type DelegationProfile as P, type DelegationProgress as Q, type DelegationRecord as R, type DelegationResultPayload as S, type DelegationResumeContext as T, type UiAuditorDelegate as U, type DelegationResumeDriver as V, type DelegationResumeTick as W, type DelegationRunContext as X, DelegationStateCorruptError as Y, type DelegationStatus as Z, type DelegationStore as _, DelegationTaskQueue as a, type ExecutorConfig as a$, type DelegationTraceCaps as a0, type DelegationTraceCollector as a1, type DelegationTraceSpan as a2, type DetachedSessionDelegateOptions as a3, type DetachedSessionRefParts as a4, type DetachedTurn as a5, type DetachedTurnResumeDriverOptions as a6, type DetachedWinnerSelection as a7, type DriveTurnCapableBox as a8, type DriveTurnTick as a9, type SubmitOutput as aA, type TraceContext as aB, type UiAuditorDelegationOutput as aC, buildDelegationTraceSpans as aD, capDelegationTrace as aE, coderTaskFromArgs as aF, composeLoopTraceEmitters as aG, createCoordinationTools as aH, createDelegateHandler as aI, createDelegationTraceCollector as aJ, createDetachedTurnResumeDriver as aK, createFleetWorkspaceExecutor as aL, createInProcessTransport as aM, createMcpServer as aN, createPropagatingTraceEmitter as aO, createSiblingSandboxExecutor as aP, detachedSessionDelegate as aQ, detachedTurnEvents as aR, eventToSnapshot as aS, formatDetachedSessionRef as aT, hashIdempotencyInput as aU, parseDetachedSessionRef as aV, readTraceContextFromEnv as aW, runDetachedTurn as aX, settleDetachedCoderTurn as aY, traceContextToEnv as aZ, validateDelegateArgs as a_, type FeedbackEvent as aa, type FeedbackRating as ab, type FeedbackRefersTo as ac, FileDelegationStore as ad, type FileDelegationStoreOptions as ae, type FleetWorkspaceExecutorOptions as af, InMemoryDelegationStore as ag, InMemoryFeedbackStore as ah, type JsonRpcMessage as ai, type JsonRpcResponse as aj, type MakeWorkerAgent as ak, type McpServer as al, type McpServerOptions as am, type McpToolDescriptor as an, type McpTransport as ao, type Question as ap, type QuestionDecision as aq, type QuestionPolicy as ar, type QuestionRecord as as, type ResearchOutputShape as at, type ResearchSource as au, type RunDetachedTurnOptions as av, type SettleDetachedCoderTurnOptions as aw, type SettledWorker as ax, type SiblingSandboxExecutorOptions as ay, type SubmitInput as az, type FeedbackStore as b, type BusEvent as b0, type BusRecord as b1, type BusStats as b2, type EventBus as b3, type ProviderSeam as b4, type PublishOptions as b5, cliWorktreeExecutor as b6, createEventBus as b7, createExecutor as b8, createExecutorRegistry as b9, type DelegateFeedbackResult as c, type DelegateFeedbackArgs as d, type DelegateUiAuditArgs as e, type DelegateUiAuditResult as f, type DelegationHistoryResult as g, type DelegationHistoryArgs as h, type DelegationStatusResult as i, type DelegationStatusArgs as j, type CoderDelegate as k, type CoderReview as l, type CoderReviewer as m, type CoordinationEvent as n, type CoordinationTools as o, type CoordinationToolsOptions as p, DELEGATE_DESCRIPTION as q, DELEGATE_INPUT_SCHEMA as r, DELEGATE_TOOL_NAME as s, DELEGATION_TRACE_MAX_BYTES as t, DELEGATION_TRACE_MAX_SPANS as u, type DelegateArgs as v, type DelegateCodeArgs as w, type DelegateCodeConfig as x, type DelegateCodeResult as y, type DelegateHandlerOptions as z };
+export { type DelegationStatus as $, type AnalystRegistry as A, type DelegateResearchArgs as B, type CappedDelegationTrace as C, type DelegationExecutor as D, type ExecutorConfig as E, type FleetHandle as F, type DelegateResearchConfig as G, type DelegateResearchResult as H, type DelegateResult as I, type DelegateRunCtx as J, type DelegateUiAuditConfig as K, type DelegateUiAuditRoute as L, type MakeWorkerAgent as M, type DelegationError as N, type DelegationFeedbackSnapshot as O, type DelegationHistoryEntry as P, DelegationPersistenceError as Q, type DelegationProfile as R, type DelegationProgress as S, type DelegationRecord as T, type UiAuditorDelegate as U, type DelegationResultPayload as V, type DelegationResumeContext as W, type DelegationResumeDriver as X, type DelegationResumeTick as Y, type DelegationRunContext as Z, DelegationStateCorruptError as _, DelegationTaskQueue as a, validateDelegateArgs as a$, type DelegationStore as a0, type DelegationTaskQueueOptions as a1, type DelegationTraceCaps as a2, type DelegationTraceCollector as a3, type DelegationTraceSpan as a4, type DetachedSessionDelegateOptions as a5, type DetachedSessionRefParts as a6, type DetachedTurn as a7, type DetachedTurnResumeDriverOptions as a8, type DetachedWinnerSelection as a9, type SubmitInput as aA, type SubmitOutput as aB, type TraceContext as aC, type UiAuditorDelegationOutput as aD, buildDelegationTraceSpans as aE, capDelegationTrace as aF, coderTaskFromArgs as aG, composeLoopTraceEmitters as aH, createCoordinationTools as aI, createDelegateHandler as aJ, createDelegationTraceCollector as aK, createDetachedTurnResumeDriver as aL, createFleetWorkspaceExecutor as aM, createInProcessTransport as aN, createMcpServer as aO, createPropagatingTraceEmitter as aP, createSiblingSandboxExecutor as aQ, detachedSessionDelegate as aR, detachedTurnEvents as aS, eventToSnapshot as aT, formatDetachedSessionRef as aU, hashIdempotencyInput as aV, parseDetachedSessionRef as aW, readTraceContextFromEnv as aX, runDetachedTurn as aY, settleDetachedCoderTurn as aZ, traceContextToEnv as a_, type DriveTurnCapableBox as aa, type DriveTurnTick as ab, type FeedbackEvent as ac, type FeedbackRating as ad, type FeedbackRefersTo as ae, FileDelegationStore as af, type FileDelegationStoreOptions as ag, type FleetWorkspaceExecutorOptions as ah, InMemoryDelegationStore as ai, InMemoryFeedbackStore as aj, type JsonRpcMessage as ak, type JsonRpcResponse as al, type McpServer as am, type McpServerOptions as an, type McpToolDescriptor as ao, type McpTransport as ap, type Question as aq, type QuestionDecision as ar, type QuestionPolicy as as, type QuestionRecord as at, type ResearchOutputShape as au, type ResearchSource as av, type RunDetachedTurnOptions as aw, type SettleDetachedCoderTurnOptions as ax, type SettledWorker as ay, type SiblingSandboxExecutorOptions as az, type FeedbackStore as b, type EvalRunEvent as b0, type EvalRunGeneration as b1, type EvalRunsExportConfig as b2, type EvalRunsExportResult as b3, INTELLIGENCE_WIRE_VERSION as b4, type LoopSpanNode as b5, type OtelAttribute as b6, type OtelExportConfig as b7, type OtelExporter as b8, type OtelSpan as b9, buildLoopOtelSpans as ba, buildLoopSpanNodes as bb, createOtelExporter as bc, exportEvalRuns as bd, loopEventToOtelSpan as be, type BusEvent as bf, type BusRecord as bg, type BusStats as bh, type EventBus as bi, type ProviderSeam as bj, type PublishOptions as bk, cliWorktreeExecutor as bl, createEventBus as bm, createExecutor as bn, createExecutorRegistry as bo, type DelegateFeedbackResult as c, type DelegateFeedbackArgs as d, type DelegateUiAuditArgs as e, type DelegateUiAuditResult as f, type DelegationHistoryResult as g, type DelegationHistoryArgs as h, type DelegationStatusResult as i, type DelegationStatusArgs as j, type CoderDelegate as k, type CoderReview as l, type CoderReviewer as m, type CoordinationEvent as n, type CoordinationTools as o, type CoordinationToolsOptions as p, DELEGATE_DESCRIPTION as q, DELEGATE_INPUT_SCHEMA as r, DELEGATE_TOOL_NAME as s, DELEGATION_TRACE_MAX_BYTES as t, DELEGATION_TRACE_MAX_SPANS as u, type DelegateArgs as v, type DelegateCodeArgs as w, type DelegateCodeConfig as x, type DelegateCodeResult as y, type DelegateHandlerOptions as z };