@tangle-network/agent-runtime 0.71.1 → 0.73.0

package/dist/{delegates-CsXJPZDH.d.ts → coordination-DU0saWeg.d.ts}

@@ -1,581 +1,234 @@
-import { ChildProcess } from 'node:child_process';
-import { DefaultVerdict, AgentEvalError } from '@tangle-network/agent-eval';
+import { L as LocalHarness, p as ExecutorFactory, E as ExecutorRegistry, o as DeliverableSpec, l as Spend, g as Agent, m as Scope, h as ResultBlobStore, B as Budget } from './worktree-DaxOvw-C.js';
 import { AgentProfile } from '@tangle-network/agent-interface';
-import { BackendType, SandboxEvent, SandboxInstance } from '@tangle-network/sandbox';
-import { d as LoopTokenUsage, b as RuntimeHooks, e as LoopTraceEmitter, L as LoopTraceEvent, S as SandboxClient, A as AgentRunSpec } from './types-CdnEAE3U.js';
-import { a as UiLens, U as UiFinding, C as CoderTask } from './substrate-BoRXgvka.js';
+import { U as UiLens, a as UiFinding, C as CoderTask } from './substrate-rNj6TDc3.js';
+import { e as LoopTraceEmitter, c as LoopTraceEvent, S as SandboxClient, A as AgentRunSpec, E as ExecCtx } from './types-JufmXF2a.js';
+import { SandboxEvent, SandboxInstance, BackendType } 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-C7kp_ECN.js';
 
 /**
  * @experimental
  *
- * Subprocess wrappers for the local coding-harness CLIs installed in the
- * sandbox image (claude-code, codex, opencode). Used by the in-process
- * delegation executor (`createInProcessExecutor`) so a `delegate_code` call
- * spawns a real harness on a real git worktree instead of provisioning a
- * sibling sandbox.
- *
- * All harness invocations:
- *   - run with `cwd` set to the worktree
- *   - inherit env from the parent (the MCP server inside the sandbox has
- *     the harness's auth already)
- *   - capture stdout/stderr
- *   - support cancellation via AbortSignal
- *   - enforce a wall-clock timeout
- */
+ * The child→parent message bus: the ONE pipe carrying every message a worker, sub-driver, or
+ * analyst sends up to the driver — settled outputs, questions, and trace-analyst findings. It
+ * unifies channels that were ad-hoc before (the settled-worker cursor, the ask-parent question
+ * channel, and analyst results) into a single typed primitive with two lanes:
+ *
+ *   - PASS-THROUGH (`subscribe`): every published event reaches subscribers immediately — the
+ *     express lane for online steering and live observation (a UI, a hook, the parent's box).
+ *   - STANDBY (`pull`): events also queue so the driver consumes them on its own cadence. The queue
+ *     is PRIORITY-ordered: a higher-`priority` event (a blocking question) is bumped ahead of
+ *     queued settles/findings so the driver sees it first; ties resolve FIFO by publish order.
+ *
+ * Observability is first-class (A++): every event is stamped with a monotonic `seq` and wall-clock
+ * `at`, the full ordered `history()` is retained as an audit/replay trail, and `stats()` exposes
+ * published/pulled counts by kind. Subscribers receive the stamped record, not a bare event.
+ *
+ * The interface is transport-agnostic on purpose. Same box → this in-process queue. Cross box →
+ * the SAME publish/pull/subscribe surface backed by a durable mailbox on the parent's box (children
+ * POST events with at-least-once retry; payloads are blob refs so the event stays small). Consumers
+ * depend only on this interface, so distribution is a transport swap, never an architecture change.
+ */
+/** Every bus event is a discriminated union member keyed by `type`. */
+interface BusEvent {
+    readonly type: string;
+}
+/** A published event stamped for ordering and observability. `seq` is the monotonic publish index;
+ *  `priority` drives pull order (higher = bumped ahead); `at` is the wall-clock publish time (ms). */
+interface BusRecord<E extends BusEvent> {
+    readonly seq: number;
+    readonly at: number;
+    readonly priority: number;
+    readonly event: E;
+}
+interface PublishOptions {
+    /** Higher = pulled ahead of lower-priority queued events (default 0). A blocking question sets
+     *  this so it bumps to the front of the driver's inbox. */
+    readonly priority?: number;
+    /** Whether the event enters the pull queue (default true). Set `false` for record-only events —
+     *  the parent→child down-leg (steer / answer / resume): they belong in `history()` and reach
+     *  `subscribe` observers, but the parent must never `pull` its own outbound message back. */
+    readonly queue?: boolean;
+}
+interface BusStats {
+    readonly published: number;
+    readonly pulled: number;
+    /** Count published per event `type`. */
+    readonly byKind: Readonly<Record<string, number>>;
+}
+interface EventBus<E extends BusEvent> {
+    /** Stamp + queue the event, then deliver the stamped record to every subscriber in order.
+     *  Returns the stamped record. */
+    publish(event: E, opts?: PublishOptions): Promise<BusRecord<E>>;
+    /** Remove and return the highest-priority QUEUED event whose type is in `kinds` (any if omitted),
+     *  ties broken FIFO by `seq`; `undefined` when nothing matches. */
+    pull(kinds?: ReadonlyArray<E['type']>): E | undefined;
+    /** Register a pass-through handler; it receives the stamped record of every event published after
+     *  registration. Returns an unsubscribe fn. */
+    subscribe(handler: (record: BusRecord<E>) => void | Promise<void>): () => void;
+    /** Count of queued, not-yet-pulled events (filtered by `kinds` when given). */
+    pending(kinds?: ReadonlyArray<E['type']>): number;
+    /** The full ordered log of every event ever published (the audit/replay trail). */
+    history(): ReadonlyArray<BusRecord<E>>;
+    /** Throughput counters for observability dashboards. */
+    stats(): BusStats;
+}
+declare function createEventBus<E extends BusEvent>(now?: () => number): EventBus<E>;
 
-/** Local coding harness available inside the sandbox. */
-type LocalHarness = 'claude' | 'codex' | 'opencode';
-/** @experimental */
-interface RunLocalHarnessOptions {
-    harness: LocalHarness;
-    /** Working directory for the subprocess (typically a worktree path). */
-    cwd: string;
-    /** Prompt forwarded as the harness CLI's task argument. */
-    taskPrompt: string;
-    /**
-     * Pre-built command + args (e.g. from `harnessInvocation` so the full authored
-     * `AgentProfile` — systemPrompt + model — reaches the harness). When set it OVERRIDES the
-     * default prompt-only `buildArgs(taskPrompt)` path; `command` defaults to the harness's
-     * default binary when only `args` is supplied. When absent the legacy prompt-only shape
-     * is used unchanged.
-     */
-    invocation?: {
-        command?: string;
-        args: ReadonlyArray<string>;
-    };
-    /** Wall-clock kill deadline (ms). Default 5 min. Subprocess SIGTERMed on expiry. */
-    timeoutMs?: number;
-    /** Caller cancellation. SIGTERM is sent on abort. */
-    signal?: AbortSignal;
-    /** Override env (defaults to inheriting from the parent). */
-    env?: NodeJS.ProcessEnv;
-    /**
-     * Test seam — inject a custom spawner so unit tests can mock the
-     * subprocess without touching the OS. Defaults to node's `child_process.spawn`.
-     */
-    spawn?: (command: string, args: ReadonlyArray<string>, opts: {
-        cwd: string;
-        env: NodeJS.ProcessEnv;
-        stdio: 'pipe';
-    }) => ChildProcess;
-}
-/** @experimental */
-interface LocalHarnessResult {
-    /** OS exit code. `null` when killed before exit. */
-    exitCode: number | null;
-    /** Concatenated stdout. */
-    stdout: string;
-    /** Concatenated stderr. */
-    stderr: string;
-    /** Set when the process exited via signal (timeout / abort). */
-    killedBySignal: NodeJS.Signals | null;
-    /** Wall-clock duration ms (spawn → exit). */
-    durationMs: number;
-    /** Set when timeoutMs elapsed before exit. */
-    timedOut: boolean;
-}
 /**
- * Spawn a local coding harness CLI as a subprocess + collect its output.
- *
- * NOT responsible for parsing the harness's output or extracting a diff —
- * the in-process executor's `streamPrompt` orchestrates `git diff` against
- * the worktree after this resolves. This function is intentionally narrow:
- * spawn, wait, capture, return.
- *
- * Fails loud — throws when:
- *   - `cwd` doesn't exist (subprocess emits ENOENT; surfaced as Error)
- *   - the harness binary is not on PATH (ENOENT)
+ * @experimental
  *
- * Does NOT throw when:
- *   - the subprocess exits non-zero (`result.exitCode` carries the code)
- *   - the subprocess is aborted / timed out (`result.killedBySignal` /
- *     `result.timedOut` carries the reason)
+ * Sandbox-session coder decode layer. The sandbox-session delegate (`./delegates`) and the
+ * cross-restart resume driver run the in-box harness over a `SandboxClient` and need to
+ * (a) build an `AgentRunSpec` from the caller-authored (or minimal model-only default) worker
+ * profile, (b) decode the harness event stream into a structured `CoderOutput`, and (c) gate it with
+ * the shared mechanical checks. This sandbox-session path is kept separate from the generic recursive
+ * path: `worktreeFanout` instead settles the raw `WorktreePatchArtifact` and gates via
+ * `patchDelivered`. Prefer `worktreeFanout` / `worktreeLoopRunner` for NEW local-repo coding.
  *
- * @experimental
+ * The decode tolerates two `result`-event shapes:
+ *   1. the in-process executor's raw worktree-harness result (`{ branch, patch, stats, checks }`),
+ *      projected onto `CoderOutput`; and
+ *   2. an LLM-emitted JSON block (`{ branch, patch, testResult, typecheckResult, diffStats }`),
+ *      lifted onto `data.result` or scanned out of the assistant transcript (any harness shape).
  */
