@tangle-network/agent-runtime 0.104.0 → 0.106.0

package/dist/mcp/index.d.ts

@@ -1,65 +1,45 @@
-import { a as SandboxClient, b as LoopSandboxPlacement } from '../types-BCoemcXU.js';
-import { F as FleetHandle, D as DelegationExecutor, a as DelegationTaskQueue, b as FeedbackStore, c as DelegateFeedbackResult, d as DelegateFeedbackArgs, U as UiAuditorDelegate, e as DelegateUiAuditArgs, f as DelegateUiAuditResult, g as DelegationHistoryResult, h as DelegationHistoryArgs, i as DelegationStatusResult, j as DelegationStatusArgs } from '../coordination-CxtzMxSM.js';
-export { A as AnalystRegistry, C as CappedDelegationTrace, k as CoderDelegate, l as CoderReview, m as CoderReviewer, n as CoordinationEvent, o as CoordinationTools, p as CoordinationToolsOptions, q as DELEGATE_DESCRIPTION, r as DELEGATE_INPUT_SCHEMA, s as DELEGATE_TOOL_NAME, t as DELEGATION_TRACE_MAX_BYTES, u as DELEGATION_TRACE_MAX_SPANS, v as DelegateArgs, w as DelegateCodeArgs, x as DelegateCodeConfig, y as DelegateCodeResult, z as DelegateHandlerOptions, B as DelegateResearchArgs, G as DelegateResearchConfig, H as DelegateResearchResult, I as DelegateResult, J as DelegateRunCtx, K as DelegateUiAuditConfig, L as DelegateUiAuditRoute, N as DelegationError, O as DelegationFeedbackSnapshot, P as DelegationHistoryEntry, Q as DelegationPersistenceError, R as DelegationProfile, S as DelegationProgress, T as DelegationRecord, V as DelegationResultPayload, X as DelegationResumeContext, Y as DelegationResumeDriver, Z as DelegationResumeTick, _ as DelegationRunContext, $ as DelegationStateCorruptError, a0 as DelegationStatus, a1 as DelegationStore, a2 as DelegationTaskQueueOptions, a3 as DelegationTraceCaps, a4 as DelegationTraceCollector, a5 as DelegationTraceSpan, a6 as DetachedSessionDelegateOptions, a7 as DetachedSessionRefParts, a8 as DetachedTurn, a9 as DetachedTurnResumeDriverOptions, aa as DetachedWinnerSelection, ab as DriveTurnCapableBox, ac as DriveTurnTick, ad as FeedbackEvent, ae as FeedbackRating, af as FeedbackRefersTo, ag as FileDelegationStore, ah as FileDelegationStoreOptions, ai as FleetWorkspaceExecutorOptions, aj as InMemoryDelegationStore, ak as InMemoryFeedbackStore, al as JsonRpcMessage, am as JsonRpcResponse, M as MakeWorkerAgent, an as McpServer, ao as McpServerOptions, ap as McpToolDescriptor, aq as McpTransport, ar as Question, as as QuestionDecision, at as QuestionPolicy, au as QuestionRecord, av as ResearchOutputShape, aw as ResearchSource, ax as RunDetachedTurnOptions, ay as SettleDetachedCoderTurnOptions, az as SettledWorker, aA as SiblingSandboxExecutorOptions, aB as SubmitInput, aC as SubmitOutput, aD as TraceContext, aE as UiAuditorDelegationOutput, aF as buildDelegationTraceSpans, aG as capDelegationTrace, aH as coderTaskFromArgs, aI as composeLoopTraceEmitters, aJ as createCoordinationTools, aK as createDelegateHandler, aL as createDelegationTraceCollector, aM as createDetachedTurnResumeDriver, aN as createFleetWorkspaceExecutor, aO as createInProcessTransport, aP as createMcpServer, aQ as createPropagatingTraceEmitter, aR as createSiblingSandboxExecutor, aS as detachedSessionDelegate, aT as detachedTurnEvents, aU as eventToSnapshot, aV as formatDetachedSessionRef, aW as hashIdempotencyInput, aX as parseDetachedSessionRef, aY as readTraceContextFromEnv, aZ as runDetachedTurn, a_ as settleDetachedCoderTurn, a$ as traceContextToEnv, b0 as validateDelegateArgs } from '../coordination-CxtzMxSM.js';
-import { L as LocalHarness, r as runLocalHarness } from '../local-harness-CtK9dSny.js';
-export { a as CodexExecutionEvidence, c as CodexExecutionPolicy, C as CodexTokenUsage, b as LocalHarnessResult, R as RunLocalHarnessOptions, p as parseCodexTokenUsage } from '../local-harness-CtK9dSny.js';
-import { G as GitRunner } from '../completion-gate-Bv47cOnn.js';
-export { C as CreateWorktreeOptions, b as DiffOptions, c as DiffResult, R as RemoveWorktreeOptions, d as WorktreeHandle, e as captureWorktreeDiff, f as createWorktree, r as removeWorktree } from '../completion-gate-Bv47cOnn.js';
-export { C as CreateKbGateOptions, F as FactCandidate, a as FactJudge, b as FactJudgeVerdict, K as KbGateResult, c as createKbGate } from '../kb-gate-CwHO0vz6.js';
-import { AgentProfileMcpServer } from '@tangle-network/agent-interface';
-export { m as mcpToolsForRuntimeMcp, a as mcpToolsForRuntimeMcpSubset } from '../openai-tools-fnj6SRVg.js';
-import { AnalystFinding } from '@tangle-network/agent-eval';
-import { a as UiLens } from '../substrate-Dyiqmd3o.js';
-import '@tangle-network/sandbox';
-import '../types-BwoZWq-i.js';
-import '../types-CvNwMzQt.js';
-import '../sanitize-DEbPNtyI.js';
-import '../environment-provider.js';
-import '@tangle-network/agent-interface/environment-provider';
-import 'node:child_process';
-import '@tangle-network/agent-profile-materialize';
-
+import { E as SandboxClient, h as LoopSandboxPlacement } from "../types-BevOjfTY.js";
+import { $c as DetachedSessionRefParts, $l as traceContextToEnv, Ac as McpToolDescriptor, Al as DelegateUiAuditConfig, As as createCoordinationTools, Au as FileDelegationStore, Bc as DetachedSessionDelegateOptions, Bl as DelegationResultPayload, Bs as DelegateResult, Cc as captureWorktreeDiff, Cl as DelegateCodeResult, Cs as QuestionLevel, Cu as buildDelegationTraceSpans, Dl as DelegateResearchConfig, Ds as QuestionUrgency, Du as DelegationPersistenceError, El as DelegateResearchArgs, Es as QuestionRecord, Eu as createDelegationTraceCollector, Fc as eventToSnapshot, Fl as DelegationHistoryArgs, Fs as DELEGATE_DESCRIPTION, Gc as detachedSessionDelegate, Gl as FeedbackRefersTo, Hc as SettleDetachedCoderTurnOptions, Hl as DelegationStatusArgs, Hs as validateDelegateArgs, Hu as CoderOutput, Ic as CoderDelegate, Il as DelegationHistoryEntry, Is as DELEGATE_INPUT_SCHEMA, Jc as FleetHandle, Jl as UiAuditLensFilter, Kc as settleDetachedCoderTurn, Kl as ResearchOutputShape, Lc as CoderReview, Ll as DelegationHistoryResult, Ls as DELEGATE_TOOL_NAME, Mc as FeedbackEvent, Ml as DelegateUiAuditRoute, Ms as McpServerOptions, Mu as InMemoryDelegationStore, Nc as FeedbackStore, Nl as DelegationError, Ns as createInProcessTransport, Oc as JsonRpcMessage, Ol as DelegateResearchResult, Os as SettledWorker, Ou as DelegationStateCorruptError, Pc as InMemoryFeedbackStore, Pl as DelegationFeedbackSnapshot, Ps as createMcpServer, Qc as createSiblingSandboxExecutor, Ql as readTraceContextFromEnv, Rc as CoderReviewer, Rl as DelegationProfile, Rs as DelegateArgs, Sc as WorktreeHandle, Sl as DelegateCodeConfig, Ss as QuestionDecision, Su as DelegationTraceSpan, Tc as removeWorktree, Tl as DelegateFeedbackResult, Ts as QuestionPolicy, Tu as composeLoopTraceEmitters, Uc as UiAuditorDelegate, Ul as DelegationStatusResult, Vc as DetachedWinnerSelection, Vl as DelegationStatus, Vs as createDelegateHandler, Wc as coderTaskFromArgs, Wl as FeedbackRating, Xc as SiblingSandboxExecutorOptions, Xl as TraceContext, Yc as FleetWorkspaceExecutorOptions, Yl as UiAuditorDelegationOutput, Zc as createFleetWorkspaceExecutor, Zl as createPropagatingTraceEmitter, _c as CreateWorktreeOptions, _l as DelegationTaskQueueOptions, _s as CoordinationToolsOptions, _u as CappedDelegationTrace, al as createDetachedTurnResumeDriver, bc as GitRunner, bl as hashIdempotencyInput, bs as MakeWorkerAgent, bu as DelegationTraceCaps, cl as parseDetachedSessionRef, dl as DelegationRecord, el as DetachedTurn, fl as DelegationResumeContext, gl as DelegationTaskQueue, gs as CoordinationTools, hl as DelegationRunContext, hs as CoordinationEvent, il as RunDetachedTurnOptions, jc as McpTransport, jl as DelegateUiAuditResult, js as McpServer, ju as FileDelegationStoreOptions, kc as JsonRpcResponse, kl as DelegateUiAuditArgs, ks as WorkerWatchOptions, ku as DelegationStore, ll as runDetachedTurn, ml as DelegationResumeTick, ms as AnalystRegistry, nl as DriveTurnCapableBox, ol as detachedTurnEvents, pl as DelegationResumeDriver, ps as AnalystFindingEvent, qc as DelegationExecutor, ql as ResearchSource, rl as DriveTurnTick, sl as formatDetachedSessionRef, tl as DetachedTurnResumeDriverOptions, ul as DelegationArgs, vc as DiffOptions, vl as SubmitInput, vs as DEFAULT_AWAIT_EVENT_TIMEOUT_MS, vu as DELEGATION_TRACE_MAX_BYTES, wc as createWorktree, wl as DelegateFeedbackArgs, ws as QuestionOption, wu as capDelegationTrace, xc as RemoveWorktreeOptions, xl as DelegateCodeArgs, xs as Question, xu as DelegationTraceCollector, yc as DiffResult, yl as SubmitOutput, ys as DownMessageEvent, yu as DELEGATION_TRACE_MAX_SPANS, zc as DelegateRunCtx, zl as DelegationProgress, zs as DelegateHandlerOptions } from "../index-DruSKs3Z.js";
+import { o as UiLens } from "../substrate-BcnuSHXm.js";
+import { a as LocalHarnessResult, c as runLocalHarness, i as LocalHarness, n as CodexExecutionPolicy, o as RunLocalHarnessOptions, r as CodexTokenUsage, s as parseCodexTokenUsage, t as CodexExecutionEvidence } from "../local-harness-Dh8PJ0ot.js";
+import { a as KbGateResult, i as FactJudgeVerdict, n as FactCandidate, o as createKbGate, r as FactJudge, t as CreateKbGateOptions } from "../kb-gate-C8z2juK8.js";
+import { n as mcpToolsForRuntimeMcpSubset, t as mcpToolsForRuntimeMcp } from "../openai-tools-B68JaOCx.js";
+import { AnalystFinding } from "@tangle-network/agent-eval";
+import { AgentProfileMcpServer } from "@tangle-network/agent-interface";
+//#region src/mcp/codex-diagnostics.d.ts
 /** Bounded, credential-redacted process context attached when reproducible Codex output fails
  * validation. The process still fails closed; this only preserves enough evidence to diagnose it. */
 interface CodexExecutionFailureDiagnostic {
-    exitCode: number | null;
-    killedBySignal: NodeJS.Signals | null;
-    timedOut: boolean;
-    aborted?: boolean;
-    durationMs: number;
-    stdout: string;
-    stderr: string;
-    stdoutTruncated: boolean;
-    stderrTruncated: boolean;
+  exitCode: number | null;
+  killedBySignal: NodeJS.Signals | null;
+  timedOut: boolean;
+  aborted?: boolean;
+  durationMs: number;
+  stdout: string;
+  stderr: string;
+  stdoutTruncated: boolean;
+  stderrTruncated: boolean;
 }
 /** Thrown when reproducible Codex exits without one valid terminal usage event. */
 declare class CodexExecutionDiagnosticError extends Error {
-    readonly reason: string;
-    readonly diagnostic: CodexExecutionFailureDiagnostic;
-    readonly code = "CODEX_EXECUTION_DIAGNOSTIC";
-    constructor(reason: string, diagnostic: CodexExecutionFailureDiagnostic, cause?: unknown);
+  readonly reason: string;
+  readonly diagnostic: CodexExecutionFailureDiagnostic;
+  readonly code = "CODEX_EXECUTION_DIAGNOSTIC";
+  constructor(reason: string, diagnostic: CodexExecutionFailureDiagnostic, cause?: unknown);
 }
