@tangle-network/agent-runtime 0.68.0 → 0.70.0

package/dist/chunk-VLF5RHEQ.js

@@ -1,143 +0,0 @@
-// src/errors.ts
-import { AgentEvalError } from "@tangle-network/agent-eval";
-import {
-  AgentEvalError as AgentEvalError2,
-  ConfigError,
-  JudgeError,
-  NotFoundError,
-  ValidationError
-} from "@tangle-network/agent-eval";
-var SessionMismatchError = class extends AgentEvalError {
-  sessionBackend;
-  requestedBackend;
-  constructor(sessionBackend, requestedBackend, options) {
-    super(
-      "validation",
-      `Cannot resume ${sessionBackend} session with ${requestedBackend} backend`,
-      options
-    );
-    this.sessionBackend = sessionBackend;
-    this.requestedBackend = requestedBackend;
-  }
-};
-var BackendTransportError = class extends AgentEvalError {
-  backend;
-  status;
-  /**
-   * Truncated upstream response body (≤2 KiB) when available. Diagnostic
-   * only — surfaces in `backend_error.error.body` and `final.error.body`
-   * so operators can see "free_tier_limit", "invalid_api_key", etc. without
-   * cracking the log line open.
-   */
-  body;
-  constructor(backend, message, options) {
-    super("config", message, options);
-    this.backend = backend;
-    this.status = options?.status;
-    this.body = options?.body;
-  }
-};
-var RuntimeRunStateError = class extends AgentEvalError {
-  constructor(message, options) {
-    super("validation", message, options);
-  }
-};
-var PlannerError = class extends AgentEvalError {
-  constructor(message, options) {
-    super("validation", message, options);
-  }
-};
-var AnalystError = class extends AgentEvalError {
-  constructor(message, options) {
-    super("validation", message, options);
-  }
-};
-
-// src/runtime/sandbox-events.ts
-function extractLlmCallEvent(event, agentRunName) {
-  if (!event || typeof event !== "object") return void 0;
-  const type = String(event.type ?? "");
-  const data = event.data && typeof event.data === "object" ? event.data : {};
-  if (type === "llm_call" || type === "cost.usage" || type === "usage") {
-    return buildLlmCall(data, agentRunName);
-  }
-  if (type === "message.completed" || type === "result" || type === "final") {
-    const usage = data.usage;
-    if (!usage || typeof usage !== "object") return void 0;
-    return buildLlmCall({ ...usage, model: data.model ?? usage.model }, agentRunName);
-  }
-  if (type === "done") {
-    const usage = data.tokenUsage;
-    if (!usage || typeof usage !== "object") return void 0;
-    const out = pickFiniteNumber(usage, ["outputTokens", "completion_tokens", "tokensOut"]);
-    const reasoning = pickFiniteNumber(usage, ["reasoningTokens"]);
-    const mergedOut = out !== void 0 || reasoning !== void 0 ? (out ?? 0) + (reasoning ?? 0) : void 0;
-    return buildLlmCall(
-      {
-        inputTokens: usage.inputTokens,
-        outputTokens: mergedOut,
-        totalCostUsd: data.totalCostUsd,
-        model: data.model ?? usage.model
-      },
-      agentRunName
-    );
-  }
-  return void 0;
-}
-function buildLlmCall(data, agentRunName) {
-  const tokensIn = pickFiniteNumber(data, ["tokensIn", "inputTokens", "prompt_tokens"]);
-  const tokensOut = pickFiniteNumber(data, ["tokensOut", "outputTokens", "completion_tokens"]);
-  const costUsd = pickFiniteNumber(data, ["costUsd", "totalCostUsd", "cost_usd", "cost"]);
-  if (tokensIn === void 0 && tokensOut === void 0 && costUsd === void 0) {
-    return void 0;
-  }
-  const model = typeof data.model === "string" && data.model.length > 0 ? data.model : agentRunName;
-  const event = {
-    type: "llm_call",
-    model
-  };
-  if (tokensIn !== void 0) event.tokensIn = tokensIn;
-  if (tokensOut !== void 0) event.tokensOut = tokensOut;
-  if (costUsd !== void 0) event.costUsd = costUsd;
-  return event;
-}
-function pickFiniteNumber(data, keys) {
-  for (const key of keys) {
-    const value = data[key];
-    if (typeof value === "number" && Number.isFinite(value)) return value;
-  }
-  return void 0;
-}
-function mapSandboxEvent(event, opts = {}) {
-  if (!event || typeof event !== "object") return void 0;
-  const type = String(event.type ?? "");
-  const data = event.data && typeof event.data === "object" ? event.data : {};
-  if (type === "message.part.updated") {
-    const part = data.part && typeof data.part === "object" ? data.part : {};
-    const partType = String(part.type ?? "");
-    const delta = typeof data.delta === "string" ? data.delta : void 0;
-    const text = delta ?? (typeof part.text === "string" ? part.text : void 0);
-    if (text === void 0) return void 0;
-    if (partType === "text") return { type: "text_delta", text };
-    if (partType === "reasoning" || partType === "thinking")
-      return { type: "reasoning_delta", text };
-    return void 0;
-  }
-  return extractLlmCallEvent(event, opts.agentRunName ?? "agent");
-}
-
-export {
-  SessionMismatchError,
-  BackendTransportError,
-  RuntimeRunStateError,
-  PlannerError,
-  AnalystError,
-  AgentEvalError2 as AgentEvalError,
-  ConfigError,
-  JudgeError,
-  NotFoundError,
-  ValidationError,
-  extractLlmCallEvent,
-  mapSandboxEvent
-};
-//# sourceMappingURL=chunk-VLF5RHEQ.js.map