-declare function runLocalHarness(options: RunLocalHarnessOptions): Promise<LocalHarnessResult>;
+
+/** @experimental The structured coder result the sandbox-session path decodes + gates. */
+interface CoderOutput {
+    /** Branch the agent wrote the patch on. */
+    branch: string;
+    /** Unified diff (`git diff <base>..HEAD`). */
+    patch: string;
+    testResult: {
+        passed: boolean;
+        output: string;
+    };
+    typecheckResult: {
+        passed: boolean;
+        output: string;
+    };
+    diffStats: {
+        filesChanged: number;
+        insertions: number;
+        deletions: number;
+    };
+    /** Optional reviewer commentary surfaced by the agent. */
+    reviewerNotes?: string;
+}
 
 /**
  * @experimental
  *
- * Recursive execution atom — the FROZEN type surface (the keystone contract).
- *
- * One self-similar `Agent` atom runs inside a budget-conserving reactive `Scope`,
- * orchestrated by a `Supervisor` over an event-sourced `SpawnJournal`. A leaf is an
- * `Agent` that never calls `scope.spawn`; a driver is an `Agent` that spawns and runs
- * a policy over its children's streaming results.
- *
- * Two invariants the surface exists to make enforceable:
- *  - Budget is an atomically-reserved CONSERVED pool, so `Σk(treatment) ≡ Σk(blind)` by
- *    construction (reserve-on-spawn, refund-unspent-on-settle, fail-closed admission).
- *  - The journal records a content-addressed `outRef` per child result, so replay
- *    rehydrates the exact `Settled` the driver branched on (the replay invariant below).
+ * Persistence port for the MCP delegation queue.
  *
- * The leaf RUNTIME is one OPEN `Executor` interface, not a closed `inline|sandbox|cli`
- * union the call site switches on. The built-ins (router/inline, sandbox, cli) are the
- * initial IMPLEMENTATIONS; any user agent is first-class the moment it implements the
- * interface. The interface IS the extension point — no per-vendor adapters live here.
+ * `DelegationTaskQueue` keeps its working set in memory (status/history
+ * reads stay synchronous) and journals every record mutation through a
+ * `DelegationStore`. `DelegationTaskQueue.restore({ store })` is the load
+ * path: it reads the full record set once at construction and rehydrates
+ * the queue from it. After that the store only sees writes.
  *
- * Layering: substrate types (`DefaultVerdict`) come from `@tangle-network/agent-eval`;
- * runtime-shaped types (everything else) live here. Pure types/interfaces only — this
- * module typechecks standalone and is imported by every keystone impl.
+ * Records MUST be JSON-safe — `FileDelegationStore` round-trips them
+ * through `JSON.stringify`/`JSON.parse`, so a `Date`, `Map`, or function
+ * smuggled into `args`/`result` would corrupt the journal.
  */
 