-
-/**
- *
- * Helpers extracted from `bin.ts` so the env-detection + executor-selection
- * logic is unit-testable without spawning a subprocess. The bin imports from
- * here; tests import from here directly.
- *
- * @experimental
- */
-
+//#endregion
+//#region src/mcp/bin-helpers.d.ts
 /** @experimental */
 interface DetectExecutorArgs {
-    sandboxClient: SandboxClient;
-    /** Raw env (defaults to `process.env`). Pass an explicit map for tests. */
-    env?: Record<string, string | undefined>;
-    /**
-     * Override how a fleet handle is resolved from the client + fleet id. The
-     * default reads `client.fleets.get(fleetId)` and validates the returned
-     * shape against the structural `FleetHandle` contract.
-     */
-    resolveFleet?: (client: SandboxClient, fleetId: string) => Promise<FleetHandle>;
+  sandboxClient: SandboxClient;
+  /** Raw env (defaults to `process.env`). Pass an explicit map for tests. */
+  env?: Record<string, string | undefined>;
+  /**
+   * Override how a fleet handle is resolved from the client + fleet id. The
+   * default reads `client.fleets.get(fleetId)` and validates the returned
+   * shape against the structural `FleetHandle` contract.
+   */
+  resolveFleet?: (client: SandboxClient, fleetId: string) => Promise<FleetHandle>;
 }
 /**
  * Pick the right executor for an MCP server invocation based on env vars.
@@ -76,39 +56,40 @@ interface DetectExecutorArgs {
  * @experimental
  */
 declare function detectExecutor(args: DetectExecutorArgs): Promise<DelegationExecutor>;