package/dist/chunk-VLF5RHEQ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/errors.ts","../src/runtime/sandbox-events.ts"],"sourcesContent":["/**\n * @stable\n *\n * Error taxonomy for `@tangle-network/agent-runtime`.\n *\n * Public contract: every error this package throws as part of its consumer-\n * facing API either extends `AgentEvalError` (re-exported here for ergonomic\n * `instanceof` checks at the runtime boundary) or extends one of the\n * runtime-specific subclasses below.\n *\n * Internal invariant guards (`throw new Error('this should never happen')`)\n * remain plain `Error` — they are programmer-mistake assertions, not\n * consumer-catchable contract failures.\n *\n * Subclassing strategy: where a runtime-specific failure maps cleanly to an\n * agent-eval code (validation, config, not_found), we re-use the agent-eval\n * subclass. Runtime-only failure modes (session resume against the wrong\n * backend, backend transport errors) get fresh subclasses that still carry an\n * `AgentEvalErrorCode` so cross-package handlers can pattern-match without\n * importing the runtime.\n */\n\nimport { AgentEvalError } from '@tangle-network/agent-eval'\n\nexport {\n  AgentEvalError,\n  type AgentEvalErrorCode,\n  ConfigError,\n  JudgeError,\n  NotFoundError,\n  ValidationError,\n} from '@tangle-network/agent-eval'\n\n/**\n * @stable\n *\n * Caller asked to resume a session against a backend whose `kind` does not\n * match the session's recorded backend. This is a routing bug — the same\n * session id was reused across two different backend implementations — and\n * is not retryable without picking the right backend.\n */\nexport class SessionMismatchError extends AgentEvalError {\n  readonly sessionBackend: string\n  readonly requestedBackend: string\n\n  constructor(sessionBackend: string, requestedBackend: string, options?: { cause?: unknown }) {\n    super(\n      'validation',\n      `Cannot resume ${sessionBackend} session with ${requestedBackend} backend`,\n      options,\n    )\n    this.sessionBackend = sessionBackend\n    this.requestedBackend = requestedBackend\n  }\n}\n\n/**\n * @stable\n *\n * A backend transport call (HTTP, gRPC, sidecar IPC) failed with a non-success\n * status. Distinct from `JudgeError` (which is structural / unrecoverable)\n * because backend failures are sometimes retryable and consumers may want to\n * branch on the upstream status code.\n */\nexport class BackendTransportError extends AgentEvalError {\n  readonly backend: string\n  readonly status?: number\n  /**\n   * Truncated upstream response body (≤2 KiB) when available. Diagnostic\n   * only — surfaces in `backend_error.error.body` and `final.error.body`\n   * so operators can see \"free_tier_limit\", \"invalid_api_key\", etc. without\n   * cracking the log line open.\n   */\n  readonly body?: string\n\n  constructor(\n    backend: string,\n    message: string,\n    options?: { cause?: unknown; status?: number; body?: string },\n  ) {\n    super('config', message, options)\n    this.backend = backend\n    this.status = options?.status\n    this.body = options?.body\n  }\n}\n\n/**\n * @stable\n *\n * A runtime-run lifecycle method was called in an order the state machine does\n * not allow: `persist()` before `complete()`, `complete()` twice, etc.\n */\nexport class RuntimeRunStateError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('validation', message, options)\n  }\n}\n\n/**\n * @stable\n *\n * The dynamic-loop planner returned an unusable topology move — the LLM emitted\n * no parseable envelope, an unknown `kind`, or a structurally-invalid move\n * (e.g. a fanout with zero tasks). This is a structural failure of the\n * agent-authored topology, not a config mistake: the planner ran but its output\n * cannot drive the kernel. Carries `validation` so cross-package handlers can\n * pattern-match without importing the runtime. Fail loud — never substitute a\n * default move, or the loop silently runs a topology nobody chose.\n */\nexport class PlannerError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('validation', message, options)\n  }\n}\n\n/**\n * The analyst loop could not read or run over a round's trace — e.g. an empty round\n * (no iterations to analyze) or a malformed trace projection. Fail loud: a silent empty\n * store would mask a broken capture path and the driver would steer on nothing.\n */\nexport class AnalystError extends AgentEvalError {\n  constructor(message: string, options?: { cause?: unknown }) {\n    super('validation', message, options)\n  }\n}\n","/**\n * Sandbox-event → runtime-event mapping.\n *\n * The sandbox SDK emits a polymorphic `SandboxEvent = { type, data, id? }`\n * whose `type` vocabulary is backend-determined (opencode, etc.) rather than\n * enumerated by the SDK. Two consumers project it:\n *   - the loop kernel's cost ledger (`extractLlmCallEvent`) — sums usage off\n *     every cost-bearing event, regardless of stream shape;\n *   - the `AgentRuntime.act` streaming contract (`mapSandboxEvent`) — projects\n *     incremental events to the `RuntimeStreamEvent` chat-UX vocabulary.\n *\n * Both live here so the empirically-observed `type` vocabulary has one home.\n */\n\nimport type { SandboxEvent } from '@tangle-network/sandbox'\nimport type { RuntimeStreamEvent } from '../types'\n\n/**\n * Extract a `RuntimeStreamEvent`-shaped `llm_call` from a sandbox event when\n * the event carries usage/cost data. Returns `undefined` for non-cost events\n * so the kernel can iterate the full stream without branching.\n *\n * Canonical cost-carrying types observed in the wild:\n *   - `llm_call` — `data: { model, tokensIn, tokensOut, costUsd, ... }`\n *   - `message.completed` / `result` — `data: { usage: { inputTokens,\n *      outputTokens, totalCostUsd? } }`\n *   - `cost.usage` / `usage` — same shape under a dedicated type\n *\n * Numeric coercion is strict: `Number.isFinite` gates every accumulator write\n * so a sentinel `NaN` from a misbehaving backend cannot poison the ledger.\n */\nexport function extractLlmCallEvent(\n  event: SandboxEvent,\n  agentRunName: string,\n): (RuntimeStreamEvent & { type: 'llm_call' }) | undefined {\n  if (!event || typeof event !== 'object') return undefined\n  const type = String(event.type ?? '')\n  const data =\n    event.data && typeof event.data === 'object'\n      ? (event.data as Record<string, unknown>)\n      : ({} as Record<string, unknown>)\n\n  if (type === 'llm_call' || type === 'cost.usage' || type === 'usage') {\n    return buildLlmCall(data, agentRunName)\n  }\n  if (type === 'message.completed' || type === 'result' || type === 'final') {\n    const usage = data.usage as Record<string, unknown> | undefined\n    if (!usage || typeof usage !== 'object') return undefined\n    return buildLlmCall({ ...usage, model: data.model ?? usage.model }, agentRunName)\n  }\n  // sandbox 0.4.0 terminal event: `data = { tokenUsage: { inputTokens, outputTokens,\n  // reasoningTokens, cacheReadInputTokens }, totalCostUsd }`. Usage lives under\n  // `tokenUsage` (not `usage`) and the cost is top-level — neither matched the\n  // branches above, so an in-process loopDispatch run reported {0,0} and the\n  // backend-integrity guard misread a real run as a stub. Reasoning tokens are\n  // billed output (reasoning models), so they fold into the output count.\n  if (type === 'done') {\n    const usage = data.tokenUsage as Record<string, unknown> | undefined\n    if (!usage || typeof usage !== 'object') return undefined\n    const out = pickFiniteNumber(usage, ['outputTokens', 'completion_tokens', 'tokensOut'])\n    const reasoning = pickFiniteNumber(usage, ['reasoningTokens'])\n    const mergedOut =\n      out !== undefined || reasoning !== undefined ? (out ?? 0) + (reasoning ?? 0) : undefined\n    return buildLlmCall(\n      {\n        inputTokens: usage.inputTokens,\n        outputTokens: mergedOut,\n        totalCostUsd: data.totalCostUsd,\n        model: data.model ?? usage.model,\n      },\n      agentRunName,\n    )\n  }\n  return undefined\n}\n\nfunction buildLlmCall(\n  data: Record<string, unknown>,\n  agentRunName: string,\n): (RuntimeStreamEvent & { type: 'llm_call' }) | undefined {\n  const tokensIn = pickFiniteNumber(data, ['tokensIn', 'inputTokens', 'prompt_tokens'])\n  const tokensOut = pickFiniteNumber(data, ['tokensOut', 'outputTokens', 'completion_tokens'])\n  const costUsd = pickFiniteNumber(data, ['costUsd', 'totalCostUsd', 'cost_usd', 'cost'])\n  if (tokensIn === undefined && tokensOut === undefined && costUsd === undefined) {\n    return undefined\n  }\n  const model = typeof data.model === 'string' && data.model.length > 0 ? data.model : agentRunName\n  const event: RuntimeStreamEvent & { type: 'llm_call' } = {\n    type: 'llm_call',\n    model,\n  }\n  if (tokensIn !== undefined) event.tokensIn = tokensIn\n  if (tokensOut !== undefined) event.tokensOut = tokensOut\n  if (costUsd !== undefined) event.costUsd = costUsd\n  return event\n}\n\nfunction pickFiniteNumber(data: Record<string, unknown>, keys: string[]): number | undefined {\n  for (const key of keys) {\n    const value = data[key]\n    if (typeof value === 'number' && Number.isFinite(value)) return value\n  }\n  return undefined\n}\n\n/**\n * Project one `SandboxEvent` onto the `RuntimeStreamEvent` chat-UX vocabulary,\n * for runtimes that bridge a sandbox `streamPrompt` into the\n * `AgentRuntime.act` streaming contract. Returns `undefined` for events that\n * have no faithful projection — the raw stream is preserved separately for the\n * `OutputAdapter`, so an unmapped event never loses data.\n *\n * Mapped (the task-optional incremental variants — no synthesized task\n * lifecycle, no guessed tool-part shapes):\n *   - `message.part.updated` text part → `text_delta`\n *   - `message.part.updated` reasoning/thinking part → `reasoning_delta`\n *   - cost-bearing events → `llm_call` (shared with the ledger extractor)\n *\n * The opencode backend emits incremental text as\n * `{ type: 'message.part.updated', data: { part: { type, text }, delta } }`;\n * `delta` is the increment, `part.text` the running accumulation.\n */\nexport function mapSandboxEvent(\n  event: SandboxEvent,\n  opts: { agentRunName?: string } = {},\n): RuntimeStreamEvent | undefined {\n  if (!event || typeof event !== 'object') return undefined\n  const type = String(event.type ?? '')\n  const data =\n    event.data && typeof event.data === 'object'\n      ? (event.data as Record<string, unknown>)\n      : ({} as Record<string, unknown>)\n\n  if (type === 'message.part.updated') {\n    const part =\n      data.part && typeof data.part === 'object' ? (data.part as Record<string, unknown>) : {}\n    const partType = String(part.type ?? '')\n    const delta = typeof data.delta === 'string' ? data.delta : undefined\n    const text = delta ?? (typeof part.text === 'string' ? part.text : undefined)\n    if (text === undefined) return undefined\n    if (partType === 'text') return { type: 'text_delta', text }\n    if (partType === 'reasoning' || partType === 'thinking')\n      return { type: 'reasoning_delta', text }\n    return undefined\n  }\n\n  return extractLlmCallEvent(event, opts.agentRunName ?? 'agent')\n}\n"],"mappings":"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","names":["AgentEvalError"]}

package/dist/coder-2leJPOvC.d.ts

@@ -1,52 +0,0 @@
-import { AgentProfile } from '@tangle-network/agent-interface';
-
-/**
- * @experimental
- *
- * `coderProfile` — the §1.5 author-the-profile DATA for code-modification tasks: an `AgentProfile`
- * constant (the agent IS its profile) plus a pure `coderTaskToPrompt` formatter that renders a
- * `CoderTask` into the per-task instruction. There is no factory, output adapter, or validator
- * here — a domain customizes the worker by authoring a profile + handing it to a leaf executor
- * (`createWorktreeCliExecutor`) or a fanout (`worktreeFanout`), and "is it delivered" is a
- * `DeliverableSpec` (`patchDelivered`), not a bundled validator.
- *
- * The standing instruction tells the agent to work on a fresh branch, keep the patch minimal,
- * avoid forbidden paths, and run the test + typecheck commands before declaring done.
- */
-
-/** @experimental The per-task inputs `coderTaskToPrompt` renders + the worktree gate enforces. */
-interface CoderTask {
-    /** What the agent must accomplish. Free-form prose. */
-    goal: string;
-    /** Absolute path inside the sandbox where the repo lives. */
-    repoRoot: string;
-    /** Default `main`. The branch the agent diffs against. */
-    baseBranch?: string;
-    /** Default `pnpm test --run`. */
-    testCmd?: string;
-    /** Default `pnpm typecheck`. */
-    typecheckCmd?: string;
-    /** Files the agent may inspect for context. Surfaced verbatim in the prompt. */
-    contextFiles?: string[];
-    /**
-     * Paths the agent must not touch. The mechanical gate hard-fails on any match.
-     * Use glob-free literal path prefixes for unambiguous enforcement.
-     */
-    forbiddenPaths?: string[];
-    /** Default 400. Hard cap; the gate hard-fails when exceeded. */
-    maxDiffLines?: number;
-}
-/** @experimental The coder agent's standing instruction (its body lives in `coderProfile.prompt`). */
-declare const DEFAULT_CODER_SYSTEM_PROMPT: string;
-/**
- * @experimental
- *
- * The coder `AgentProfile` — the §1.5 DATA the substrate materializes into a harness invocation.
- * Stateless and harness-agnostic: a consumer overrides `model`/`metadata.backendType` by spreading
- * a copy, never by a factory. `worktreeFanout` authors one such profile per harness leaf.
- */
-declare const coderProfile: AgentProfile;
-/** @experimental Render a `CoderTask` into the per-task instruction handed to the coder profile. */
-declare function coderTaskToPrompt(task: CoderTask): string;
-
-export { type CoderTask as C, DEFAULT_CODER_SYSTEM_PROMPT as D, coderTaskToPrompt as a, coderProfile as c };

package/dist/improvement.d.ts

@@ -1,208 +0,0 @@
-import { AnalystFinding } from '@tangle-network/agent-eval';
-import { L as LocalHarness, r as runLocalHarness } from './local-harness-BE_h8szs.js';
-import { LabeledScenarioStore, WorktreeAdapter, ImprovementDriver } from '@tangle-network/agent-eval/campaign';
-import { S as SurfaceImprovementEdit } from './improvement-adapter-BC4HhuAR.js';
-import { I as ImprovementAdapter } from './types-p8dWBIXL.js';
-import 'node:child_process';
-
-/**
- * @experimental
- *
- * `improvementDriver` — the ONE reflective/agentic improvement driver for
- * agent-eval's improvement loop. It implements `ImprovementDriver` and owns
- * the candidate lifecycle (worktree create → generate → finalize/discard,
- * × populationSize); it delegates the only thing that genuinely varies — HOW
- * a candidate change is produced — to a pluggable `CandidateGenerator`.
- *
- * There is no separate "analyst driver" vs "autoresearch driver": those are
- * the SAME driver at two settings of a dial.
- *   - cheap reflective path  → `reflectiveGenerator` (shots=1, no sandbox;
- *                              applies pre-drafted patches)
- *   - full agentic path      → `agenticGenerator` (shots=N, multi-shot
- *                              verify-in-session loop; an agent reads code +
- *                              report, edits, and re-tries on verifier failure)
- * Both emit changes into a worktree the driver finalizes into a
- * `CodeSurface{ worktreeRef }` the loop measures on the holdout. See
- * agent-eval's `docs/design/self-improvement-engine.md`.
- */
-
-/** The byte-producing seam — the ONE thing that differs between the cheap
- *  reflective path and the full agentic path. A generator makes (uncommitted)
- *  changes inside `worktreePath`; the driver commits them via the worktree
- *  adapter's `finalize`. */
-interface CandidateGenerator {
-    kind: string;
-    generate(args: {
-        /** The candidate worktree — a fresh checkout of baseRef. Write changes here. */
-        worktreePath: string;
-        /** Phase-2 research report (analyst findings + diff), opaque. */
-        report: unknown;
-        /** Findings resolved from the report or the loop context. */
-        findings: AnalystFinding[];
-        /** Handle to all captured data, to ground the change. */
-        dataset?: LabeledScenarioStore;
-        /** DEPTH: max iterations the generator may take (agentic uses this; the
-         *  reflective generator ignores it). */
-        maxShots: number;
-        signal: AbortSignal;
-    }): Promise<{
-        applied: boolean;
-        summary: string;
-    }>;
-}
-interface ImprovementDriverOptions {
-    worktree: WorktreeAdapter;
-    generator: CandidateGenerator;
-    /** Base ref candidate worktrees fork from. Default `main`. */
-    baseRef?: string;
-}
-declare function improvementDriver(opts: ImprovementDriverOptions): ImprovementDriver<AnalystFinding>;
-
-/**
- * @experimental
- *
- * `agenticGenerator` — the full-agentic `CandidateGenerator`: the
- * `shots=N, sandbox=on` setting of the one `improvementDriver`. It runs a real
- * coding harness (claude / codex / opencode) inside the candidate worktree the
- * driver already created, letting the agent read the codebase + the research
- * report and make the change in place. The driver then commits the worktree
- * into a `CodeSurface`.
- *
- * Mechanism: identical to the proven Phase-2.8 in-process executor — spawn the
- * harness as a subprocess with `cwd` = the worktree, on the same filesystem,
- * so edits land in place (no sandbox-mount round-trip). `runLocalHarness` is
- * the verified primitive. The OUTER sandbox is the improvement loop's own
- * execution context; the generator does not nest a second sandbox per
- * candidate (which would reintroduce a host↔sandbox worktree-transport
- * problem that does not need solving here).
- *
- * `maxShots` is the DEPTH dial — a multi-shot verify-in-session loop, NOT the
- * kernel `runLoop`. Each shot runs one full harness session in the (persistent)
- * worktree; between shots the loop refines based on what the last shot produced:
- *   - empty tree   → "you changed nothing, make the edits" → retry
- *   - dirty + `verify` fails → feed the verifier's failure into the next shot
- *       (the worktree persists, so the harness RESUMES atop its own failing
- *       edits with the error in hand — no `--resume` session plumbing needed,
- *       and harness-agnostic across claude/codex/opencode)
- *   - dirty + `verify` ok (or no verifier configured) → return the candidate
- * A candidate that never verifies within `maxShots` is discarded (`applied:
- * false`), never shipped — if you configured a verifier, a non-passing tree is
- * not a candidate. With no verifier the legacy behavior holds: first dirty shot
- * is the candidate.
- */
-
-/** Outcome of verifying a candidate worktree. `feedback` (compiler errors,
- *  failing test output) is fed into the next shot when `ok` is false. */
-interface VerifyResult {
-    ok: boolean;
-    feedback?: string;
-}
-/** Verifies the edited worktree. Sync or async; throws only on a setup fault
- *  (a candidate that fails verification returns `{ok:false}`, it does not
- *  throw). */
-type Verifier = (worktreePath: string) => Promise<VerifyResult> | VerifyResult;
-interface AgenticGeneratorOptions {
-    /** Local coding harness to run in the worktree. Default `claude`. */
-    harness?: LocalHarness;
-    /** Per-shot wall-clock timeout (ms). Default = `runLocalHarness` default (5m). */
-    timeoutMs?: number;
-    /** Build the harness task prompt from the report + findings. Override for
-     *  domain phrasing; the default turns findings into a concrete coder task. */
-    buildPrompt?: (args: {
-        report: unknown;
-        findings: AnalystFinding[];
-    }) => string;
-    /** Verify the worktree after each dirtying shot. When set, a candidate that
-     *  fails verification is NOT returned — the failure feeds the next shot
-     *  (verify-in-session), up to `maxShots`; a candidate that never verifies is
-     *  discarded (`applied:false`), never shipped. Omitted ⇒ legacy behavior:
-     *  the first dirty shot is the candidate. See `commandVerifier`. */
-    verify?: Verifier;
-    /** Test seam — inject the harness runner (defaults to `runLocalHarness`). */
-    runHarness?: typeof runLocalHarness;
-    /** Test seam — inject the worktree-dirty check (defaults to `git status`). */
-    isDirty?: (worktreePath: string) => boolean;
-}
-declare function agenticGenerator(opts?: AgenticGeneratorOptions): CandidateGenerator;
-/** A `Verifier` that runs a command in the worktree: exit 0 ⇒ ok, any other
- *  exit ⇒ failed with stdout+stderr as feedback. The common case — verify by
- *  `tsc --noEmit`, `pnpm build`, or a test command. A timeout is treated as a
- *  FAILED candidate (a change that hangs the build is a bad change); a missing
- *  binary or spawn fault throws (a setup bug, not a failed candidate — no
- *  silent fallback). */
-declare function commandVerifier(command: string, args?: string[], timeoutMs?: number): Verifier;
-
-/**
- * Build-prompt starting points for the two buildable artifact types. There is
- * NO `toolGenerator`/`mcpGenerator` wrapper — the factory is `agenticGenerator`
- * + a verifier (docs/artifact-lifecycle-frontier.md), so a tool or an MCP
- * server is built by composing the pieces directly:
- *
- *   // a tool:
- *   agenticGenerator({ buildPrompt: toolBuildPrompt, verify: commandVerifier('pnpm', ['test']) })
- *   // an MCP server:
- *   agenticGenerator({ buildPrompt: mcpBuildPrompt, verify: mcpServeVerifier({ command: 'node', args: ['server.mjs'] }) })
- *
- * These are the only type-specific bit (the phrasing that points the agent at a
- * tool vs. an MCP); the worktree, resume-on-failure loop, and improvement-loop
- * wrapper are shared. MCP is the load-bearing target — it is how a harness
- * acquires tools; raw tools matter where we control the loader.
- */
-
-type FindingsArg = {
-    report: unknown;
-    findings: AnalystFinding[];
-};
-declare function toolBuildPrompt(args: FindingsArg): string;
-declare function mcpBuildPrompt(args: FindingsArg): string;
-
-/**
- * `mcpServeVerifier` — the intrinsic verifier for a built MCP server: the
- * boot-and-probe checker named in docs/artifact-lifecycle-frontier.md. A
- * generated MCP server is only a candidate if it actually *serves* — so this
- * boots it over stdio (the default local MCP transport) and runs the real
- * handshake: `initialize` → `notifications/initialized` → `tools/list`, and
- * asserts the server answers with at least `minTools` tools.
- *
- * Outcomes follow the `Verifier` contract: a server that fails to start, exits
- * early, errors the handshake, times out, or exposes no tools is a FAILED
- * candidate (`{ok:false}`, fed back into the next generation shot); a missing
- * start binary or spawn fault THROWS (a setup bug, never a silent fallback).
- *
- * Protocol matches the runtime's own stdio MCP server (src/mcp/server.ts):
- * newline-delimited JSON-RPC 2.0, protocol version 2024-11-05.
- */
-
-interface McpServeSpec {
-    /** Command that starts the built MCP server in the worktree (stdio transport). */
-    command: string;
-    args?: string[];
-    /** Extra env for the server process (merged over `process.env`). */
-    env?: Record<string, string>;
-    /** Handshake timeout (ms). Default 30s. */
-    timeoutMs?: number;
-    /** Minimum tools the server must expose to pass. Default 1. */
-    minTools?: number;
-}
-declare function mcpServeVerifier(spec: McpServeSpec): Verifier;
-
-/**
- * @experimental
- *
- * `reflectiveGenerator` — the cheap, no-sandbox `CandidateGenerator`. It drafts
- * surface edits via the existing improvement adapter (`proposeFromFindings`,
- * one LLM patch per finding) and applies them as ONE coherent improvement into
- * the candidate worktree. `maxShots` is ignored — reflection is single-shot by
- * construction (the patches are already drafted).
- *
- * This is the `shots=1, sandbox=off` setting of the one improvement driver.
- * The `agenticGenerator` (a multi-shot verify-in-session loop) is the
- * `shots=N` setting — both plug into the same `improvementDriver`.
- */
-
-interface ReflectiveGeneratorOptions {
-    improvementAdapter: ImprovementAdapter<SurfaceImprovementEdit>;
-}
-declare function reflectiveGenerator(opts: ReflectiveGeneratorOptions): CandidateGenerator;
-
-export { type AgenticGeneratorOptions, type CandidateGenerator, type ImprovementDriverOptions, type McpServeSpec, type ReflectiveGeneratorOptions, type Verifier, type VerifyResult, agenticGenerator, commandVerifier, improvementDriver, mcpBuildPrompt, mcpServeVerifier, reflectiveGenerator, toolBuildPrompt };