-/**
- * One self-similar atom. A leaf is an `Agent` that never calls `scope.spawn`; a driver
- * is an `Agent` whose `act` spawns children and reacts to them via `scope.next()`. An
- * analyst is an `Agent` whose task is "read these traces → findings" — `where` it runs
- * is its executor, not a separate type.
- *
- * `act` MUST be replay-safe: it may read `verdict`, `spent`, and `out` (rehydrated by
- * `outRef`) off each `Settled`; it MUST NOT read `Date.now`, `Math.random`, or any
- * unordered collection. `scope.next()` delivers strictly in recorded `seq` order.
- */
-interface Agent<Task, Out> {
-    readonly name: string;
-    act(task: Task, scope: Scope<Out>): Promise<Out>;
-}
-/**
- * The leaf runtime — ONE open interface, not a closed union. `execute` returns a
- * `Promise<ExecutorResult>` for one-shot executors OR an `AsyncIterable<UsageEvent>` for
- * streaming ones; a streaming executor reports incremental normalized usage as it runs
- * (the budget pool reconciles against it) and exposes its terminal artifact via
- * `resultArtifact()`. Both shapes normalize usage to `UsageEvent` so the conserved pool
- * meters every runtime identically.
- *
- * Built-in implementations (in `runtime.ts`, NOT variants here): router/inline (a direct
- * Router/HTTP inference call, no box), sandbox (COMPOSES `runLoop` as a leaf, forwarding
- * PR #150's optional `lineage` passthrough — does NOT reinvent checkpoint/fork), cli
- * (Halo/RLM subprocess; `budgetExempt`, excluded from equal-k by construction). A user's
- * own agent (mastra/agno/raw HTTP/anything) is first-class by implementing this interface.
- */
-interface Executor<Out> {
-    /** Stable runtime tag for traces + the equal-k exemption check. */
-    readonly runtime: Runtime;
-    /**
-     * When true, this executor's spend is NOT metered against the conserved pool and its
-     * iterations are excluded from the equal-k assertion (a `cli` subprocess without
-     * token accounting). Fail-loud everywhere else: a metered executor MUST report usage.
-     */
-    readonly budgetExempt?: boolean;
-    /**
-     * One-shot → resolves a `ExecutorResult`; streaming → yields incremental `UsageEvent`s and
-     * the terminal artifact is read from `resultArtifact()` after the stream drains.
-     * `signal` is the spawn-scoped abort (chains the acquire lifecycle for sandbox).
-     */
-    execute(task: unknown, signal: AbortSignal): Promise<ExecutorResult<Out>> | AsyncIterable<UsageEvent>;
-    /**
-     * Optional inbox: receive an out-of-band message from the driver mid-run (the `send`/`steer_agent`
-     * verb). A streaming executor drains pending messages between turns and folds them into the next
-     * step (a steer / interrupt / resume). A one-shot executor that can't be steered mid-flight omits
-     * this; `Scope.send` then returns `false` for it. Never throws — a malformed message is the
-     * executor's to ignore.
-     */
-    deliver?(msg: unknown): void;
-    /**
-     * Tear the executor's resources down. `grace` mirrors the OTP shutdown spec
-     * (`'brutalKill'` = immediate, a number = ms grace, `'infinity'` = await clean exit).
-     */
-    teardown(grace: number | 'brutalKill' | 'infinity'): Promise<{
-        destroyed: boolean;
-    }>;
+/** @experimental */
+interface DelegationStore {
     /**
-     * The replay source (B1): the content-addressed `outRef` + the materialized output the
-     * driver branched on, its verdict, and the conserved spend. Read once, after settle.
+     * Read every persisted record. Called once, by
+     * `DelegationTaskQueue.restore`, before any write. A missing backing
+     * file is an empty store; an unparseable one throws
+     * `DelegationStateCorruptError`.
      */
-    resultArtifact(): {
-        outRef: string;
-        out: Out;
-        verdict?: DefaultVerdict;
-        spent: Spend;
-    };
+    loadAll(): Promise<DelegationRecord[]>;
+    /** Insert or replace the record keyed by `record.taskId`. */
+    upsert(record: DelegationRecord): Promise<void>;
     /**
-     * A driver-executor's OWN-inference subtree total (rolled up from its nested tree's `metered`
-     * events) — the parent scope journals it as a `metered` event for this node on settle, on BOTH
-     * the done AND the down/crash paths, so a crashed sub-driver's partial inference still re-homes
-     * (the pool already debited it via `observe`; the journal must match). NOT reconciled, so it never
-     * trips the reservation clamp. Read on settle, valid after `execute` resolves OR throws. Leaf
-     * executors omit it (returns `undefined`).
+     * Resolve an idempotency key to the taskId that claimed it, if any.
+     * The queue serves submit-time dedupe from its rehydrated in-memory
+     * index; this read exists for consumers that share a store across
+     * processes without holding the full record set.
      */
-    metered?(): Spend | undefined;
-}
-/** Terminal artifact of a one-shot `Executor.execute`. */
-interface ExecutorResult<Out> {
-    outRef: string;
-    out: Out;
-    verdict?: DefaultVerdict;
-    spent: Spend;
-}
-/**
- * Normalized usage event — the single channel every executor reports through, so the
- * conserved pool meters all runtimes identically. `tokens` carries `LoopTokenUsage`'s
- * `{ input, output }`; `usd` is a SEPARATE channel (never folded into tokens).
- */
-type UsageEvent = {
-    kind: 'tokens';
-    input: number;
-    output: number;
-} | {
-    kind: 'cost';
-    usd: number;
-} | {
-    kind: 'iteration';
-};
-/** The runtime tag of a `Executor` impl. Open by intent — `string` so a BYO executor
- *  names its own runtime; the built-ins use these literals. */
-type Runtime = 'router' | 'inline' | 'sandbox' | 'cli' | (string & {});
-/**
- * `AgentProfile` does NOT carry a `harness`/backend field — `harness` lives on the
- * sandbox SDK's `BackendConfig`, not the portable profile. So an agent is mapped to its
- * executor through this MINIMAL wrapper, never by fabricating a field onto `AgentProfile`.
- *
- * Resolution (in `runtime.ts`):
- *  - `executor` present        → BYO: use it verbatim (a user's own `Executor`).
- *  - `harness === null`        → router/inline: a direct Router call, no box.
- *  - `harness` is a `BackendType` → sandbox: compose `runLoop` against `profile` on that backend.
- * Fail loud on an unresolvable spec (no executor and an unknown harness).
- */
-interface AgentSpec {
-    readonly profile: AgentProfile;
-    /** `null` selects router/inline; a `BackendType` selects the sandboxed harness. */
-    readonly harness: BackendType | null;
-    /** Bring-your-own executor: when set, overrides harness-based resolution entirely. */
-    readonly executor?: Executor<unknown>;
+    lookupIdempotencyKey(key: string): Promise<string | undefined>;
+    /** Delete the named records — the retention-cap eviction path. */
+    remove(taskIds: readonly string[]): Promise<void>;
 }
 /**
- * Builds a fresh `Executor` for one spawn from the resolved spec. Per-spawn (not
- * shared) so each child owns its own box/abort/teardown lifecycle. A BYO factory lets a
- * user supply construction args without pre-instantiating.
+ * The persisted delegation state exists but cannot be parsed into
+ * records. Fail loud: silently starting empty over a corrupt journal
+ * would erase delegation history and re-run idempotent work. Opt into
+ * recovery explicitly via `FileDelegationStoreOptions.recoverCorrupt`
+ * (the bin maps `AGENT_RUNTIME_DELEGATION_STATE_RECOVER=1` onto it),
+ * which archives the corrupt file and starts fresh.
+ *
+ * @experimental
  */
-type ExecutorFactory<Out> = (spec: AgentSpec, ctx: ExecutorContext) => Executor<Out>;
-/** Construction context handed to a `ExecutorFactory` — the seams a built-in needs
- *  (sandbox client for the sandbox executor, router config for router/inline) without
- *  the factory reaching into module globals. */
-interface ExecutorContext {
-    readonly signal: AbortSignal;
-    /** Opaque seams the registry threads through; a built-in narrows what it needs. */
-    readonly seams: Readonly<Record<string, unknown>>;
+declare class DelegationStateCorruptError extends AgentEvalError {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
 }
 /**
- * The OPEN resolver: maps an `AgentSpec` to a `ExecutorFactory`. The default
- * registry resolves the three built-ins AND accepts a BYO `executor`/factory; callers
- * register more runtimes by name. NOT a closed switch — registration is the extension
- * point, mirroring the open `Executor` interface.
+ * A delegation-store read or write failed (filesystem error, store
+ * called before `loadAll`, ...). Once the queue observes one, it stops
+ * accepting new submissions — accepting work it cannot journal would
+ * silently demote durable mode to in-memory mode.
+ *
+ * @experimental
  */
-interface ExecutorRegistry {
-    /** Register a factory for a named runtime. Throws on a duplicate name (fail loud). */
-    register<Out>(runtime: Runtime, factory: ExecutorFactory<Out>): void;
-    /**
-     * Resolve a spec to a factory. Precedence: a BYO `spec.executor` → a trivial factory
-     * returning it; else `harness === null` → the `'router'` factory; else a registered
-     * factory for the harness-derived runtime. Returns a typed outcome — the caller
-     * inspects `succeeded` before `value` (no silent fallback).
-     */
-    resolve<Out>(spec: AgentSpec): {
-        succeeded: true;
-        value: ExecutorFactory<Out>;
-    } | {
-        succeeded: false;
-        error: string;
-    };
-}
-/** A budget envelope on a spawn or the root. All ceilings; the pool reserves against them. */
-interface Budget {
-    readonly maxIterations: number;
-    readonly maxTokens: number;
-    readonly maxUsd?: number;
-    readonly deadlineMs?: number;
-}
-/** Conserved spend, reconciled from the normalized `UsageEvent` stream. Tokens and usd
- *  are separate channels (never folded). */
-interface Spend {
-    iterations: number;
-    tokens: LoopTokenUsage;
-    usd: number;
-    ms: number;
-}
-/** OTP child-spec restart class. */
-type Restart = 'temporary' | 'transient' | 'permanent';
-/** `'acquiring'` is first-class (M1): a node spends real time + reaps an orphan box
- *  during sandbox acquire BEFORE it is `running`, so abort must be defined over it. */
-type NodeStatus = 'pending' | 'acquiring' | 'running' | 'done' | 'failed' | 'cancelled';
-/** Deterministic node id — `${parent}:s${seq}` from the cursor order, never wall-clock. */
-type NodeId = string;
-interface SpawnOpts {
-    readonly budget: Budget;
-    readonly label: string;
-    readonly restart?: Restart;
-    /** Teardown grace handed to the executor when this node is reaped. */
-    readonly shutdown?: number | 'brutalKill' | 'infinity';
+declare class DelegationPersistenceError extends AgentEvalError {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
 }
-/**
- * A live child handle. `abort()` is defined over the ACQUIRE lifecycle: it chains into
- * the `acquireSandbox` signal and reaps a find-by-name orphan box, so a node aborted
- * mid-acquire never leaks (M1).
- */
-interface Handle<Out> {
-    readonly id: NodeId;
-    readonly label: string;
-    readonly status: NodeStatus;
-    abort(reason?: string): void;
-    /** Phantom: binds the handle to the child's output type so `spawn<C>` returns a
-     *  `Handle<C>` distinct from a `Handle<other>`. Type-only — never present at runtime. */
-    readonly __out?: Out;
+/** @experimental */
+declare class InMemoryDelegationStore implements DelegationStore {
+    private readonly records;
+    loadAll(): Promise<DelegationRecord[]>;
+    upsert(record: DelegationRecord): Promise<void>;
+    lookupIdempotencyKey(key: string): Promise<string | undefined>;
+    remove(taskIds: readonly string[]): Promise<void>;
 }
-/**
- * A settled child, delivered by `scope.next()`. `seq` is the monotonic cursor order
- * `next()` yielded this settlement (B2) — NOT wall-clock — and replay delivers strictly
- * in `seq` order. `outRef` rehydrates `out` from the `ResultBlobStore` on replay.
- */
-type Settled<Out> = {
-    kind: 'done';
-    handle: Handle<Out>;
-    out: Out;
-    outRef: string;
-    verdict?: DefaultVerdict;
-    spent: Spend;
-    seq: number;
-} | {
-    kind: 'down';
-    handle: Handle<Out>;
-    reason: string;
-    /** True = infrastructure failure (excluded from merge `n` / equal-k), not a bad result. */
-    infra: boolean;
-    restartCount: number;
-    seq: number;
-};
-/**
- * The budget-conserving reactive scope an `Agent.act` runs inside. `spawn` reserves
- * budget atomically from the shared pool and fails closed when the pool cannot cover it.
- * `next()` waits for one settlement from this scope's live set; `view` reads live state,
- * not the replay log.
- */
-interface Scope<Out> {
-    /**
-     * Spawn a child. Reserves `opts.budget` from the conserved pool atomically; refunds the
-     * unspent remainder on settle. Returns a typed outcome — fail-closed on an exhausted
-     * pool or an exceeded depth ceiling (the caller inspects `ok` before `handle`).
-     */
-    spawn<C extends Out>(agent: Agent<unknown, C>, task: unknown, opts: SpawnOpts): {
-        ok: true;
-        handle: Handle<C>;
-    } | {
-        ok: false;
-        reason: 'budget-exhausted' | 'depth-exceeded';
-    };
-    /** ray.wait n=1 over this scope's in-memory live set; resolves as each child settles;
-     *  `null` when the live set is empty. */
-    next(): Promise<Settled<Out> | null>;
-    /**
-     * Steer a RUNNING child out-of-band — deliver a message to its executor's inbox (the driver's
-     * `send` verb: next-instruction, interrupt, or resume). Returns `true` if the message was
-     * delivered to a live child whose executor accepts delivery, `false` otherwise (unknown id,
-     * already settled, or an executor with no inbox). The executor drains its inbox between turns;
-     * a leaf that does not implement `deliver` simply cannot be steered mid-flight. In-process this
-     * is a direct call; the sandbox/Agent-Bus transports surface the SAME verb as an MCP tool.
-     */
-    send(nodeId: NodeId, msg: unknown): boolean;
-    /** This scope's abort signal — aborted when the run is cancelled, a breaker trips, the pool
-     *  is exhausted, or a parent scope cascades. A long-running driver `act` over this scope reads
-     *  it to break promptly (the conserved pool + driver-stop are the other bounds). A nested
-     *  scope carries its own signal, chained off its driver child's abort. */
-    readonly signal: AbortSignal;
+/** @experimental */
+interface FileDelegationStoreOptions {
+    /** Absolute path of the JSON state file. Parent directories are created on first write. */
+    filePath: string;
     /**
-     * Meter the driver's OWN compute against the conserved pool — its inference turns, which are
-     * real tokens/usd but not a spawned child (no reserve/reconcile). A direct `free → committed`
-     * debit, so equal-k counts the driver's tokens AND the in-loop budget guard (`budget.tokensLeft`)
-     * halts a driver that thinks the pool dry. `detail` rides an `agent.turn` trace event for live
-     * observability (turn index, tool calls, cumulative spend). It also journals a `metered` event —
-     * the durable twin of the pool debit (as `settled` is the twin of `reconcile`) — so every
-     * journal-based cost reader (`spentFromJournal`, `trajectoryReport`) sums driver inference
-     * automatically. A leaf never calls this; a driver meters each chat turn and awaits it (the
-     * metered event is cost-critical, so it lands before the join-barrier roll-up).
+     * When the state file exists but cannot be parsed, archive it to
+     * `<filePath>.corrupt-<timestamp>` and start empty instead of
+     * throwing `DelegationStateCorruptError`. Default false.
      */
-    meter(spend: Spend, detail?: Record<string, unknown>): Promise<void>;
-    /** The live tree — reads the in-memory nursery, not the journal. */
-    readonly view: TreeView;
-    /** Conserved-pool readouts (post-reservation). */
-    readonly budget: Readonly<{
-        tokensLeft: number;
-        usdLeft: number;
-        usdCapped: boolean;
-        deadlineMs: number;
-        reservedTokens: number;
-    }>;
-}
-interface NodeSnapshot {
-    readonly id: NodeId;
-    readonly parent?: NodeId;
-    readonly label: string;
-    readonly status: NodeStatus;
-    readonly runtime: Runtime;
-    readonly budget: Budget;
-    /** Conserved spend so far for this node. */
-    readonly spent: Spend;
-    /** `outRef` once the node is `done` (the replay/result pointer). */
-    readonly outRef?: string;
-}
-/** The live tree — what `scope.view` / `RootHandle.view()` materialize for a viewer. */
-interface TreeView {
-    readonly root: NodeId;
-    readonly nodes: ReadonlyArray<NodeSnapshot>;
-    /** Count of nodes in `running` or `acquiring` — the "what's in flow?" answer. */
-    readonly inFlight: number;
-}
-/** Journaled spawn-tree events (B1/B2). `seq` is the cursor order; `at` is an ISO
- *  timestamp for human inspection only (NOT a replay input). */
-type SpawnEvent = {
-    kind: 'spawned';
-    id: NodeId;
-    parent?: NodeId;
-    label: string;
-    budget: Budget;
-    runtime: Runtime;
-    seq: number;
-    at: string;
-} | {
-    kind: 'settled';
-    id: NodeId;
-    status: 'done' | 'down';
-    /** Content-addressed result pointer; rehydrates `out` from `ResultBlobStore`. */
-    outRef?: string;
-    verdict?: DefaultVerdict;
-    spent: Spend;
-    infra?: boolean;
-    seq: number;
-    at: string;
-} | {
-    kind: 'cancelled';
-    id: NodeId;
-    reason: string;
-    seq: number;
-    at: string;
-} | {
-    /** A driver's OWN inference spend, journaled separately from spawned-child work — the journal
-     *  TWIN of `BudgetPool.observe`, exactly as `settled` is the twin of `reconcile`. So every
-     *  journal-based cost reader sums it automatically — the journal is the single cost ledger.
-     *  It carries spend only and is NOT a settlement: replay + `materializeTreeView` skip it for
-     *  structure, and its `seq` lives outside the cursor-uniqueness namespace. A
-     *  driver re-homes its nested subtree's metered total up to its parent (like settled spend),
-     *  so summing any sub-tree root yields that sub-tree's true driver-inference cost. */
-    kind: 'metered';
-    id: NodeId;
-    spend: Spend;
-    seq: number;
-    at: string;
-};
-/**
- * The spawn-tree event source (mirrors `ConversationJournal`'s begin/append/load shape).
- * `loadTree` replays the full ordered event list for resume/replay; `appendEvent` is
- * called only AFTER the event is observed-committed (never speculative).
- */
-interface SpawnJournal {
-    loadTree(root: NodeId): Promise<SpawnEvent[] | undefined>;
-    beginTree(root: NodeId, at: string): Promise<void>;
-    appendEvent(root: NodeId, ev: SpawnEvent): Promise<void>;
-}
-/** Content-addressed result blobs (the `outRef` → artifact map) backing the replay
- *  invariant. Split from the journal so the journal stays small (decisions) and the
- *  payloads (evidence) live where a viewer/replayer rehydrates them. */
-interface ResultBlobStore {
-    put(outRef: string, artifact: unknown): Promise<void>;
-    get(outRef: string): Promise<unknown | undefined>;
+    recoverCorrupt?: boolean;
 }
 /**
- * Owns the conserved pool, the spawn log, the abort cascade, the OTP intensity breaker,
- * and the root handle. `run` executes the root `Agent` to completion; `attach` wires a
- * live `RootHandle` (the Q2 substrate the chat/pi-viz client later consumes).
- */
-interface Supervisor<Task, Out> {
-    run(root: Agent<Task, Out>, task: Task, opts: SupervisorOpts): Promise<SupervisedResult<Out>>;
-    attach(h: RootHandle<Out>): void;
-}
-interface SupervisorOpts {
-    /** The root conserved-pool ceiling (tokens + usd + iterations + deadline). */
-    readonly budget: Budget;
-    /** Trace-correlation root + the journal/blob root key. */
-    readonly runId: NodeId;
-    /** Event source — defaults to the in-memory journal in the impl; pass JSONL/FS for durability. */
-    readonly journal: SpawnJournal;
-    /** Result payload store backing `outRef` rehydration. */
-    readonly blobs: ResultBlobStore;
-    /** Executor resolution — the open registry mapping `AgentSpec` → `Executor`. */
-    readonly executors: ExecutorRegistry;
-    /** Runtime recursion-depth ceiling (paired with the conserved pool per R3). */
-    readonly maxDepth?: number;
-    /**
-     * OTP intensity breaker: more than `maxRestarts` child restarts within `withinMs`
-     * trips the supervisor to `no-winner` rather than restarting forever.
-     */
-    readonly maxRestarts?: number;
-    readonly withinMs?: number;
-    readonly now?: () => number;
-    readonly signal?: AbortSignal;
-    /** Lifecycle stream sink, threaded into the root `Scope` so every `spawn`/settle emits on the
-     *  same `agent.spawn`/`agent.child` stream `runLoop` feeds — one observable recursive tree. */
-    readonly hooks?: RuntimeHooks;
-}
-/** Typed terminal result (M2) — a no-winner is NEVER coerced to a best-effort output. */
-type SupervisedResult<Out> = {
-    kind: 'winner';
-    out: Out;
-    outRef: string;
-    verdict?: DefaultVerdict;
-    tree: TreeView;
-    spentTotal: Spend;
-    /** Where `spentTotal` went: `driverInference` = the drivers' own chat turns (metered via
-     *  `Scope.meter`); `childWork` = every spawned child's reconciled spend (the journal sum).
-     *  `driverInference + childWork === spentTotal`. Present whenever any driver metered. */
-    spentBreakdown?: {
-        driverInference: Spend;
-        childWork: Spend;
-    };
-} | {
-    kind: 'no-winner';
-    reason: 'all-children-down' | 'budget-exhausted' | 'aborted';
-    tree: TreeView;
-    downCount: number;
-    /** The conserved spend incurred before the run failed — real cost is paid even when no
-     *  worker delivers, so the caller always learns what the delegation actually spent. Summed
-     *  off the same journal the `winner` path reads. */
-    spentTotal: Spend;
-};
-/** Live root handle — the substrate a chat/pi-viz client attaches to (Q2). `signal`
- *  delivers an out-of-band message to the running root; `view()` materializes the tree. */
-interface RootHandle<Out> {
-    view(): TreeView;
-    signal(msg: RootSignal): void;
-    abort(reason?: string): void;
-    /** Phantom: binds the handle to the supervised run's output type. Type-only — never
-     *  present at runtime; lets `attach(h: RootHandle<Out>)` stay output-typed. */
-    readonly __out?: Out;
-}
-/** Out-of-band message to a running root. Open by intent — a client extends it. */
-type RootSignal = {
-    kind: 'pause';
-} | {
-    kind: 'resume';
-} | {
-    kind: 'cancel';
-    reason?: string;
-} | {
-    kind: 'ask';
-    question: string;
-};
-/**
- * The progressive-widening gate (MCTS-PW). Decides whether a settled child is
- * `promising` enough to spawn another under the remaining pool. DEFAULTS TO FLAT
- * (`shouldWiden` always false) so a gate run never widens and the selector≠judge
- * firewall conflict (R2) stays dormant. When widening IS enabled, `promising` MUST be
- * derived from TRACE findings (`analyses`), never raw `verdict` — or the gate carries
- * an explicit, argued `judgeExempt: true` (the documented escape hatch, off by default).
+ * JSON-file persistence for the delegation queue. Each write serializes
+ * the full record set and lands it atomically (write to a sibling tmp
+ * file, then `rename`), so readers never observe a torn file — a crash
+ * mid-write leaves the previous snapshot intact. Writes are serialized
+ * internally; concurrent `upsert`/`remove` calls cannot interleave.
+ *
+ * Built for the MCP server's scale (one stdio process, hundreds of
+ * records): full-snapshot writes keep the format trivially inspectable
+ * and corruption-detectable without a database dependency.
+ *
+ * @experimental
  */
-interface WidenGate<Out> {
-    /** Default impl returns false for every settlement (flat — never widens). */
-    shouldWiden(settled: Settled<Out>, budget: Scope<Out>['budget']): boolean;
-    /** When true, widening may read `verdict` directly (collides with the steer firewall —
-     *  must be explicitly argued per cell, never defaulted on). */
-    readonly judgeExempt?: boolean;
+declare class FileDelegationStore implements DelegationStore {
+    private readonly filePath;
+    private readonly recoverCorrupt;
+    private readonly records;
+    private loaded;
+    private writeTail;
+    private tmpSeq;
+    constructor(options: FileDelegationStoreOptions);
+    loadAll(): Promise<DelegationRecord[]>;
+    upsert(record: DelegationRecord): Promise<void>;
+    lookupIdempotencyKey(key: string): Promise<string | undefined>;
+    remove(taskIds: readonly string[]): Promise<void>;
+    private assertLoaded;
+    private enqueueWrite;
+    private writeSnapshot;
 }
 
 /**
@@ -683,45 +336,50 @@ declare function composeLoopTraceEmitters(...emitters: ReadonlyArray<LoopTraceEm
 /**
  * @experimental
  *
- * Sandbox-session coder decode layer. The sandbox-session delegate (`./delegates`) and the
- * cross-restart resume driver (`./bin`) run the in-box harness over a `SandboxClient` and need to
- * (a) build an `AgentRunSpec` from the authored coder profile, (b) decode the harness event stream
- * into a structured `CoderOutput`, and (c) gate it with the shared mechanical checks. This is the
- * MCP server's built-in `delegate_code` path — it is the live default delegate, NOT dormant — and is
- * kept separate from the generic recursive path: `worktreeFanout` instead settles the raw
- * `WorktreePatchArtifact` and gates via `patchDelivered`. Only the OPTIONAL cross-restart resume
- * (the `driveTurn` tick) is opt-in (`MCP_ENABLE_DETACHED_RESUME`); the held-stream delegate is
- * always live. Prefer `worktreeFanout` / `worktreeLoopRunner` for NEW local-repo coding.
+ * Trace context propagation for MCP subprocess.
  *
- * The decode tolerates two `result`-event shapes:
- *   1. the in-process executor's raw worktree-harness result (`{ branch, patch, stats, checks }`),
- *      projected onto `CoderOutput`; and
- *   2. an LLM-emitted JSON block (`{ branch, patch, testResult, typecheckResult, diffStats }`),
- *      lifted onto `data.result` or scanned out of the assistant transcript (any harness shape).
+ * When the MCP server is launched as a child process by a sandbox harness,
+ * the parent passes trace context via environment variables:
+ *
+ *   TRACE_ID=<current-run-trace-id>
+ *   PARENT_SPAN_ID=<span-that-dispatched-the-delegation>
+ *
+ * The MCP server reads these at startup and uses them as the root of its
+ * internal trace tree. All spans emitted by `runLoop` invocations inside
+ * the MCP are children of the parent's delegation span.
+ *
+ * When these env vars are absent, the MCP generates a fresh trace root —
+ * the server operates standalone without trace joining.
  */
 
-/** @experimental The structured coder result the sandbox-session path decodes + gates. */
-interface CoderOutput {
-    /** Branch the agent wrote the patch on. */
-    branch: string;
-    /** Unified diff (`git diff <base>..HEAD`). */
-    patch: string;
-    testResult: {
-        passed: boolean;
-        output: string;
-    };
-    typecheckResult: {
-        passed: boolean;
-        output: string;
-    };
-    diffStats: {
-        filesChanged: number;
-        insertions: number;
-        deletions: number;
-    };
-    /** Optional reviewer commentary surfaced by the agent. */
-    reviewerNotes?: string;
+interface TraceContext {
+    /** Trace id inherited from the parent process, or a fresh one. */
+    traceId: string;
+    /** Parent span id from the delegation that launched this MCP server. */
+    parentSpanId?: string;
 }
+/**
+ * Read trace context from the process environment.
+ * Returns a context with inherited ids or a freshly generated root.
+ */
+declare function readTraceContextFromEnv(): TraceContext;
+/**
+ * Create a LoopTraceEmitter that:
+ *   1. Parents all spans under the inherited PARENT_SPAN_ID.
+ *   2. Exports spans to OTEL when OTEL_EXPORTER_OTLP_ENDPOINT is set.
+ *
+ * Returns both the emitter and the optional exporter handle for shutdown.
+ */
+declare function createPropagatingTraceEmitter(ctx: TraceContext): {
+    emitter: LoopTraceEmitter;
+    exporter: OtelExporter | undefined;
+    context: TraceContext;
+};
+/**
+ * Build env vars to pass to a child MCP subprocess so it inherits the
+ * current trace context.
+ */
+declare function traceContextToEnv(ctx: TraceContext): Record<string, string>;
 
 /**
  * @experimental
@@ -980,377 +638,36 @@ interface DelegationHistoryArgs {
 /** @experimental */
 interface DelegationFeedbackSnapshot {
     id: string;
-    score: number;
-    label?: FeedbackRating['label'];
-    by: DelegateFeedbackArgs['by'];
-    notes: string;
-    capturedAt: string;
-}
-/** @experimental */
-interface DelegationHistoryEntry {
-    taskId: string;
-    profile: DelegationProfile;
-    namespace?: string;
-    args: DelegateCodeArgs | DelegateResearchArgs | DelegateUiAuditArgs;
-    status: DelegationStatus;
-    feedback?: DelegationFeedbackSnapshot[];
-    costUsd?: number;
-    startedAt: string;
-    completedAt?: string;
-    /**
-     * True when the record carries a journaled loop trace. History stays
-     * light by design — fetch the spans via
-     * `delegation_status { taskId, includeTrace: true }`.
-     */
-    hasTrace: boolean;
-    /** Inherited trace identity recorded at submit — join key into the caller's trace. */
-    traceId?: string;
-}
-/** @experimental */
-interface DelegationHistoryResult {
-    delegations: DelegationHistoryEntry[];
-}
-
-/**
- * @experimental
- *
- * Persistence port for the MCP delegation queue.
- *
- * `DelegationTaskQueue` keeps its working set in memory (status/history
- * reads stay synchronous) and journals every record mutation through a
- * `DelegationStore`. `DelegationTaskQueue.restore({ store })` is the load
- * path: it reads the full record set once at construction and rehydrates
- * the queue from it. After that the store only sees writes.
- *
- * Records MUST be JSON-safe — `FileDelegationStore` round-trips them
- * through `JSON.stringify`/`JSON.parse`, so a `Date`, `Map`, or function
- * smuggled into `args`/`result` would corrupt the journal.
- */
-
-/** @experimental */
-interface DelegationStore {
-    /**
-     * Read every persisted record. Called once, by
-     * `DelegationTaskQueue.restore`, before any write. A missing backing
-     * file is an empty store; an unparseable one throws
-     * `DelegationStateCorruptError`.
-     */
-    loadAll(): Promise<DelegationRecord[]>;
-    /** Insert or replace the record keyed by `record.taskId`. */
-    upsert(record: DelegationRecord): Promise<void>;
-    /**
-     * Resolve an idempotency key to the taskId that claimed it, if any.
-     * The queue serves submit-time dedupe from its rehydrated in-memory
-     * index; this read exists for consumers that share a store across
-     * processes without holding the full record set.
-     */
-    lookupIdempotencyKey(key: string): Promise<string | undefined>;
-    /** Delete the named records — the retention-cap eviction path. */
-    remove(taskIds: readonly string[]): Promise<void>;
-}
-/**
- * The persisted delegation state exists but cannot be parsed into
- * records. Fail loud: silently starting empty over a corrupt journal
- * would erase delegation history and re-run idempotent work. Opt into
- * recovery explicitly via `FileDelegationStoreOptions.recoverCorrupt`
- * (the bin maps `AGENT_RUNTIME_DELEGATION_STATE_RECOVER=1` onto it),
- * which archives the corrupt file and starts fresh.
- *
- * @experimental
- */
-declare class DelegationStateCorruptError extends AgentEvalError {
-    constructor(message: string, options?: {
-        cause?: unknown;
-    });
-}
-/**
- * A delegation-store read or write failed (filesystem error, store
- * called before `loadAll`, ...). Once the queue observes one, it stops
- * accepting new submissions — accepting work it cannot journal would
- * silently demote durable mode to in-memory mode.
- *
- * @experimental
- */
-declare class DelegationPersistenceError extends AgentEvalError {
-    constructor(message: string, options?: {
-        cause?: unknown;
-    });
-}
-/** @experimental */
-declare class InMemoryDelegationStore implements DelegationStore {
-    private readonly records;
-    loadAll(): Promise<DelegationRecord[]>;
-    upsert(record: DelegationRecord): Promise<void>;
-    lookupIdempotencyKey(key: string): Promise<string | undefined>;
-    remove(taskIds: readonly string[]): Promise<void>;
-}
-/** @experimental */
-interface FileDelegationStoreOptions {
-    /** Absolute path of the JSON state file. Parent directories are created on first write. */
-    filePath: string;
-    /**
-     * When the state file exists but cannot be parsed, archive it to
-     * `<filePath>.corrupt-<timestamp>` and start empty instead of
-     * throwing `DelegationStateCorruptError`. Default false.
-     */
-    recoverCorrupt?: boolean;
-}
-/**
- * JSON-file persistence for the delegation queue. Each write serializes
- * the full record set and lands it atomically (write to a sibling tmp
- * file, then `rename`), so readers never observe a torn file — a crash
- * mid-write leaves the previous snapshot intact. Writes are serialized
- * internally; concurrent `upsert`/`remove` calls cannot interleave.
- *
- * Built for the MCP server's scale (one stdio process, hundreds of
- * records): full-snapshot writes keep the format trivially inspectable
- * and corruption-detectable without a database dependency.
- *
- * @experimental
- */
-declare class FileDelegationStore implements DelegationStore {
-    private readonly filePath;
-    private readonly recoverCorrupt;
-    private readonly records;
-    private loaded;
-    private writeTail;
-    private tmpSeq;
-    constructor(options: FileDelegationStoreOptions);
-    loadAll(): Promise<DelegationRecord[]>;
-    upsert(record: DelegationRecord): Promise<void>;
-    lookupIdempotencyKey(key: string): Promise<string | undefined>;
-    remove(taskIds: readonly string[]): Promise<void>;
-    private assertLoaded;
-    private enqueueWrite;
-    private writeSnapshot;
-}
-
-/**
- * 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;
+    score: number;
+    label?: FeedbackRating['label'];
+    by: DelegateFeedbackArgs['by'];
+    notes: string;
+    capturedAt: string;
 }
-interface EvalRunsExportResult {
-    ok: boolean;
-    status: number;
-    accepted: number;
-    rejected: Array<{
-        index: number;
-        reason: string;
-    }>;
+/** @experimental */
+interface DelegationHistoryEntry {
+    taskId: string;
+    profile: DelegationProfile;
+    namespace?: string;
+    args: DelegateCodeArgs | DelegateResearchArgs | DelegateUiAuditArgs;
+    status: DelegationStatus;
+    feedback?: DelegationFeedbackSnapshot[];
+    costUsd?: number;
+    startedAt: string;
+    completedAt?: string;
+    /**
+     * True when the record carries a journaled loop trace. History stays
+     * light by design — fetch the spans via
+     * `delegation_status { taskId, includeTrace: true }`.
+     */
+    hasTrace: boolean;
+    /** Inherited trace identity recorded at submit — join key into the caller's trace. */
+    traceId?: 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>;
-
-/**
- * @experimental
- *
- * Trace context propagation for MCP subprocess.
- *
- * When the MCP server is launched as a child process by a sandbox harness,
- * the parent passes trace context via environment variables:
- *
- *   TRACE_ID=<current-run-trace-id>
- *   PARENT_SPAN_ID=<span-that-dispatched-the-delegation>
- *
- * The MCP server reads these at startup and uses them as the root of its
- * internal trace tree. All spans emitted by `runLoop` invocations inside
- * the MCP are children of the parent's delegation span.
- *
- * When these env vars are absent, the MCP generates a fresh trace root —
- * the server operates standalone without trace joining.
- */
-
-interface TraceContext {
-    /** Trace id inherited from the parent process, or a fresh one. */
-    traceId: string;
-    /** Parent span id from the delegation that launched this MCP server. */
-    parentSpanId?: string;
+/** @experimental */
+interface DelegationHistoryResult {
+    delegations: DelegationHistoryEntry[];
 }
-/**
- * Read trace context from the process environment.
- * Returns a context with inherited ids or a freshly generated root.
- */
-declare function readTraceContextFromEnv(): TraceContext;
-/**
- * Create a LoopTraceEmitter that:
- *   1. Parents all spans under the inherited PARENT_SPAN_ID.
- *   2. Exports spans to OTEL when OTEL_EXPORTER_OTLP_ENDPOINT is set.
- *
- * Returns both the emitter and the optional exporter handle for shutdown.
- */
-declare function createPropagatingTraceEmitter(ctx: TraceContext): {
-    emitter: LoopTraceEmitter;
-    exporter: OtelExporter | undefined;
-    context: TraceContext;
-};
-/**
- * Build env vars to pass to a child MCP subprocess so it inherits the
- * current trace context.
- */
-declare function traceContextToEnv(ctx: TraceContext): Record<string, string>;
 
 /**
  * @experimental
@@ -1660,128 +977,6 @@ declare class DelegationTaskQueue {
  */
 declare function hashIdempotencyInput(value: unknown): string;
 
-/**
- * @experimental
- *
- * The completion-oracle: **settled ⟺ DELIVERED.**
- *
- * Foreman's one hard lesson (0/18 self-improvement deliverables) — "done" must mean a check
- * PASSED, not the agent's say-so. `gateOnDeliverable` wraps an `Executor` so its settlement
- * is `valid` ONLY when the deliverable check passes. The child still RUNS and settles (its
- * spend is conserved into the pool either way), but a child that ran WITHOUT delivering
- * settles `valid:false` — so a keep-best driver never counts it as done, and a gate never
- * inflates with self-judged wins.
- *
- * Dual-purpose by construction:
- *  - product: the agent fleet only advances on real, checked deliverables.
- *  - proof: the gate's `valid` is the honest settle — equal-k comparisons can't be gamed by an
- *    arm that "ran" without producing the artifact.
- *
- * The check is a DEPLOYABLE oracle — a test command, a state verifier, the commit0 judge —
- * read off the child's output, never the model judging itself. A throwing check is
- * fail-closed (not delivered), never a crash.
- */
-
-/**
- * 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>;
-
-/**
- * @experimental
- *
- * Git worktree helpers for the in-process delegation executor. Each
- * delegation runs in its own worktree so multiple parallel harness
- * subprocesses (claude / codex / opencode in a 3-way fanout) don't clobber
- * each other's edits on the shared workspace.
- *
- * Worktrees live under `<repoRoot>/.agent-worktrees/<runId>/`. After the
- * harness exits + the diff is captured, the worktree is removed.
- *
- * All operations spawn `git` via `child_process.spawn` synchronously
- * (via a `runGit` helper). Stays narrow on purpose: no commits, no rebases.
- * Diff capture stages all changes (`git add -A`) into the ephemeral worktree's
- * index so created (untracked) files appear in the `--cached` diff.
- */
-/** @experimental */
-interface WorktreeHandle {
-    /** Absolute path to the worktree directory. */
-    path: string;
-    /** SHA the worktree was created at. */
-    baseSha: string;
-    /** Branch name created for this worktree (typically `delegate/<runId>`). */
-    branch: string;
-}
-/** @experimental */
-interface CreateWorktreeOptions {
-    /** Absolute path to the main git checkout. */
-    repoRoot: string;
-    /** Unique id for the worktree path + branch. Use the delegation run id. */
-    runId: string;
-    /** Parent directory the worktree lives under. Defaults to `.agent-worktrees`. */
-    variantsDir?: string;
-    /** Override the base ref (default `HEAD`). */
-    baseRef?: string;
-    /** Test seam — inject a custom git runner. */
-    runGit?: GitRunner;
-}
-/** @experimental */
-interface DiffOptions {
-    /** Worktree to diff. */
-    worktree: WorktreeHandle;
-    /** What to compare against. Default `worktree.baseSha`. */
-    baseRef?: string;
-    /** Test seam. */
-    runGit?: GitRunner;
-}
-/** @experimental */
-interface DiffResult {
-    patch: string;
-    stats: {
-        filesChanged: number;
-        insertions: number;
-        deletions: number;
-    };
-}
-/** @experimental */
-interface RemoveWorktreeOptions {
-    worktree: WorktreeHandle;
-    repoRoot: string;
-    /** Force removal even if dirty (default true; the loser of a fanout has uncommitted changes). */
-    force?: boolean;
-    /** Test seam. */
-    runGit?: GitRunner;
-}
-/** Pluggable git runner (sync) — replaceable in tests. */
-type GitRunner = (args: ReadonlyArray<string>, opts: {
-    cwd: string;
-}) => {
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-};
-/** @experimental */
-declare function createWorktree(options: CreateWorktreeOptions): Promise<WorktreeHandle>;
-/** @experimental */
-declare function captureWorktreeDiff(options: DiffOptions): Promise<DiffResult>;
-/** @experimental */
-declare function removeWorktree(options: RemoveWorktreeOptions): Promise<void>;
-
 /**
  * @experimental
  *
@@ -2083,29 +1278,21 @@ declare function createFleetWorkspaceExecutor(options: FleetWorkspaceExecutorOpt
 /**
  * @experimental
  *
- * Delegate factories — the layer between MCP tool handlers and the
- * underlying `runLoop` runners.
- *
- * Delegation vs COORDINATION (`../runtime/supervise/coordination-mcp.ts`): delegation runs a coding
- * task INSIDE the agent's OWN sandbox environment — a sibling box on its own `SandboxClient`, fresh
- * branch on its repo — as a durable, fire-and-poll job that survives an MCP restart. It is NOT
- * backend-pluggable. To instead SPAWN + live-drive workers in a CHOSEN backend (sandbox OR cli-bridge,
- * via `createExecutor({ backend })`) with observe/steer/resume + recursion, use the coordination MCP.
- *
- * The MCP server is profile-agnostic: it owns the task queue + feedback
- * store + transport. Each `*Delegate` is the closure that the queue
- * invokes when a task runs. Consumers can override either delegate to
- * inject custom drivers, mocks, fleet-aware dispatchers, etc.
- *
- * The `detachedSessionDelegate` here is the built-in SANDBOX-SESSION coder path — the live default
- * `delegate_code` delegate: workers run the in-box harness over a `SandboxClient`. By default it
- * holds the stream; single-variant turns can OPTIONALLY dispatch DETACHED (`driveTurn` ticks) so a
- * durable queue resumes them across an MCP restart — that resume tick is the only part gated behind
- * `MCP_ENABLE_DETACHED_RESUME` (default off) in `bin.ts`, a capability the recursive
- * `Scope`/worktree-CLI leaf has no durable equivalent for yet. For NEW local-repo coding use
- * `worktreeFanout` / `worktreeLoopRunner`. The default researcher delegate is **not** wired in this
- * file — `agent-knowledge` cannot be imported from `agent-runtime` without inducing a cycle.
- * Consumers pass `researcherDelegate` explicitly.
+ * `detachedSessionDelegate` — the sandbox-session coder delegate: a closure that drives `runLoop`
+ * against a `SandboxClient` + a caller-supplied (or minimal model-only default) worker profile, to a
+ * mechanically-validated `CoderOutput`. The caller invokes the returned delegate directly with its
+ * coder args; when wired into a durable queue it also settles cross-restart-resumed records.
+ *
+ * Delegation vs COORDINATION (`../runtime/supervise/coordination-mcp.ts`): this delegate runs a
+ * coding task INSIDE the agent's OWN sandbox environment — a sibling box on its own `SandboxClient`,
+ * fresh branch on its repo. It is NOT backend-pluggable. To instead SPAWN + live-drive workers in a
+ * CHOSEN backend (sandbox OR cli-bridge, via `createExecutor({ backend })`) with observe/steer/resume
+ * + recursion, use `delegate()` / the coordination MCP.
+ *
+ * The worker profile is a parameter the caller supplies (§1.5: the system authors profiles). When
+ * none is passed, a minimal model-only default profile is materialized in `./detached-coder` — no
+ * hardcoded skills or tools. For NEW local-repo coding use `worktreeFanout` / `worktreeLoopRunner`
+ * (author one `AgentProfile` per harness → `createWorktreeCliExecutor` leaves → `gateOnDeliverable`).
  */
 
 /** @experimental */
@@ -2129,11 +1316,10 @@ interface DelegateRunCtx {
      */
     traceEmitter?: LoopTraceEmitter;
 }
-/** @experimental The server's coder-profile delegate slot — the closure the queue invokes for a
- *  `delegate_code` task. `detachedSessionDelegate` is the built-in implementation. */
+/** @experimental The coder delegate closure — given the coder args + run context, drives the
+ *  sandbox-session coder path to a validated `CoderOutput`. `detachedSessionDelegate` is the
+ *  built-in implementation; the queue invokes one of these per coder delegation. */
 type CoderDelegate = (args: DelegateCodeArgs, ctx: DelegateRunCtx) => Promise<CoderOutput>;
-/** @experimental */
-type ResearcherDelegate = (args: DelegateResearchArgs, ctx: DelegateRunCtx) => Promise<ResearchOutputShape>;
 /**
  * UI-auditor delegate — fully consumer-injected. agent-runtime ships no
  * default factory because the inputs are workspace path + judge function
@@ -2188,14 +1374,22 @@ interface DetachedSessionDelegateOptions {
      * `executor: createSiblingSandboxExecutor({ client: sandboxClient })`.
      */
     sandboxClient?: SandboxClient;
-    /** Backend harness for the single-coder path. Default comes from `coderProfile`. */
+    /**
+     * The worker's authored `AgentProfile` (§1.5: the system authors profiles). Spread onto the
+     * sandbox-session run spec → `runLoop` → the executor's `harnessInvocation`, so the harness runs
+     * under the caller's stance. Omit to use a minimal model-only default (no hardcoded skills/tools);
+     * `harness` / `model` / `systemPrompt` below are convenience overrides layered onto whichever
+     * profile is used.
+     */
+    workerProfile?: AgentProfile;
+    /** Backend harness for the single-coder path (sets `metadata.backendType`). Default `claude-code`. */
     harness?: string;
     /** Model override for the single-coder path. */
     model?: string;
     /**
-     * The worker's authored system prompt (§1.5). Flows onto `coderProfile`'s
+     * The worker's authored system prompt (§1.5). Flows onto the run spec's
      * `profile.prompt.systemPrompt` → through `runLoop` → the executor's `harnessInvocation`, so the
-     * harness runs under this stance, not just the default coder prompt. Omit to keep the default.
+     * harness runs under this stance. Omit to keep the profile's own prompt.
      */
     systemPrompt?: string;
     /** Default `['claude-code', 'codex', 'opencode/zai-coding-plan/glm-5.1']` when variants > 1. */
@@ -2285,4 +1479,586 @@ interface SettleDetachedCoderTurnOptions {
  */
 declare function settleDetachedCoderTurn(turn: DetachedTurn, options: SettleDetachedCoderTurnOptions): Promise<CoderOutput>;
 
-export { type DelegationHistoryEntry as $, type Agent as A, type Budget as B, type CoderReviewer as C, type DelegateCodeArgs as D, type ExecutorFactory as E, type FleetHandle as F, type GitRunner as G, type DelegationHistoryArgs as H, type DelegationStatusResult as I, type DelegationStatusArgs as J, type CappedDelegationTrace as K, type LocalHarness as L, type CoderReview as M, type NodeId as N, type CreateWorktreeOptions as O, DELEGATION_TRACE_MAX_BYTES as P, DELEGATION_TRACE_MAX_SPANS as Q, type ResearcherDelegate as R, type Spend as S, type TraceContext as T, type UiAuditorDelegate as U, type DelegateCodeConfig as V, type DelegateResearchConfig as W, type DelegateRunCtx as X, type DelegateUiAuditConfig as Y, type DelegateUiAuditRoute as Z, type DelegationError as _, type DetachedWinnerSelection as a, type EvalRunGeneration as a$, DelegationPersistenceError as a0, type DelegationProfile as a1, type DelegationProgress as a2, type DelegationRecord as a3, type DelegationResultPayload as a4, type DelegationResumeContext as a5, type DelegationResumeDriver as a6, type DelegationResumeTick as a7, type DelegationRunContext as a8, DelegationStateCorruptError as a9, type SiblingSandboxExecutorOptions as aA, type SubmitInput as aB, type SubmitOutput as aC, type UiAuditorDelegationOutput as aD, type WorktreeHandle as aE, buildDelegationTraceSpans as aF, capDelegationTrace as aG, captureWorktreeDiff as aH, coderTaskFromArgs as aI, composeLoopTraceEmitters as aJ, createDelegationTraceCollector as aK, createDetachedTurnResumeDriver as aL, createFleetWorkspaceExecutor as aM, createPropagatingTraceEmitter as aN, createSiblingSandboxExecutor as aO, createWorktree as aP, detachedSessionDelegate as aQ, detachedTurnEvents as aR, formatDetachedSessionRef as aS, hashIdempotencyInput as aT, parseDetachedSessionRef as aU, readTraceContextFromEnv as aV, removeWorktree as aW, runDetachedTurn as aX, settleDetachedCoderTurn as aY, traceContextToEnv as aZ, type EvalRunEvent as a_, type DelegationStatus as aa, type DelegationStore as ab, type DelegationTaskQueueOptions as ac, type DelegationTraceCaps as ad, type DelegationTraceCollector as ae, type DelegationTraceSpan as af, type DetachedSessionDelegateOptions as ag, type DetachedSessionRefParts as ah, type DetachedTurn as ai, type DetachedTurnResumeDriverOptions as aj, type DiffOptions as ak, type DiffResult as al, type DriveTurnCapableBox as am, type DriveTurnTick as an, type FeedbackRating as ao, type FeedbackRefersTo as ap, FileDelegationStore as aq, type FileDelegationStoreOptions as ar, type FleetWorkspaceExecutorOptions as as, InMemoryDelegationStore as at, type LocalHarnessResult as au, type RemoveWorktreeOptions as av, type ResearchOutputShape as aw, type RunDetachedTurnOptions as ax, type RunLocalHarnessOptions as ay, type SettleDetachedCoderTurnOptions as az, type CoderOutput as b, type EvalRunsExportConfig as b0, type EvalRunsExportResult as b1, INTELLIGENCE_WIRE_VERSION as b2, type LoopSpanNode as b3, type OtelAttribute as b4, type OtelExportConfig as b5, type OtelExporter as b6, type OtelSpan as b7, buildLoopOtelSpans as b8, buildLoopSpanNodes as b9, createOtelExporter as ba, exportEvalRuns as bb, loopEventToOtelSpan as bc, type SpawnEvent as bd, type UsageEvent as be, type Supervisor as bf, type ExecutorContext as bg, type ExecutorResult as bh, type SupervisorOpts as bi, type TreeView as bj, type WidenGate as bk, gateOnDeliverable as bl, type DelegateFeedbackArgs as c, type DelegationFeedbackSnapshot as d, type ExecutorRegistry as e, type DeliverableSpec as f, DelegationTaskQueue as g, type CoderDelegate as h, type Scope as i, type ResultBlobStore as j, type AgentSpec as k, type SpawnJournal as l, type RootHandle as m, type SupervisedResult as n, type Settled as o, type Executor as p, type DelegationExecutor as q, runLocalHarness as r, type DelegateCodeResult as s, type DelegateFeedbackResult as t, type ResearchSource as u, type DelegateResearchArgs as v, type DelegateResearchResult as w, type DelegateUiAuditArgs as x, type DelegateUiAuditResult as y, type DelegationHistoryResult as z };
+/**
+ * @experimental
+ *
+ * Feedback persistence surface for the MCP layer.
+ *
+ * The substrate cannot import `@tangle-network/agent-knowledge` (it would
+ * induce a dependency cycle), so the store is an abstract interface. The
+ * default implementation is in-memory; consumers wire their own adapter
+ * (a real KbStore-backed sink, an HTTP relay to gtm-agent's knowledge
+ * service, etc.) via `createMcpServer({ feedbackStore })`.
+ *
+ * Feedback events are append-only: every rating is a new event with a
+ * fresh id, even when the same delegation is rated multiple times. The
+ * caller decides how to roll up scores downstream.
+ */
+
+/** @experimental */
+interface FeedbackEvent {
+    id: string;
+    refersTo: DelegateFeedbackArgs['refersTo'];
+    rating: DelegateFeedbackArgs['rating'];
+    by: DelegateFeedbackArgs['by'];
+    capturedAt: string;
+    namespace?: string;
+}
+/** @experimental */
+interface FeedbackStore {
+    /** Append a new event. Never dedupes — every rating is its own event. */
+    put(event: FeedbackEvent): Promise<void>;
+    /**
+     * List events filtered by `namespace`. When `namespace` is omitted, list
+     * across all namespaces. Returns events in insertion order.
+     */
+    list(filter?: {
+        namespace?: string;
+        refersToRef?: string;
+    }): Promise<FeedbackEvent[]>;
+}
+/** @experimental */
+declare class InMemoryFeedbackStore implements FeedbackStore {
+    private readonly events;
+    put(event: FeedbackEvent): Promise<void>;
+    list(filter?: {
+        namespace?: string;
+        refersToRef?: string;
+    }): Promise<FeedbackEvent[]>;
+}
+/**
+ * Project a `FeedbackEvent` down to the snapshot shape carried on
+ * `delegation_history` entries.
+ *
+ * @experimental
+ */
+declare function eventToSnapshot(event: FeedbackEvent): DelegationFeedbackSnapshot;
+
+/**
+ * @experimental
+ *
+ * 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.
+ */
+
+/**
+ * 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;
+    harness: LocalHarness;
+    taskPrompt: string;
+    runId?: string;
+    baseRef?: string;
+    harnessTimeoutMs?: 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;
+    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;
+}
+/**
+ * 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: '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;
+
+/**
+ * @experimental
+ *
+ * `delegate` MCP tool — the ONE generic delegation verb, the agent-facing front door to
+ * `delegate()` / `supervise()`. The agent hands it an INTENT (what it wants done); a default
+ * authoring supervisor decomposes the intent and AUTHORS the worker profile it needs — there is no
+ * hardcoded coder/researcher profile. It is the generic replacement for `delegate_code` /
+ * `delegate_research`.
+ *
+ * Unlike those async, queue-backed tools (kick off → return a taskId → poll `delegation_status`),
+ * `delegate` is SYNCHRONOUS: it awaits the full supervised run and returns the delivered output
+ * TOGETHER WITH `spentTotal` — the conserved cost of the whole delegation (`iterations` / `tokens` /
+ * `usd` / `ms`). Returning the real spend is the whole reason `delegate` beats `delegate_code`,
+ * which has no cost channel.
+ *
+ * The supervisor's substrate (its brain `router`, the worker `backend`, the completion `deliverable`)
+ * is INJECTED at server construction — never an agent-supplied arg — exactly as `delegate_code`
+ * injects its `CoderDelegate`. The agent supplies only the intent (+ an optional per-call `model` /
+ * `runId`).
+ */
+
+/** @experimental */
+declare const DELEGATE_TOOL_NAME = "delegate";
+/** @experimental */
+declare const DELEGATE_DESCRIPTION: string;
+/** @experimental */
+declare const DELEGATE_INPUT_SCHEMA: {
+    readonly type: "object";
+    readonly properties: {
+        readonly intent: {
+            readonly type: "string";
+            readonly description: "What you want accomplished, as an outcome. The supervisor authors the worker.";
+        };
+        readonly model: {
+            readonly type: "string";
+            readonly description: "Optional per-call override for the supervisor brain model.";
+        };
+        readonly runId: {
+            readonly type: "string";
+            readonly description: "Optional trace-correlation id for this delegation.";
+        };
+    };
+    readonly required: readonly ["intent"];
+    readonly additionalProperties: false;
+};
+/** Parsed `delegate` tool arguments. */
+interface DelegateArgs {
+    intent: string;
+    model?: string;
+    runId?: string;
+}
+/** @experimental */
+declare function validateDelegateArgs(raw: unknown): DelegateArgs;
+/** The synchronous result the `delegate` tool returns to the calling agent: the delivered output (or
+ *  the no-winner reason) PLUS the conserved spend of the whole delegation. */
+type DelegateResult = {
+    status: 'winner';
+    out: unknown;
+    outRef: string;
+    spentTotal: Spend;
+} | {
+    status: 'no-winner';
+    reason: string;
+    spentTotal: Spend;
+};
+/** @experimental */
+interface DelegateHandlerOptions {
+    /** The supervisor brain's router substrate (REQUIRED — the default supervisor is router-brained). */
+    router: RouterConfig;
+    /** WHERE the authored workers run. Required for `supervise()` to spawn anything. */
+    backend: ExecutorConfig;
+    /** The completion oracle the authored workers settle against (settled ⟺ delivered). */
+    deliverable?: DeliverableSpec;
+    /** Default supervisor brain model when a call omits `model`. */
+    model?: string;
+    /** Restrict the run to this subset of models. */
+    allowedModels?: readonly string[];
+}
+/**
+ * Build the `delegate` tool handler. Closes over the injected supervisor substrate (`router` /
+ * `backend` / `deliverable`); each call routes the agent's intent to `delegate()` and returns the
+ * delivered output with its conserved cost.
+ */
+declare function createDelegateHandler(options: DelegateHandlerOptions): (raw: unknown) => Promise<DelegateResult>;
+
+/**
+ * @experimental
+ *
+ * Stdio JSON-RPC MCP server exposing the delegation tools to sandbox
+ * coding-harness agents (claude-code, codex, opencode, ...): the generic
+ * `delegate` verb plus the queue-bound `delegate_feedback`,
+ * `delegation_status`, and `delegation_history`. `delegate_ui_audit` is served
+ * when a `uiAuditorDelegate` is wired.
+ *
+ * The server is transport-bound but topology-free: tool execution is
+ * delegated to handler functions composed from a queue, a feedback
+ * store, and the wired run delegates. Consumers wire those at
+ * construction time. The `agent-runtime-mcp` bin serves the generic
+ * `delegate` verb over a real sandbox client when `MCP_ENABLE_DELEGATE=1`.
+ *
+ * Wire protocol: line-delimited JSON-RPC 2.0 over stdio. Each line is
+ * one request; each response is one line. `tools/list` and `tools/call`
+ * mirror the MCP 2024-11-05 spec; we do not pull in
+ * `@modelcontextprotocol/sdk` to keep the dependency footprint zero.
+ */
+
+/** @experimental */
+interface McpServerOptions {
+    /**
+     * Required to enable `delegate` — the ONE generic delegation verb (the replacement for
+     * delegate_code / delegate_research). Inject the supervisor substrate: its brain `router`, the
+     * worker `backend`, and the completion `deliverable`. The supervisor AUTHORS its own worker from
+     * the agent's intent, so there is no worker profile to wire here.
+     */
+    delegateSupervisor?: DelegateHandlerOptions;
+    /**
+     * Required to enable delegate_ui_audit. Wire one that closes over your
+     * `runLoop` + `uiAuditorProfile` + a `SandboxClient` (the
+     * canonical in-process choice is `createInProcessUiAuditClient` from
+     * `@tangle-network/agent-runtime/profiles`) + your vision judge.
+     */
+    uiAuditorDelegate?: UiAuditorDelegate;
+    /** Override the default in-memory feedback store. */
+    feedbackStore?: FeedbackStore;
+    /** Override the default in-memory task queue. */
+    queue?: DelegationTaskQueue;
+    /**
+     * Extra tools to serve alongside the delegation tools, for example
+     * `createCoordinationTools(...).tools`. Registered after the built-ins; a
+     * duplicate name throws so delegation tools cannot be shadowed silently.
+     */
+    extraTools?: McpToolDescriptor[];
+    /**
+     * Inherited trace identity (`readTraceContextFromEnv()`) stamped on every
+     * record the DEFAULT queue creates. Ignored when `queue` is supplied —
+     * pass `traceContext` to that queue's constructor instead.
+     */
+    traceContext?: TraceContext;
+    /** Server display name surfaced via `initialize`. Default `'agent-runtime-mcp'`. */
+    serverName?: string;
+    /** Server version surfaced via `initialize`. Default = the package version baked at build time. */
+    serverVersion?: string;
+}
+/** @experimental */
+interface McpToolDescriptor {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    handler: (raw: unknown) => Promise<unknown>;
+}
+/** @experimental */
+interface McpServer {
+    /** Tools currently registered (depend on which delegates were wired). */
+    readonly tools: ReadonlyMap<string, McpToolDescriptor>;
+    /** The underlying queue — exposed so tests can introspect it. */
+    readonly queue: DelegationTaskQueue;
+    /** The feedback store — exposed for the same reason. */
+    readonly feedbackStore: FeedbackStore;
+    /** Handle a single parsed JSON-RPC message. Returns the response object (or `null` for notifications). */
+    handle(message: JsonRpcMessage): Promise<JsonRpcResponse | null>;
+    /** Drive the server on a stdio-shaped transport until `stop()` is called. */
+    serve(transport?: McpTransport): Promise<void>;
+    /** Stop a `serve` call. Subsequent requests are rejected. */
+    stop(): void;
+}
+/** @experimental */
+interface McpTransport {
+    input: NodeJS.ReadableStream;
+    output: NodeJS.WritableStream;
+}
+/** @experimental */
+interface JsonRpcMessage {
+    jsonrpc: '2.0';
+    id?: number | string | null;
+    method: string;
+    params?: unknown;
+}
+/** @experimental */
+interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: number | string | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+/** @experimental */
+declare function createMcpServer(options?: McpServerOptions): McpServer;
+/**
+ * In-process pair of `Readable` + `Writable` streams suitable for driving
+ * `server.serve(...)` from a test. Returns the agent-side stream (the
+ * client writes to it) and the server-side stream (the test reads from it).
+ *
+ * @experimental
+ */
+declare function createInProcessTransport(): {
+    transport: McpTransport;
+    clientWrite(line: string): void;
+    clientClose(): void;
+    readServer(): Promise<JsonRpcResponse[]>;
+};
+
+/**
+ * @experimental
+ *
+ * MCP binding for a live `Scope`. A sandbox driver gets the same small verbs
+ * the in-process driver has: spawn, observe, await, steer, ask/answer, analyze,
+ * and stop. Settled outputs remain Scope artifacts; product code can project
+ * them into any UI/report envelope it needs.
+ */
+
+/** A worker the driver has drained via `await_event`. */
+interface SettledWorker {
+    readonly id: string;
+    readonly status: 'done' | 'down';
+    readonly score?: number;
+    readonly valid?: boolean;
+    readonly outRef?: string;
+    readonly reason?: string;
+}
+type QuestionLevel = 'worker' | 'driver' | 'loop';
+type QuestionUrgency = 'continue-without' | 'blocks-step' | 'blocks-run';
+interface QuestionOption {
+    readonly label: string;
+    readonly tradeoff: string;
+}
+interface Question {
+    readonly id: string;
+    readonly from: string;
+    readonly level: QuestionLevel;
+    readonly question: string;
+    readonly reason: string;
+    readonly urgency: QuestionUrgency;
+    readonly options?: ReadonlyArray<QuestionOption>;
+}
+type QuestionDecision = {
+    readonly kind: 'answer';
+    readonly answer: string;
+    readonly by: string;
+} | {
+    readonly kind: 'defer';
+    readonly reason: string;
+} | {
+    readonly kind: 'escalate';
+    readonly to: 'parent' | 'user' | string;
+    readonly reason: string;
+};
+interface QuestionRecord extends Question {
+    readonly status: 'open' | 'answered' | 'deferred' | 'escalated';
+    readonly decision?: QuestionDecision;
+    readonly openedAt: number;
+}
+type QuestionPolicy = 'auto' | 'mustDecide' | 'bubble' | 'failClosed';
+interface AnalystRegistry {
+    readonly kinds: ReadonlyArray<{
+        id: string;
+        description: string;
+        area: string;
+    }>;
+    readonly run: (kindId: string, trace: unknown) => Promise<unknown>;
+}
+/** A trace-analyst result re-entered as a message on the bus (the `finding` event kind). */
+interface AnalystFindingEvent {
+    readonly fromWorker: string;
+    readonly analyst: string;
+    readonly findings: unknown;
+}
+/** A parent→child message (the down-leg): recorded for observability, delivered via the child inbox,
+ *  never pulled back by the parent. `delivered` mirrors whether the live child accepted it. */
+interface DownMessageEvent {
+    readonly toWorker: string;
+    readonly instruction: string;
+    readonly delivered: boolean;
+}
+/** Every message on the one typed pipe. UP (child→parent): question / settled / finding — queued for
+ *  the driver to `pull`. DOWN (parent→child): steer / answer — record-only (history + subscribers),
+ *  routed to the child inbox. New kinds are additive. */
+type CoordinationEvent = {
+    readonly type: 'question';
+    readonly question: QuestionRecord;
+} | {
+    readonly type: 'settled';
+    readonly worker: SettledWorker;
+} | {
+    readonly type: 'finding';
+    readonly finding: AnalystFindingEvent;
+} | {
+    readonly type: 'steer';
+    readonly down: DownMessageEvent;
+} | {
+    readonly type: 'answer';
+    readonly down: DownMessageEvent;
+    readonly questionId: string;
+};
+type MakeWorkerAgent = (profile: unknown) => Agent<unknown, unknown>;
+interface CoordinationToolsOptions {
+    readonly scope: Scope<unknown>;
+    readonly blobs: ResultBlobStore;
+    readonly makeWorkerAgent: MakeWorkerAgent;
+    readonly perWorker: Budget;
+    readonly analysts?: AnalystRegistry;
+    readonly onEvent?: (event: CoordinationEvent) => void | Promise<void>;
+    readonly questionPolicy?: QuestionPolicy;
+    /** Analyst kind ids to run AUTOMATICALLY when a worker settles `done` (the analyst-on-settle
+     *  hook). Each result is published as a `finding` event on the bus — pass-through to subscribers
+     *  and queued for the driver to pull via `await_event`. Omit/empty = no auto-analysis (default;
+     *  the driver can still run lenses on demand via `run_analyst`). Requires `analysts`. */
+    readonly analyzeOnSettle?: ReadonlyArray<string>;
+    /** Hard cap on how many workers may be LIVE (spawned but not yet settled) at once. `spawn_agent`
+     *  counts the scope's non-terminal nodes and fails closed (`error: 'max-live-workers'`) BEFORE
+     *  reserving from the pool when the cap is already met — a concurrency fence on top of the
+     *  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;
+}
+/**
+ * The supervisor-side toolbox returned by {@link createCoordinationTools}: the MCP tool
+ * descriptors a driver `AgentProfile` calls to spawn, steer, observe, and settle workers
+ * over a live `Scope`, plus the typed accessors (`settled`/`questions`/`history`/`stats`/
+ * `raiseFinding`) for the bidirectional coordination bus. This is the live, backend-of-your-
+ * choice, steerable counterpart to the one-shot own-sandbox delegation MCP.
+ */
+interface CoordinationTools {
+    readonly tools: McpToolDescriptor[];
+    isStopped(): boolean;
+    stopReason(): string | undefined;
+    settled(): ReadonlyArray<SettledWorker>;
+    questions(): ReadonlyArray<QuestionRecord>;
+    /** The full ordered log of every bus event — UP (settled / question / finding) and DOWN
+     *  (steer / answer) — the observability audit + replay trail. Each record carries seq,
+     *  timestamp, and priority. */
+    history(): ReadonlyArray<BusRecord<CoordinationEvent>>;
+    /** Bus throughput counters (published / pulled / by-kind) for live dashboards. */
+    stats(): BusStats;
+    /** Raise a `finding` on the bus from outside the settle hook — the seam an ONLINE detector
+     *  (mid-run, on the worker pipe) uses to tell the driver "this worker is looping/erroring" the
+     *  moment it happens, instead of only at settle. Queued for `await_event` + pass-through. */
+    raiseFinding(finding: AnalystFindingEvent): Promise<void>;
+}
+/** 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 PublishOptions as b4, cliWorktreeExecutor as b5, createEventBus as b6, createExecutor as b7, createExecutorRegistry as b8, 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 };