-
+//#endregion
+//#region src/mcp/in-process-executor.d.ts
 /** @experimental */
 interface InProcessExecutorOptions {
-    /** Absolute path to the git repo (the workspace). Worktrees go under `<repoRoot>/.agent-worktrees/`. */
-    repoRoot: string;
-    /** Harnesses to round-robin across `create()` calls. One entry = no fanout. Default `['claude']`. */
-    harnesses?: ReadonlyArray<LocalHarness>;
-    /** Optional per-delegation test command run in the worktree after the harness exits. */
-    testCmd?: string;
-    /** Optional per-delegation typecheck command. Same shape as `testCmd`. */
-    typecheckCmd?: string;
-    /** Wall-clock cap per harness subprocess (ms). Default 5min. */
-    harnessTimeoutMs?: number;
-    /** Wall-clock cap per test/typecheck subprocess (ms). Default 2min. */
-    postCheckTimeoutMs?: number;
-    /** Test seam — override the git runner used by the worktree helpers. */
-    runGit?: GitRunner;
-    /** Test seam — override the harness runner (defaults to the real CLI via `runLocalHarness`). */
-    runHarness?: typeof runLocalHarness;
-    /** Test seam — override the post-check runner (defaults to a `sh -c` spawn). A throw is folded
-     *  into a non-fatal `{exitCode:-1}` so a broken check command fails the signal, not the run. */
-    runPostCheck?: (cmd: string, cwd: string, signal?: AbortSignal) => Promise<{
-        exitCode: number;
-        stdout: string;
-        stderr: string;
-    }>;
+  /** Absolute path to the git repo (the workspace). Worktrees go under `<repoRoot>/.agent-worktrees/`. */
+  repoRoot: string;
+  /** Harnesses to round-robin across `create()` calls. One entry = no fanout. Default `['claude']`. */
+  harnesses?: ReadonlyArray<LocalHarness>;
+  /** Optional per-delegation test command run in the worktree after the harness exits. */
+  testCmd?: string;
+  /** Optional per-delegation typecheck command. Same shape as `testCmd`. */
+  typecheckCmd?: string;
+  /** Wall-clock cap per harness subprocess (ms). Default 5min. */
+  harnessTimeoutMs?: number;
+  /** Wall-clock cap per test/typecheck subprocess (ms). Default 2min. */
+  postCheckTimeoutMs?: number;
+  /** Test seam — override the git runner used by the worktree helpers. */
+  runGit?: GitRunner;
+  /** Test seam — override the harness runner (defaults to the real CLI via `runLocalHarness`). */
+  runHarness?: typeof runLocalHarness;
+  /** Test seam — override the post-check runner (defaults to a `sh -c` spawn). A throw is folded
+   *  into a non-fatal `{exitCode:-1}` so a broken check command fails the signal, not the run. */
+  runPostCheck?: (cmd: string, cwd: string, signal?: AbortSignal) => Promise<{
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+  }>;
 }
 /** @experimental */
 interface InProcessExecutorDescribePlacement extends LoopSandboxPlacement {
-    /** Worktree path in the parent sandbox's filesystem (set so traces correlate to on-disk artifacts). */
-    worktreePath?: string;
-    /** Which harness handled this delegation. */
-    harness?: LocalHarness;
+  /** Worktree path in the parent sandbox's filesystem (set so traces correlate to on-disk artifacts). */
+  worktreePath?: string;
+  /** Which harness handled this delegation. */
+  harness?: LocalHarness;
 }
 /**
  * Build an in-process executor. Returns a {@link DelegationExecutor} whose `client.create()`
@@ -120,109 +101,42 @@ interface InProcessExecutorDescribePlacement extends LoopSandboxPlacement {
  * @experimental
  */
 declare function createInProcessExecutor(options: InProcessExecutorOptions): DelegationExecutor;
-
-/**
- * `createStdioToolServer` — the generic newline-delimited JSON-RPC 2.0 MCP
- * server core: `initialize` / `notifications/initialized` / `tools/list` /
- * `tools/call` over a stdio-shaped transport, protocol 2024-11-05.
- *
- * Extracted from `createMcpServer` (server.ts) so every in-repo MCP server —
- * the delegation server, the memory server — serves the ONE wire protocol the
- * same-host client (`connectStdioMcp`, runtime/stdio-mcp-client.ts) speaks.
- * A second hand-rolled serve loop could drift from what the client expects;
- * this core makes that impossible by construction.
- *
- * @experimental
- */
-/** @experimental */
-interface McpToolDescriptor {
-    name: string;
-    description: string;
-    inputSchema: Record<string, unknown>;
-    handler: (raw: unknown) => Promise<unknown>;
-}
-/** @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;
-    };
-}
+//#endregion
+//#region src/mcp/tool-server.d.ts
 /** @experimental */
 interface StdioToolServerOptions {
-    /** Server display name surfaced via `initialize`. */
-    serverName: string;
-    /** Server version surfaced via `initialize`. */
-    serverVersion: string;
-    /** The tools to serve. Duplicate names throw — a silent shadow would hide a tool. */
-    tools: readonly McpToolDescriptor[];
+  /** Server display name surfaced via `initialize`. */
+  serverName: string;
+  /** Server version surfaced via `initialize`. */
+  serverVersion: string;
+  /** The tools to serve. Duplicate names throw — a silent shadow would hide a tool. */
+  tools: readonly McpToolDescriptor[];
 }
 /** @experimental */
 interface StdioToolServer {
-    /** Tools currently registered, keyed by name. */
-    readonly tools: ReadonlyMap<string, McpToolDescriptor>;
-    /** 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;
+  /** Tools currently registered, keyed by name. */
+  readonly tools: ReadonlyMap<string, McpToolDescriptor>;
+  /** 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;
 }
 /** Build the generic stdio JSON-RPC tool server. */
 declare function createStdioToolServer(options: StdioToolServerOptions): StdioToolServer;
-
-/**
- * Memory MCP server — the LIVE serving half of the `memory` profile surface
- * (Phase 5). A curated memory (lessons distilled from prior runs) is only
- * real if the DRIVEN agent can query it mid-task; this module serves a flat
- * store of `MemoryItem` rows as `memory_search` / `memory_get` tools over the
- * ONE in-repo stdio JSON-RPC core (`createStdioToolServer`), so the exact
- * wire protocol the same-host client (`connectStdioMcp` /
- * `materializeLocalMcp`, runtime/stdio-mcp-client.ts) speaks is guaranteed by
- * construction — serve and consume cannot drift.
- *
- * Retrieval is DETERMINISTIC lexical overlap (no vectors, no LLM): a lift
- * measured with this memory mounted is attributable to the lessons
- * themselves, never to retrieval-model noise — the same discipline as
- * agent-eval's `memoryCurationProposer` (deterministic curation). Every
- * `memory_search` can append one JSONL row to a retrieval log (`logPath`) —
- * the per-query record an off-policy retrieval estimator (agent-knowledge's
- * `RetrievalHoldout`) consumes. agent-knowledge is NOT a dependency of this
- * repo, so the log file is the flagged cross-package seam, not an import.
- *
- * Fail-loud discipline (mirrors `materializeLocalMcp`): an EMPTY memory is
- * never served — a profile without memory simply omits the artifact, and
- * silently serving zero rows would fake the with/without ablation.
- *
- * @experimental
- */
-
+//#endregion
+//#region src/mcp/memory-server.d.ts
 /** One row of agent memory: a crisp lesson/fact with provenance. */
 interface MemoryItem {
-    /** Stable id (content-hash by convention; see `memoryArtifactFromLessons`). */
-    id: string;
-    /** The lesson itself — one imperative or observation the agent should recall. */
-    text: string;
-    /** Optional retrieval tags, matched by `memory_search` alongside the text. */
-    tags?: string[];
-    /** Provenance: the finding / trace / curation pass this row came from. */
-    source?: string;
+  /** Stable id (content-hash by convention; see `memoryArtifactFromLessons`). */
+  id: string;
+  /** The lesson itself — one imperative or observation the agent should recall. */
+  text: string;
+  /** Optional retrieval tags, matched by `memory_search` alongside the text. */
+  tags?: string[];
+  /** Provenance: the finding / trace / curation pass this row came from. */
+  source?: string;
 }
 /**
  * The `memory` artifact payload — HOW a profile's memory is stored and served:
@@ -239,15 +153,15 @@ interface MemoryItem {
  * — the retrieval log a holdout estimator reads (see module doc).
  */
 interface AgentMemorySpec {
-    store: 'file' | 'mcp';
-    /** `store:'file'` — host path to the durable row store (JSON array or JSONL). */
-    path?: string;
-    /** Inline seed rows, served alongside (and winning over) `path` rows. */
-    items?: MemoryItem[];
-    /** `store:'mcp'` — the external server that already serves memory tools. */
-    server?: AgentProfileMcpServer;
-    /** JSONL retrieval log: one row per `memory_search` (ts, query, k, returned). */
-    logPath?: string;
+  store: 'file' | 'mcp';
+  /** `store:'file'` — host path to the durable row store (JSON array or JSONL). */
+  path?: string;
+  /** Inline seed rows, served alongside (and winning over) `path` rows. */
+  items?: MemoryItem[];
+  /** `store:'mcp'` — the external server that already serves memory tools. */
+  server?: AgentProfileMcpServer;
+  /** JSONL retrieval log: one row per `memory_search` (ts, query, k, returned). */
+  logPath?: string;
 }
 /** Env var naming the durable row store file the memory bin loads (the
  *  `memoryMcpServer` ↔ memory-bin contract). */
@@ -259,16 +173,16 @@ declare const MEMORY_LOG_ENV = "AGENT_MEMORY_LOG";
 /** Env var overriding the served display name (default 'agent-memory'). */
 declare const MEMORY_NAME_ENV = "AGENT_MEMORY_NAME";
 interface CreateMemoryToolServerOptions {
-    /** The rows to serve. MUST be non-empty (an empty memory is never served). */
-    items: readonly MemoryItem[];
-    /** Server display name surfaced via `initialize`. Default 'agent-memory'. */
-    serverName?: string;
-    /** Server version surfaced via `initialize`. Default '0'. */
-    serverVersion?: string;
-    /** Default result count for `memory_search`. Default 5. */
-    defaultK?: number;
-    /** Append one JSONL row per `memory_search` (the retrieval-holdout seam). */
-    logPath?: string;
+  /** The rows to serve. MUST be non-empty (an empty memory is never served). */
+  items: readonly MemoryItem[];
+  /** Server display name surfaced via `initialize`. Default 'agent-memory'. */
+  serverName?: string;
+  /** Server version surfaced via `initialize`. Default '0'. */
+  serverVersion?: string;
+  /** Default result count for `memory_search`. Default 5. */
+  defaultK?: number;
+  /** Append one JSONL row per `memory_search` (the retrieval-holdout seam). */
+  logPath?: string;
 }
 /**
  * Build the memory MCP server: `memory_search` (lexical top-k over the rows)
@@ -281,9 +195,9 @@ declare function parseMemoryItems(value: unknown, source: string): MemoryItem[];
 declare function readMemoryItemsFile(path: string): MemoryItem[];
 /** What the memory bin resolved from its environment. */
 interface ResolvedMemoryEnv {
-    items: MemoryItem[];
-    serverName?: string;
-    logPath?: string;
+  items: MemoryItem[];
+  serverName?: string;
+  logPath?: string;
 }
 /**
  * Resolve the bin's memory from `AGENT_MEMORY_FILE` (durable store) and/or
@@ -291,35 +205,18 @@ interface ResolvedMemoryEnv {
  * a boot FAILURE, matching the fail-closed materialization discipline.
  */
 declare function resolveMemoryFromEnv(env: Record<string, string | undefined>): ResolvedMemoryEnv;
-
-/**
- *
- * The trace-analyst KIND directory — the operator's lenses, as composable DATA.
- *
- * An analyst is not one question. A kind is ONE lens (completeness, correctness, policy, efficiency,
- * tool-use, …); each emits `AnalystFinding`s tagged by its `area`. The driver `list_analysts` to see
- * the menu, `run_analyst(kind, worker)` to apply a lens, and `define_analyst` to author a new one —
- * so at test time you compose the exact lenses a domain needs (maximum specificity), not one generic
- * reviewer. The kinds are data, the runner is generic, and the finding shape + firewall are reused
- * from agent-eval / the keystone — never re-derived.
- *
- * A kind here is a lightweight lens (`Check`); it is a deliberate SUBSET of agent-eval's full
- * `TraceAnalystKindSpec`, so a kind that needs the heavy agentic actor (sub-agent recursion, tools,
- * goldens) upgrades to `createTraceAnalystKind` without changing this directory's surface.
- *
- * @experimental
- */
-
+//#endregion
+//#region src/mcp/tools/checks.d.ts
 /** One lens — a composable analyst kind. Identity fields mirror `TraceAnalystKindSpec` so a kind is
  *  upgradeable to the full agentic factory; `lookFor` is the lens question the actor applies. */
 interface Check {
-    readonly id: string;
-    readonly description: string;
-    /** Coarse classification stamped on every finding this kind emits (the renderer groups by it). */
-    readonly area: string;
-    readonly version: string;
-    /** The lens — what this analyst looks for in the trace. */
-    readonly lookFor: string;
+  readonly id: string;
+  readonly description: string;
+  /** Coarse classification stamped on every finding this kind emits (the renderer groups by it). */
+  readonly area: string;
+  readonly version: string;
+  /** The lens — what this analyst looks for in the trace. */
+  readonly lookFor: string;
 }
 /** The built-in lens directory. Domain-blind (about any agent trace); compose at test time. */
 declare const defaultChecks: Record<string, Check>;
@@ -330,11 +227,11 @@ declare function liftFindings(kind: Check, rows: unknown[], producedAt: string):
  *  the trace shape: a `{ messages }` conversation, a bare message array, else stringified. */
 declare function renderTrace(trace: unknown): string;
 interface CheckRunnerOptions {
-    routerBaseUrl: string;
-    routerKey: string;
-    model: string;
-    /** Test/override seam — replace the LLM call. Default: a router chat completion. */
-    chat?: (system: string, user: string) => Promise<string>;
+  routerBaseUrl: string;
+  routerKey: string;
+  model: string;
+  /** Test/override seam — replace the LLM call. Default: a router chat completion. */
+  chat?: (system: string, user: string) => Promise<string>;
 }
 /** Run ONE lens over a trace → findings. Generic over any kind: prompt = the lens + the agent-eval
  *  finding schema; the model's JSON array is parsed (`parseRawFinding`), lifted, and firewalled. */
@@ -345,288 +242,249 @@ declare function runCheck(kind: Check, trace: unknown, opts: CheckRunnerOptions,
  * passed in because replay-safe paths must not read `Date.now`.
  */
 declare function makeCheckRunner(kinds: Record<string, Check>, opts: CheckRunnerOptions): (kindId: string, trace: unknown, producedAt: string) => Promise<AnalystFinding[] | {
-    error: string;
+  error: string;
 }>;
-
-/**
- *
- * `delegate_feedback` MCP tool — synchronous record of agent / user /
- * downstream-judge feedback on a delegation, artifact, or outcome.
- *
- * The store is append-only. Every rating is its own event; no dedupe.
- * When `refersTo.kind === 'delegation'`, the snapshot is also attached
- * to the matching queue record so `delegation_history` surfaces it
- * inline without a join.
- *
- * @experimental
- */
-
+//#endregion
+//#region src/mcp/tools/delegate-feedback.d.ts
 /** MCP tool name for the `delegate_feedback` feedback-recording tool. @experimental */
 declare const DELEGATE_FEEDBACK_TOOL_NAME = "delegate_feedback";
 /** Human-readable description of the `delegate_feedback` MCP tool, injected into the tool manifest. @experimental */
 declare const DELEGATE_FEEDBACK_DESCRIPTION: string;
 /** JSON Schema for `delegate_feedback` tool arguments (`refersTo`, `rating`, `by`, optional fields). @experimental */
 declare const DELEGATE_FEEDBACK_INPUT_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly refersTo: {
-            readonly type: "object";
-            readonly properties: {
-                readonly kind: {
-                    readonly type: "string";
-                    readonly enum: readonly ["delegation", "artifact", "outcome"];
-                };
-                readonly ref: {
-                    readonly type: "string";
-                };
-            };
-            readonly required: readonly ["kind", "ref"];
-            readonly additionalProperties: false;
+  readonly type: "object";
+  readonly properties: {
+    readonly refersTo: {
+      readonly type: "object";
+      readonly properties: {
+        readonly kind: {
+          readonly type: "string";
+          readonly enum: readonly ["delegation", "artifact", "outcome"];
         };
-        readonly rating: {
-            readonly type: "object";
-            readonly properties: {
-                readonly score: {
-                    readonly type: "number";
-                    readonly minimum: 0;
-                    readonly maximum: 1;
-                };
-                readonly label: {
-                    readonly type: "string";
-                    readonly enum: readonly ["good", "bad", "neutral", "mixed"];
-                };
-                readonly notes: {
-                    readonly type: "string";
-                };
-            };
-            readonly required: readonly ["score", "notes"];
-            readonly additionalProperties: false;
+        readonly ref: {
+          readonly type: "string";
         };
-        readonly by: {
-            readonly type: "string";
-            readonly enum: readonly ["agent", "user", "downstream-judge"];
+      };
+      readonly required: readonly ["kind", "ref"];
+      readonly additionalProperties: false;
+    };
+    readonly rating: {
+      readonly type: "object";
+      readonly properties: {
+        readonly score: {
+          readonly type: "number";
+          readonly minimum: 0;
+          readonly maximum: 1;
         };
-        readonly capturedAt: {
-            readonly type: "string";
+        readonly label: {
+          readonly type: "string";
+          readonly enum: readonly ["good", "bad", "neutral", "mixed"];
         };
-        readonly namespace: {
-            readonly type: "string";
+        readonly notes: {
+          readonly type: "string";
         };
+      };
+      readonly required: readonly ["score", "notes"];
+      readonly additionalProperties: false;
+    };
+    readonly by: {
+      readonly type: "string";
+      readonly enum: readonly ["agent", "user", "downstream-judge"];
+    };
+    readonly capturedAt: {
+      readonly type: "string";
     };
-    readonly required: readonly ["refersTo", "rating", "by"];
-    readonly additionalProperties: false;
+    readonly namespace: {
+      readonly type: "string";
+    };
+  };
+  readonly required: readonly ["refersTo", "rating", "by"];
+  readonly additionalProperties: false;
 };
 /** Parse and validate raw MCP tool input into typed `DelegateFeedbackArgs`; throws `TypeError` on bad input. @experimental */
 declare function validateDelegateFeedbackArgs(raw: unknown): DelegateFeedbackArgs;
 /** @experimental */
 interface DelegateFeedbackHandlerOptions {
-    queue: DelegationTaskQueue;
-    store: FeedbackStore;
-    generateId?: () => string;
-    now?: () => string;
+  queue: DelegationTaskQueue;
+  store: FeedbackStore;
+  generateId?: () => string;
+  now?: () => string;
 }
 /** Build the MCP tool handler that persists feedback events and attaches them to delegation records. @experimental */
 declare function createDelegateFeedbackHandler(options: DelegateFeedbackHandlerOptions): (raw: unknown) => Promise<DelegateFeedbackResult>;
-
-/**
- *
- * `delegate_ui_audit` MCP tool — async kickoff for UI audit runs. Validates
- * the input, computes an idempotency key over the canonical fields, hands
- * the task to the queue, and returns a taskId. Identical inputs return
- * the same taskId.
- *
- * The handler does not import the auditor profile directly — consumers
- * inject a `UiAuditorDelegate` via `createMcpServer({ uiAuditorDelegate })`.
- * The delegate is the seam where the consumer chooses the judge (vision
- * model) and the `SandboxClient` (in-process Playwright vs fleet vs
- * remote browser). agent-runtime ships the in-process client under
- * `./profiles` so consumers who want the canonical setup can wire it
- * with a few lines.
- *
- * @experimental
- */
-
+//#endregion
+//#region src/mcp/tools/delegate-ui-audit.d.ts
 /** MCP tool name for the `delegate_ui_audit` async kickoff tool. @experimental */
 declare const DELEGATE_UI_AUDIT_TOOL_NAME = "delegate_ui_audit";
 /** Human-readable description of the `delegate_ui_audit` MCP tool, injected into the tool manifest. @experimental */
 declare const DELEGATE_UI_AUDIT_DESCRIPTION: string;
 /** JSON Schema for `delegate_ui_audit` tool arguments (`workspaceDir`, `routes`, optional config). @experimental */
 declare const DELEGATE_UI_AUDIT_INPUT_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly workspaceDir: {
+  readonly type: "object";
+  readonly properties: {
+    readonly workspaceDir: {
+      readonly type: "string";
+      readonly description: "Absolute path for the audit workspace.";
+    };
+    readonly routes: {
+      readonly type: "array";
+      readonly items: {
+        readonly type: "object";
+        readonly properties: {
+          readonly name: {
             readonly type: "string";
-            readonly description: "Absolute path for the audit workspace.";
-        };
-        readonly routes: {
+            readonly description: "Stable route name (used in screenshot filenames).";
+          };
+          readonly url: {
+            readonly type: "string";
+            readonly description: "Fully-qualified URL.";
+          };
+          readonly viewports: {
             readonly type: "array";
             readonly items: {
-                readonly type: "object";
-                readonly properties: {
-                    readonly name: {
-                        readonly type: "string";
-                        readonly description: "Stable route name (used in screenshot filenames).";
-                    };
-                    readonly url: {
-                        readonly type: "string";
-                        readonly description: "Fully-qualified URL.";
-                    };
-                    readonly viewports: {
-                        readonly type: "array";
-                        readonly items: {
-                            readonly type: "object";
-                            readonly properties: {
-                                readonly width: {
-                                    readonly type: "integer";
-                                    readonly minimum: 1;
-                                };
-                                readonly height: {
-                                    readonly type: "integer";
-                                    readonly minimum: 1;
-                                };
-                            };
-                            readonly required: readonly ["width", "height"];
-                            readonly additionalProperties: false;
-                        };
-                        readonly description: "Viewports to capture at. Default [{1280, 800}].";
-                    };
-                    readonly fullPage: {
-                        readonly type: "boolean";
-                    };
-                    readonly waitFor: {
-                        readonly type: "string";
-                        readonly description: "CSS selector to wait for before capturing.";
-                    };
+              readonly type: "object";
+              readonly properties: {
+                readonly width: {
+                  readonly type: "integer";
+                  readonly minimum: 1;
+                };
+                readonly height: {
+                  readonly type: "integer";
+                  readonly minimum: 1;
                 };
-                readonly required: readonly ["name", "url"];
-                readonly additionalProperties: false;
+              };
+              readonly required: readonly ["width", "height"];
+              readonly additionalProperties: false;
             };
-            readonly minItems: 1;
+            readonly description: "Viewports to capture at. Default [{1280, 800}].";
+          };
+          readonly fullPage: {
+            readonly type: "boolean";
+          };
+          readonly waitFor: {
+            readonly type: "string";
+            readonly description: "CSS selector to wait for before capturing.";
+          };
         };
-        readonly namespace: {
+        readonly required: readonly ["name", "url"];
+        readonly additionalProperties: false;
+      };
+      readonly minItems: 1;
+    };
+    readonly namespace: {
+      readonly type: "string";
+      readonly description: "Multi-tenant scope.";
+    };
+    readonly config: {
+      readonly type: "object";
+      readonly properties: {
+        readonly lenses: {
+          readonly type: "array";
+          readonly items: {
             readonly type: "string";
-            readonly description: "Multi-tenant scope.";
+            readonly enum: readonly UiLens[];
+          };
+          readonly description: "Lenses to iterate. Default: every lens except \"other\".";
         };
-        readonly config: {
-            readonly type: "object";
-            readonly properties: {
-                readonly lenses: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "string";
-                        readonly enum: readonly UiLens[];
-                    };
-                    readonly description: "Lenses to iterate. Default: every lens except \"other\".";
-                };
-                readonly maxIterations: {
-                    readonly type: "integer";
-                    readonly minimum: 1;
-                };
-                readonly maxConcurrency: {
-                    readonly type: "integer";
-                    readonly minimum: 1;
-                };
-                readonly productContext: {
-                    readonly type: "string";
-                };
-            };
-            readonly additionalProperties: false;
+        readonly maxIterations: {
+          readonly type: "integer";
+          readonly minimum: 1;
+        };
+        readonly maxConcurrency: {
+          readonly type: "integer";
+          readonly minimum: 1;
+        };
+        readonly productContext: {
+          readonly type: "string";
         };
+      };
+      readonly additionalProperties: false;
     };
-    readonly required: readonly ["workspaceDir", "routes"];
-    readonly additionalProperties: false;
+  };
+  readonly required: readonly ["workspaceDir", "routes"];
+  readonly additionalProperties: false;
 };
 /** Parse and validate raw MCP tool input into typed `DelegateUiAuditArgs`; throws `TypeError` on bad input. @experimental */
 declare function validateDelegateUiAuditArgs(raw: unknown): DelegateUiAuditArgs;
 /** @experimental */
 interface DelegateUiAuditHandlerOptions {
-    queue: DelegationTaskQueue;
-    delegate: UiAuditorDelegate;
-    estimateDurationMs?: (args: DelegateUiAuditArgs) => number;
+  queue: DelegationTaskQueue;
+  delegate: UiAuditorDelegate;
+  estimateDurationMs?: (args: DelegateUiAuditArgs) => number;
 }
 /** Build the MCP tool handler that validates input, deduplicates via idempotency key, and enqueues a UI audit. @experimental */
 declare function createDelegateUiAuditHandler(options: DelegateUiAuditHandlerOptions): (raw: unknown) => Promise<DelegateUiAuditResult>;
-
-/**
- *
- * `delegation_history` MCP tool — synchronous read of past delegations.
- * The agent uses this for self-introspection — "have I delegated this
- * kind of task before? did it work?" — and calibration.
- *
- * @experimental
- */
-
+//#endregion
+//#region src/mcp/tools/delegation-history.d.ts
 /** MCP tool name for the `delegation_history` read-past-delegations tool. @experimental */
 declare const DELEGATION_HISTORY_TOOL_NAME = "delegation_history";
 /** Human-readable description of the `delegation_history` MCP tool, injected into the tool manifest. @experimental */
 declare const DELEGATION_HISTORY_DESCRIPTION: string;
 /** JSON Schema for `delegation_history` tool arguments (optional `namespace`, `profile`, `since`, `limit`). @experimental */
 declare const DELEGATION_HISTORY_INPUT_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly namespace: {
-            readonly type: "string";
-        };
-        readonly profile: {
-            readonly type: "string";
-            readonly enum: readonly ["coder", "researcher"];
-        };
-        readonly since: {
-            readonly type: "string";
-            readonly description: "ISO datetime — earliest startedAt to include.";
-        };
-        readonly limit: {
-            readonly type: "integer";
-            readonly minimum: 1;
-            readonly maximum: 500;
-        };
+  readonly type: "object";
+  readonly properties: {
+    readonly namespace: {
+      readonly type: "string";
+    };
+    readonly profile: {
+      readonly type: "string";
+      readonly enum: readonly ["coder", "researcher"];
     };
-    readonly additionalProperties: false;
+    readonly since: {
+      readonly type: "string";
+      readonly description: "ISO datetime — earliest startedAt to include.";
+    };
+    readonly limit: {
+      readonly type: "integer";
+      readonly minimum: 1;
+      readonly maximum: 500;
+    };
+  };
+  readonly additionalProperties: false;
 };
 /** Parse and validate raw MCP tool input into typed `DelegationHistoryArgs`; throws `TypeError` on bad input. @experimental */
 declare function validateDelegationHistoryArgs(raw: unknown): DelegationHistoryArgs;
 /** @experimental */
 interface DelegationHistoryHandlerOptions {
-    queue: DelegationTaskQueue;
+  queue: DelegationTaskQueue;
 }
 /** Build the MCP tool handler that reads filtered past delegations from a `DelegationTaskQueue`. @experimental */
 declare function createDelegationHistoryHandler(options: DelegationHistoryHandlerOptions): (raw: unknown) => Promise<DelegationHistoryResult>;
-
-/**
- *
- * `delegation_status` MCP tool — synchronous poll. Returns the current
- * state machine + optional progress + final result (when terminal).
- *
- * @experimental
- */
-
+//#endregion
+//#region src/mcp/tools/delegation-status.d.ts
 /** MCP tool name for the `delegation_status` synchronous-poll tool. @experimental */
 declare const DELEGATION_STATUS_TOOL_NAME = "delegation_status";
 /** Human-readable description of the `delegation_status` MCP tool, injected into the tool manifest. @experimental */
 declare const DELEGATION_STATUS_DESCRIPTION: string;
 /** JSON Schema for `delegation_status` tool arguments (`taskId` + optional `includeTrace`). @experimental */
 declare const DELEGATION_STATUS_INPUT_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly taskId: {
-            readonly type: "string";
-            readonly description: "Returned by delegate_ui_audit.";
-        };
-        readonly includeTrace: {
-            readonly type: "boolean";
-            readonly description: "Also return the journaled loop-trace span tree for this delegation. Default false.";
-        };
+  readonly type: "object";
+  readonly properties: {
+    readonly taskId: {
+      readonly type: "string";
+      readonly description: "Returned by delegate_ui_audit.";
+    };
+    readonly includeTrace: {
+      readonly type: "boolean";
+      readonly description: "Also return the journaled loop-trace span tree for this delegation. Default false.";
     };
-    readonly required: readonly ["taskId"];
-    readonly additionalProperties: false;
+  };
+  readonly required: readonly ["taskId"];
+  readonly additionalProperties: false;
 };
 /** Parse and validate raw MCP tool input into typed `DelegationStatusArgs`; throws `TypeError` on bad input. @experimental */
 declare function validateDelegationStatusArgs(raw: unknown): DelegationStatusArgs;
 /** @experimental */
 interface DelegationStatusHandlerOptions {
-    queue: DelegationTaskQueue;
+  queue: DelegationTaskQueue;
 }
 /** Build the MCP tool handler that polls a `DelegationTaskQueue` for task status. @experimental */
 declare function createDelegationStatusHandler(options: DelegationStatusHandlerOptions): (raw: unknown) => Promise<DelegationStatusResult>;
-
-export { type AgentMemorySpec, type Check, type CheckRunnerOptions, CodexExecutionDiagnosticError, type CodexExecutionFailureDiagnostic, type CreateMemoryToolServerOptions, DELEGATE_FEEDBACK_DESCRIPTION, DELEGATE_FEEDBACK_INPUT_SCHEMA, DELEGATE_FEEDBACK_TOOL_NAME, DELEGATE_UI_AUDIT_DESCRIPTION, DELEGATE_UI_AUDIT_INPUT_SCHEMA, DELEGATE_UI_AUDIT_TOOL_NAME, DELEGATION_HISTORY_DESCRIPTION, DELEGATION_HISTORY_INPUT_SCHEMA, DELEGATION_HISTORY_TOOL_NAME, DELEGATION_STATUS_DESCRIPTION, DELEGATION_STATUS_INPUT_SCHEMA, DELEGATION_STATUS_TOOL_NAME, DelegateFeedbackArgs, DelegateFeedbackResult, DelegateUiAuditArgs, DelegateUiAuditResult, DelegationExecutor, DelegationHistoryArgs, DelegationHistoryResult, DelegationStatusArgs, DelegationStatusResult, DelegationTaskQueue, type DetectExecutorArgs, FeedbackStore, FleetHandle, GitRunner, type InProcessExecutorDescribePlacement, type InProcessExecutorOptions, LocalHarness, MEMORY_FILE_ENV, MEMORY_ITEMS_ENV, MEMORY_LOG_ENV, MEMORY_NAME_ENV, type MemoryItem, type ResolvedMemoryEnv, type McpToolDescriptor as StdioToolDescriptor, type StdioToolServer, type StdioToolServerOptions, UiAuditorDelegate, createDelegateFeedbackHandler, createDelegateUiAuditHandler, createDelegationHistoryHandler, createDelegationStatusHandler, createInProcessExecutor, createMemoryToolServer, createStdioToolServer, defaultChecks, detectExecutor, liftFindings, makeCheckRunner, parseMemoryItems, readMemoryItemsFile, renderTrace, resolveMemoryFromEnv, runCheck, runLocalHarness, validateDelegateFeedbackArgs, validateDelegateUiAuditArgs, validateDelegationHistoryArgs, validateDelegationStatusArgs };
+//#endregion
+//#region src/mcp/index.d.ts
+/** @deprecated Use `McpToolDescriptor`; both names are the same protocol contract. */
+type StdioToolDescriptor = McpToolDescriptor;
+//#endregion
+export { type AgentMemorySpec, type AnalystFindingEvent, type AnalystRegistry, type CappedDelegationTrace, type Check, type CheckRunnerOptions, type CoderDelegate, type CoderOutput, type CoderReview, type CoderReviewer, CodexExecutionDiagnosticError, type CodexExecutionEvidence, type CodexExecutionFailureDiagnostic, type CodexExecutionPolicy, type CodexTokenUsage, type CoordinationEvent, type CoordinationTools, type CoordinationToolsOptions, type CreateKbGateOptions, type CreateMemoryToolServerOptions, type CreateWorktreeOptions, DEFAULT_AWAIT_EVENT_TIMEOUT_MS, DELEGATE_DESCRIPTION, DELEGATE_FEEDBACK_DESCRIPTION, DELEGATE_FEEDBACK_INPUT_SCHEMA, DELEGATE_FEEDBACK_TOOL_NAME, DELEGATE_INPUT_SCHEMA, DELEGATE_TOOL_NAME, DELEGATE_UI_AUDIT_DESCRIPTION, DELEGATE_UI_AUDIT_INPUT_SCHEMA, DELEGATE_UI_AUDIT_TOOL_NAME, DELEGATION_HISTORY_DESCRIPTION, DELEGATION_HISTORY_INPUT_SCHEMA, DELEGATION_HISTORY_TOOL_NAME, DELEGATION_STATUS_DESCRIPTION, DELEGATION_STATUS_INPUT_SCHEMA, DELEGATION_STATUS_TOOL_NAME, DELEGATION_TRACE_MAX_BYTES, DELEGATION_TRACE_MAX_SPANS, type DelegateArgs, type DelegateCodeArgs, type DelegateCodeConfig, type DelegateCodeResult, type DelegateFeedbackArgs, type DelegateFeedbackHandlerOptions, type DelegateFeedbackResult, type DelegateHandlerOptions, type DelegateResearchArgs, type DelegateResearchConfig, type DelegateResearchResult, type DelegateResult, type DelegateRunCtx, type DelegateUiAuditArgs, type DelegateUiAuditConfig, type DelegateUiAuditHandlerOptions, type DelegateUiAuditResult, type DelegateUiAuditRoute, type DelegationArgs, type DelegationError, type DelegationExecutor, type DelegationFeedbackSnapshot, type DelegationHistoryArgs, type DelegationHistoryEntry, type DelegationHistoryHandlerOptions, type DelegationHistoryResult, DelegationPersistenceError, type DelegationProfile, type DelegationProgress, type DelegationRecord, type DelegationResultPayload, type DelegationResumeContext, type DelegationResumeDriver, type DelegationResumeTick, type DelegationRunContext, DelegationStateCorruptError, type DelegationStatus, type DelegationStatusArgs, type DelegationStatusHandlerOptions, type DelegationStatusResult, type DelegationStore, DelegationTaskQueue, type DelegationTaskQueueOptions, type DelegationTraceCaps, type DelegationTraceCollector, type DelegationTraceSpan, type DetachedSessionDelegateOptions, type DetachedSessionRefParts, type DetachedTurn, type DetachedTurnResumeDriverOptions, type DetachedWinnerSelection, type DetectExecutorArgs, type DiffOptions, type DiffResult, type DownMessageEvent, type DriveTurnCapableBox, type DriveTurnTick, type FactCandidate, type FactJudge, type FactJudgeVerdict, type FeedbackEvent, type FeedbackRating, type FeedbackRefersTo, type FeedbackStore, FileDelegationStore, type FileDelegationStoreOptions, type FleetHandle, type FleetWorkspaceExecutorOptions, type GitRunner, InMemoryDelegationStore, InMemoryFeedbackStore, type InProcessExecutorDescribePlacement, type InProcessExecutorOptions, type JsonRpcMessage, type JsonRpcResponse, type KbGateResult, type LocalHarness, type LocalHarnessResult, MEMORY_FILE_ENV, MEMORY_ITEMS_ENV, MEMORY_LOG_ENV, MEMORY_NAME_ENV, type MakeWorkerAgent, type McpServer, type McpServerOptions, type McpToolDescriptor, type McpTransport, type MemoryItem, type Question, type QuestionDecision, type QuestionLevel, type QuestionOption, type QuestionPolicy, type QuestionRecord, type QuestionUrgency, type RemoveWorktreeOptions, type ResearchOutputShape, type ResearchSource, type ResolvedMemoryEnv, type RunDetachedTurnOptions, type RunLocalHarnessOptions, type SettleDetachedCoderTurnOptions, type SettledWorker, type SiblingSandboxExecutorOptions, StdioToolDescriptor, type StdioToolServer, type StdioToolServerOptions, type SubmitInput, type SubmitOutput, type TraceContext, type UiAuditLensFilter, type UiAuditorDelegate, type UiAuditorDelegationOutput, type WorkerWatchOptions, type WorktreeHandle, buildDelegationTraceSpans, capDelegationTrace, captureWorktreeDiff, coderTaskFromArgs, composeLoopTraceEmitters, createCoordinationTools, createDelegateFeedbackHandler, createDelegateHandler, createDelegateUiAuditHandler, createDelegationHistoryHandler, createDelegationStatusHandler, createDelegationTraceCollector, createDetachedTurnResumeDriver, createFleetWorkspaceExecutor, createInProcessExecutor, createInProcessTransport, createKbGate, createMcpServer, createMemoryToolServer, createPropagatingTraceEmitter, createSiblingSandboxExecutor, createStdioToolServer, createWorktree, defaultChecks, detachedSessionDelegate, detachedTurnEvents, detectExecutor, eventToSnapshot, formatDetachedSessionRef, hashIdempotencyInput, liftFindings, makeCheckRunner, mcpToolsForRuntimeMcp, mcpToolsForRuntimeMcpSubset, parseCodexTokenUsage, parseDetachedSessionRef, parseMemoryItems, readMemoryItemsFile, readTraceContextFromEnv, removeWorktree, renderTrace, resolveMemoryFromEnv, runCheck, runDetachedTurn, runLocalHarness, settleDetachedCoderTurn, traceContextToEnv, validateDelegateArgs, validateDelegateFeedbackArgs, validateDelegateUiAuditArgs, validateDelegationHistoryArgs, validateDelegationStatusArgs };
+//# sourceMappingURL=index.d.ts.map