@tangle-network/agent-runtime 0.104.0 → 0.106.0

package/dist/index.d.ts

@@ -1,1134 +1,14 @@
-import { AgentEvalError, AnalystFinding, KnowledgeReadinessReport, RunRecord, ControlEvalResult } from '@tangle-network/agent-eval';
-export { AgentEvalError, AgentEvalErrorCode, ConfigError, ControlBudget, ControlDecision, ControlEvalResult, ControlRunResult, ControlStep, DataAcquisitionPlan, JudgeError, KnowledgeReadinessReport, KnowledgeRequirement, NotFoundError, RunRecord, ValidationError } from '@tangle-network/agent-eval';
-import { c as createOpenAICompatibleBackend } from './backends-BO4Jqoe2.js';
-export { a as createIterableBackend, b as createSandboxPromptBackend } from './backends-BO4Jqoe2.js';
-export { AGENT_CANDIDATE_EXECUTION_SUPPORT, AgentCandidateBundleInput, AgentCandidateCodeSource, AgentCandidateCodeSurfaceSource, AgentCandidateProfileSource, AgentCandidateWorkspaceArchiveLimits, BuildAgentCandidateBundleInput, CANDIDATE_KNOWLEDGE_RETRIEVAL_CONFIG_ENV, CANDIDATE_KNOWLEDGE_ROOT_ENV, CaptureAgentCandidateWorkspaceOptions, CapturedAgentCandidateWorkspace, CreateAgentCandidateWorkspacePortOptions, DisposePreparedAgentCandidateOptions, ExactProcessCandidateExecutorOptions, FileAgentCandidateExecutionClaimStore, FileAgentCandidateExecutionClaimStoreOptions, RecoverExpiredAgentCandidateOptions, buildAgentCandidateBundle, candidateExecutionClaim, candidateKnowledgeExecutionPaths, captureAgentCandidateWorkspace, captureAgentCandidateWorkspaceFiles, createAgentCandidateWorkspacePort, disposePreparedAgentCandidateExecution, exactProcessProviderAsCandidateExecutor, persistCandidateOutputArtifact, recoverExpiredAgentCandidateExecution, sealAgentCandidateBundle, verifyAgentCandidateBundle } from './candidate-execution/index.js';
-export { a as AgentCandidateExecutionAttemptRecord, b as AgentCandidateExecutionAttemptRef, c as AgentCandidateExecutionClaim, d as AgentCandidateExecutionClaimResult, A as AgentCandidateExecutionClaimStore, e as AgentCandidateExecutionCleanupHandles, f as AgentCandidateExecutionFailureClass, g as AgentCandidateExecutionFinishResult, h as AgentCandidateExecutionLease, i as AgentCandidateExecutionPhase, j as AgentCandidateExecutionPhaseResult, k as AgentCandidateExecutionRecoveryEvidence, l as AgentCandidateExecutionStageResult, m as AgentCandidateExecutionTerminalRecord, n as AgentCandidateExecutionTerminalResult, o as AgentCandidateModelGrantActivateInput, q as AgentCandidateModelGrantClient, r as AgentCandidateModelGrantReservation, s as AgentCandidateModelGrantReserveInput, t as AgentCandidateModelGrantSettleInput, u as AgentCandidatePreparationEvidence, v as AgentCandidateRetryRejection, C as CreateProtectedAgentCandidateModelPortOptions, E as ExecutePreparedAgentCandidateOptions, I as InMemoryAgentCandidateExecutionClaimStore, P as PrepareAgentCandidateExecutionOptions, w as applyExactAgentProfileDiff, x as assertCandidateProfileBinding, y as createProtectedAgentCandidateModelPort, z as executePreparedAgentCandidate, B as parseExactAgentProfile, D as parseExactAgentProfileDiff, F as prepareAgentCandidateExecution } from './protected-model-port-DzkUY3HQ.js';
-export { j as AgentCandidateArtifactPort, a as AgentCandidateBenchmarkGraderPort, k as AgentCandidateContainerPort, e as AgentCandidateExecutionPorts, l as AgentCandidateExecutorFinalCapture, m as AgentCandidateExecutorMemoryCapture, A as AgentCandidateExecutorPort, n as AgentCandidateExecutorProfileFile, o as AgentCandidateExecutorRequest, p as AgentCandidateExecutorStopRequest, q as AgentCandidateExecutorTaskOutcomeCapture, r as AgentCandidateExecutorWorkspaceFile, s as AgentCandidateExecutorWorkspaceInput, t as AgentCandidateMemoryPort, u as AgentCandidateMemoryResetResult, v as AgentCandidateModelLimits, f as AgentCandidateModelPort, b as AgentCandidateOutputArtifactPort, w as AgentCandidateOutputPurpose, h as AgentCandidateProtectedModelActivation, g as AgentCandidateProtectedModelReservation, i as AgentCandidateProtectedModelSettlement, x as AgentCandidateProtectedRunCapture, y as AgentCandidateRepositoryPort, c as AgentCandidateRunFinalization, d as AgentCandidateTaskExecution, z as AgentCandidateVerificationPorts, B as AgentCandidateWorkspacePort, C as CANDIDATE_TRACE_ENV, D as CANDIDATE_TRACE_TAGS, E as CanonicalCandidateDocument, P as PreparedAgentCandidateExecution, F as PreparedAgentCandidateInstruction, G as PreparedAgentCandidateKnowledge, H as PreparedAgentCandidateLaunch, I as PreparedAgentCandidateTrace, R as ResolvedAgentCandidateContainer, V as VerifiedAgentCandidate, J as VerifiedAgentCandidateTaskOutcome } from './types-Cbp72qyu.js';
-export { AuthSource, BackendCallPolicy, CircuitBreakerConfig, CircuitBreakerState, CircuitOpenError, Conversation, ConversationDriveState, ConversationJournal, ConversationJournalEntry, ConversationParticipant, ConversationPolicy, ConversationResult, ConversationStreamEvent, ConversationTurn, D1DatabaseLike, D1StmtLike, DEFAULT_MAX_DEPTH, DeadlineExceededError, FORWARD_HEADERS, FileConversationJournal, ForwardHeaderName, HaltContext, HaltPredicate, HaltReason, HaltSignal, InMemoryConversationJournal, PersonaConversationResult, PersonaDriver, PropagatedHeaders, RetryBackoff, RetryableErrorPredicate, RunConversationOptions, RunPersonaConfig, RunPersonaConversationOptions, SqlAdapter, SqlConversationJournal, TurnOrder, buildForwardHeaders, computeBackoff, createConversationBackend, d1ToSqlAdapter, defaultIsRetryable, defineConversation, isDepthExceeded, makePerAttemptSignal, readDepth, runConversation, runConversationStream, runPersonaConversation, runPersonaDispatch, sleep, slugifySpeaker, turnId } from './conversation.js';
-import { V as Verifier, C as CandidateGenerator } from './improve--2A0gK1-.js';
-export { A as AGENTIC_PROFILE_RESOURCE_ROOT, b as AgenticGeneratorOptions, c as AgenticGeneratorShotDisposition, d as AgenticGeneratorShotExecution, e as AgenticGeneratorShotReceipt, f as ImproveCodeOptions, I as ImproveOptions, a as ImproveResult, g as ImproveSkillsOptions, h as ImproveSurface, i as ImprovementCandidate, j as ImprovementDriverOptions, M as ManagedImprovementDriver, k as VerifyResult, l as agenticGenerator, m as commandVerifier, n as defaultBuildPrompt, o as improve, p as improvementDriver } from './improve--2A0gK1-.js';
-import { ProposeContext, SurfaceProposer, MutableSurface } from '@tangle-network/agent-eval/campaign';
-import { L as LocalHarness, r as runLocalHarness } from './local-harness-CtK9dSny.js';
-import { T as ToolLoopChat, c as RuntimeTelemetryOptions } from './sanitize-DEbPNtyI.js';
-export { d as RuntimeEventCollector, e as RuntimeStreamEventCollector, S as SanitizedKnowledgeReadinessReport, f as createRuntimeEventCollector, g as createRuntimeStreamEventCollector, s as sanitizeAgentRuntimeEvent, h as sanitizeKnowledgeReadinessReport, i as sanitizeRuntimeStreamEvent } from './sanitize-DEbPNtyI.js';
-import { AgentProfile, AgentProfileDiff } from '@tangle-network/agent-interface';
-export { AgentCandidateBenchmarkGraderIdentity } from '@tangle-network/agent-interface';
-import { Scenario, SelfImproveOptions } from '@tangle-network/agent-eval/contract';
-import { S as SurfaceImprovementEdit } from './improvement-adapter-HAZz-7vK.js';
-import { I as ImprovementProposalSource } from './types-CmYCMbFT.js';
-import { S as StructuralRolloutPolicy } from './structural-rollout-C4mabf87.js';
-export { AgentKnowledgeReadinessCheckOptions, CreateKnowledgeImprovementActivationExecutorOptions, KnowledgeImprovementActivationExecutor, KnowledgeImprovementCandidatePair, KnowledgeImprovementExperimentBundles, KnowledgeImprovementJobMeasurement, KnowledgeImprovementJobResult, KnowledgeReadinessCheck, KnowledgeReadinessCheckInput, KnowledgeReadinessCheckResult, RESEARCH_SUPERVISOR_SYSTEM_PROMPT, RunKnowledgeImprovementJobOptions, SupervisedKnowledgeUpdateInput, SupervisedKnowledgeUpdateOptions, SupervisedKnowledgeUpdateResult, SupervisedKnowledgeUpdater, buildKnowledgeImprovementExperimentBundles, createAgentKnowledgeReadinessCheck, createKnowledgeImprovementActivationExecutor, createSupervisedKnowledgeUpdater, formatSupervisedKnowledgeTask, knowledgeReadinessDeliverable, runKnowledgeImprovementJob, runSupervisedKnowledgeUpdate } from './knowledge.js';
-export { D as DELEGATED_LOOP_MODES, a as DelegatedLoopMode, b as DelegatedLoopRegistry, c as DelegatedLoopResult, d as DelegatedLoopRunner, L as LoopRunnerCliArgs, e as LoopRunnerCliResult, R as ResearchLoopResult, f as ResearchLoopRunnerOptions, g as RunDelegatedLoopOptions, V as VetoedFact, W as WorktreeLoopRunnerOptions, h as auditLoopRunner, i as isDelegatedLoopMode, p as parseLoopRunnerArgv, r as researchLoopRunner, j as runDelegatedLoop, k as runLoopRunnerCli, s as selfImproveLoopRunner, w as worktreeLoopRunner } from './loop-runner-bin-DUOGtvOl.js';
-export { m as mcpToolsForRuntimeMcp, a as mcpToolsForRuntimeMcpSubset } from './openai-tools-fnj6SRVg.js';
-export { b1 as EvalRunEvent, b2 as EvalRunGeneration, b3 as EvalRunsExportConfig, b4 as EvalRunsExportResult, b5 as INTELLIGENCE_WIRE_VERSION, b6 as LoopSpanNode, b7 as OtelAttribute, b8 as OtelExportConfig, b9 as OtelExporter, ba as OtelSpan, bb as RuntimeEventOtelOptions, bc as buildLoopOtelSpans, bd as buildLoopSpanNodes, be as buildRuntimeEventOtelSpans, bf as createOtelExporter, bg as exportEvalRuns, bh as loopEventToOtelSpan } from './coordination-CxtzMxSM.js';
-import { K as KnowledgeReadinessDecision, A as AgentBackendInput, c as AgentExecutionBackend, h as RunAgentTaskOptions, i as AgentTaskRunResult, j as RunAgentTaskStreamOptions, R as RuntimeStreamEvent, k as RuntimeSessionStore, l as RuntimeSession } from './types-BwoZWq-i.js';
-export { m as AgentAdapter, d as AgentBackendContext, n as AgentKnowledgeProvider, e as AgentRuntimeEvent, o as AgentRuntimeEventSink, p as AgentTaskContext, g as AgentTaskSpec, f as AgentTaskStatus, B as BackendErrorDetail, b as OpenAIChatResponseFormat, O as OpenAIChatTool, a as OpenAIChatToolChoice } from './types-BwoZWq-i.js';
-import { R as RuntimeHooks } from './types-BCoemcXU.js';
-export { d as RuntimeDecisionEvidenceRef, e as RuntimeDecisionKind, f as RuntimeDecisionPoint, g as RuntimeHookContext, h as RuntimeHookErrorContext, i as RuntimeHookEvent, j as RuntimeHookPhase, k as RuntimeHookTarget, l as RuntimeRunHandle, m as RuntimeRunPersistenceAdapter, n as RuntimeRunRow, o as composeRuntimeHooks, p as defineRuntimeHooks, q as notifyRuntimeDecisionPoint, r as notifyRuntimeHookEvent, s as startRuntimeRun } from './types-BCoemcXU.js';
-import '@tangle-network/agent-interface/environment-provider';
-import 'node:child_process';
-import './worktree-fanout-WsOzt8qu.js';
-import './types-CvNwMzQt.js';
-import '@tangle-network/sandbox';
-import './completion-gate-Bv47cOnn.js';
-import '@tangle-network/agent-profile-materialize';
-import '@tangle-network/agent-knowledge';
-import './activation-Cm-9MMX1.js';
-import './supervise-7q9F5brx.js';
-import './kb-gate-CwHO0vz6.js';
-import './substrate-Dyiqmd3o.js';
-import './environment-provider.js';
-
-/**
- * `handleChatTurn` — framework-neutral chat-turn HTTP orchestrator.
- * Owns the NDJSON `ChatStreamEvent` line protocol, the `session.run.*`
- * lifecycle vocabulary, and the persist / post-process / trace-flush
- * hook order. Returns a `ReadableStream` body the product hands to its
- * platform `Response`.
- *
- * Execution durability is the substrate's concern: `box.streamPrompt`
- * auto-reconnects in-call; cross-process reconnect via `X-Execution-ID`
- * is the product's job. The producer this engine wraps already speaks
- * that protocol — the engine just frames the events.
- *
- * Hooks (`ChatTurnHooks`):
- *   - `produce`                  — build the backend event stream
- *   - `persistAssistantMessage`  — write the assistant turn to the product DB
- *   - `onTurnComplete?`          — post-process (proposals, citations, …)
- *   - `onEvent?`                 — per-event side channel (e.g. DO broadcast)
- *   - `transformFinalText?`      — pre-persist transform (e.g. PII redact)
- *   - `traceFlush?`              — handed to waitUntil so OTLP export lands
- *
- * Framework neutrality: takes already-resolved values (`identity` tuple,
- * a `waitUntil`), never a `Request` or a `Context`. The product's thin
- * route adapter does auth + parse + access-control, then calls
- * `handleChatTurn(...)` and returns `result.body` as its platform `Response`.
- */
-/** The NDJSON line protocol every product chat client already speaks. */
-interface ChatStreamEvent {
-    type: string;
-    data?: Record<string, unknown>;
-}
-/** Identity of a chat turn. `tenantId` is the workspace id for workspace-
- *  scoped products and the user id for session-scoped products. */
-interface ChatTurnIdentity {
-    tenantId: string;
-    /** Thread / session id. */
-    sessionId: string;
-    userId: string;
-    /** Monotonic 0-based turn index within the session. */
-    turnIndex: number;
-}
-/** The live side of a turn — what the product's `produce` hook returns. */
-interface ChatTurnProducer<TEvent extends ChatStreamEvent = ChatStreamEvent> {
-    /** The turn's event stream. Forwarded verbatim to the caller. */
-    stream: AsyncGenerator<TEvent, void, unknown>;
-    /** The turn's final assistant text. Read once, after `stream` drains. */
-    finalText(): string;
-}
-interface ChatTurnHooks {
-    /** Build the backend stream. The engine forwards events verbatim and
-     *  reads `finalText()` once the stream drains. */
-    produce(): ChatTurnProducer;
-    /** Persist the assistant message to the product's own store. Called
-     *  once, after drain, with the assembled (transform-applied) text. */
-    persistAssistantMessage(input: {
-        identity: ChatTurnIdentity;
-        finalText: string;
-    }): Promise<void>;
-    /** Optional post-processing (proposals, citations, credit metering …).
-     *  Errors are swallowed + logged — post-process must never fail a turn
-     *  that already streamed successfully. */
-    onTurnComplete?(input: {
-        identity: ChatTurnIdentity;
-        finalText: string;
-    }): Promise<void>;
-    /** Optional per-event side channel (e.g. DO broadcast). Runs for every
-     *  emitted event, lifecycle envelope included. Errors swallowed — a
-     *  broadcast failure must not break the chat stream. */
-    onEvent?(event: ChatStreamEvent): void | Promise<void>;
-    /** Optional pre-persist transform of the final text (e.g. PII
-     *  redaction). Affects only what is persisted; the live stream is
-     *  never altered. */
-    transformFinalText?(text: string): string | Promise<string>;
-    /** Optional trace flush — resolves when OTLP export completes. Handed
-     *  to `waitUntil` so the worker isolate stays alive for the POST. */
-    traceFlush?(): Promise<void>;
-}
-interface RunChatTurnInput {
-    identity: ChatTurnIdentity;
-    hooks: ChatTurnHooks;
-    /** Worker liveness hook. When omitted, trace flush is awaited inline
-     *  before the stream closes. */
-    waitUntil?: (p: Promise<unknown>) => void;
-    /** Structured logger for swallowed hook errors. Defaults to
-     *  `console.error` so failures surface without product wiring. */
-    log?: (message: string, meta?: Record<string, unknown>) => void;
-}
-interface ChatTurnResult {
-    /** NDJSON body — return this as the platform `Response` body. */
-    body: ReadableStream<Uint8Array>;
-    /** Content type for the response. */
-    contentType: 'application/x-ndjson';
-}
-/**
- * Run one chat turn. Returns immediately with a `ReadableStream` body;
- * the turn executes as the body is pulled. Never rejects — backend
- * failures surface as `error` + `session.run.failed` events.
- */
-declare function handleChatTurn(input: RunChatTurnInput): ChatTurnResult;
-
-/**
- * Derive a stable executionId from the run identity. The same
- * `(projectId, sessionId, turnIndex)` tuple yields the same id — so a
- * client retry of the same turn lands on the same substrate execution
- * and the orchestrator's buffer replays instead of starting a second
- * prompt.
- *
- * Format is readable, not hashed: operators grepping orchestrator logs
- * for `gtm-agent:thread-abc:3` find the run without translating an
- * opaque id. Substrate executionIds are not a secrecy boundary.
- *
- * Wire integration:
- *   - Sandbox PromptOptions accepts `executionId` and `lastEventId`.
- *     Products pass this id to make cross-process reconnect land on the
- *     same substrate execution instead of spawning a duplicate run.
- */
-declare function deriveExecutionId(input: {
-    projectId: string;
-    sessionId: string;
-    turnIndex: number;
-}): string;
-
-/**
- *
- * Error taxonomy for `@tangle-network/agent-runtime`.
- *
- * Public contract: every error this package throws as part of its consumer-
- * facing API either extends `AgentEvalError` (re-exported here for ergonomic
- * `instanceof` checks at the runtime boundary) or extends one of the
- * runtime-specific subclasses below.
- *
- * Internal invariant guards (`throw new Error('this should never happen')`)
- * remain plain `Error` — they are programmer-mistake assertions, not
- * consumer-catchable contract failures.
- *
- * Subclassing strategy: where a runtime-specific failure maps cleanly to an
- * agent-eval code (validation, config, not_found), we re-use the agent-eval
- * subclass. Runtime-only failure modes (session resume against the wrong
- * backend, backend transport errors) get fresh subclasses that still carry an
- * `AgentEvalErrorCode` so cross-package handlers can pattern-match without
- * importing the runtime.
- *
- * @stable
- */
-
-/**
- *
- * A backend transport call (HTTP, gRPC, sidecar IPC) failed with a non-success
- * status. Distinct from `JudgeError` (which is structural / unrecoverable)
- * because backend failures are sometimes retryable and consumers may want to
- * branch on the upstream status code.
- *
- * @stable
- */
-declare class BackendTransportError extends AgentEvalError {
-    readonly backend: string;
-    readonly status?: number;
-    /**
-     * 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.
-     */
-    readonly body?: string;
-    constructor(backend: string, message: string, options?: {
-        cause?: unknown;
-        status?: number;
-        body?: string;
-    });
-}
-/**
- *
- * A runtime-run lifecycle method was called in an order the state machine does
- * not allow: `persist()` before `complete()`, `complete()` twice, etc.
- *
- * @stable
- */
-declare class RuntimeRunStateError extends AgentEvalError {
-    constructor(message: string, options?: {
-        cause?: unknown;
-    });
-}
-/**
- *
- * The dynamic-loop planner returned an unusable topology move — the LLM emitted
- * no parseable envelope, an unknown `kind`, or a structurally-invalid move
- * (e.g. a fanout with zero tasks). This is a structural failure of the
- * agent-authored topology, not a config mistake: the planner ran but its output
- * cannot drive the kernel. Carries `validation` so cross-package handlers can
- * pattern-match without importing the runtime. Fail loud — never substitute a
- * default move, or the loop silently runs a topology nobody chose.
- *
- * @stable
- */
-declare class PlannerError extends AgentEvalError {
-    constructor(message: string, options?: {
-        cause?: unknown;
-    });
-}
-
-/**
- * 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[];
-};
-/** Render findings as the ranked-evidence block every build prompt ends with. */
-declare function findingLines(findings: AnalystFinding[]): string[];
-/** Build the starting instruction for a coder agent tasked with implementing a new tool. */
-declare function toolBuildPrompt(args: FindingsArg): string;
-/** Build the starting instruction for a coder agent tasked with implementing a new MCP server. */
-declare function mcpBuildPrompt(args: FindingsArg): string;
-
-/**
- * Campaign `spans.jsonl` → OTLP-flat JSONL — the missing converter between
- * what the substrate RECORDS and what its trace analysts READ.
- *
- * agent-eval's `runCampaign` durably records one `spans.jsonl` per cell
- * (`defaultBuildTraceWriter`): flat records
- * `{ name, cellId, startMs, durationMs?, ...attributes }` with no trace/span
- * ids. Its trace consumers (`OtlpFileTraceStore`, the trace-analyst registry,
- * `haloProposer`/`traceAnalystProposer` via `resolveTraces`) read OTLP-flat
- * JSONL (`trace_id`/`span_id`/ISO times/status/attributes — the shape
- * `projectOtlpFlatLine` parses). Nothing shipped converts between the two, so
- * the traces real optimization runs write could never reach the trace-native
- * proposers. This module is that wire adapter:
- *
- *   - {@link campaignCellSpansToOtlp} — one cell's `spans.jsonl` content →
- *     OTLP lines (a per-cell root AGENT anchor span + one child per record).
- *   - {@link convertCampaignDirToOtlp} — walk any campaign run/generation dir
- *     for `spans.jsonl` files and concatenate their OTLP lines.
- *   - {@link campaignTraceResolver} — the `resolveTraces` implementation for
- *     `traceAnalystProposer`/`haloProposer`: proposing generation g reads the
- *     traces the loop just recorded (`gen-<g-1>`, or `baseline` for g = 0)
- *     under the same `runDir` handed to `improve()`/`selfImprove()`.
- *
- * Trace identity: one trace per CELL, keyed on the cell's on-disk path — the
- * same sanitized `cellId` recurs across the baseline and every candidate
- * campaign, so folding the id alone would merge distinct runs into one trace.
- * Ids are deterministic FNV-1a folds to OTLP's 32/16-hex width, so re-converts
- * are stable and byte-identical.
- */
-
-interface CampaignOtlpOptions {
-    /** OTLP `service.name` on every emitted span. Default `'campaign'`. */
-    serviceName?: string;
-}
-/**
- * Convert ONE cell's `spans.jsonl` content to OTLP-flat JSONL lines.
- * `cellKey` is the identity the trace id folds from — pass the cell's on-disk
- * path (unique per campaign); `cellId` is the display/attribute label.
- * Returns `[]` for empty/recordless content (a dispatch that never touched
- * `ctx.trace`/`ctx.cost` writes an empty file — that is data, not an error).
- */
-declare function campaignCellSpansToOtlp(content: string, cell: {
-    cellId: string;
-    cellKey?: string;
-}, opts?: CampaignOtlpOptions): string[];
-/**
- * Walk `dir` (a campaign run dir, a generation dir, or a whole `selfImprove`
- * run root) for `spans.jsonl` files and return their concatenated OTLP-flat
- * JSONL — the exact string the `resolveTraces` contract expects. `''` when no
- * spans exist (the proposers fail loud on empty by design).
- */
-declare function convertCampaignDirToOtlp(dir: string, opts?: CampaignOtlpOptions): string;
-interface CampaignTraceResolverOptions extends CampaignOtlpOptions {
-    /** The `selfImprove`/`improve()` run root — the SAME `runDir` the loop
-     *  records under (`<runDir>/baseline/...`, `<runDir>/gen-<g>/candidate-<i>/...`).
-     *  Must be a real path; a `mem://` run records nothing to resolve. */
-    runDir: string;
-}
-/**
- * Build the `resolveTraces` function `traceAnalystProposer`/`haloProposer`
- * take: proposing generation g reads the traces of the campaigns the loop just
- * scored — `gen-<g-1>` (or `baseline` when g = 0), falling back to every trace
- * under the run root when that directory has none (e.g. a caller pointing at a
- * single campaign dir rather than a loop root).
- *
- *   traceAnalystProposer({ ..., resolveTraces: campaignTraceResolver({ runDir }) })
- */
-declare function campaignTraceResolver(opts: CampaignTraceResolverOptions): (ctx: Pick<ProposeContext, 'generation'>) => string;
-
-/**
- * `driverLoopGenerator` — the driver→worker `CandidateGenerator`: the build
- * loop run by the ATOM instead of the canned respawn.
- *
- * `agenticGenerator` steers with three hardcoded conditions picking a canned
- * note (`EMPTY_TREE_NOTE` / `failureNote`) and respawns. This generator swaps
- * that respawn brain for a real driver: an LLM on the canonical tool-loop seam
- * (`runBrainLoop` + `ToolLoopChat` — the exact loop `driverAgent` runs its
- * brain on) that AUTHORS each worker instruction, OBSERVES what the session
- * actually produced (diff, files, verifier output), RATES it, and DECIDES
- * refine / re-scope / decompose — prompted with the senior scientific-method
- * doctrine (`buildDriverSystem`).
- *
- * The worker stays the proven primitive: `runLocalHarness` in the candidate
- * worktree, same as `agenticGenerator` — only the brain between sessions
- * changes. The worktree machinery (`worktreeBuildCandidate`) and verifiers
- * (`commandVerifier` / `mcpServeVerifier`) are reused verbatim.
- *
- * Completion-oracle invariant (the supervisor doctrine, kept): the driver's
- * prose NEVER decides the outcome. After the loop, code re-checks ground
- * truth — tree dirty, raw-trace evidence present, verifier green — and only
- * that decides `applied`. A driver that claims success over a failing verifier
- * produces a discarded candidate, not a shipped one.
- *
- * @experimental
- */
-
-interface DriverLoopGeneratorOptions {
-    /** The driver-LLM seam — ONE inference turn over the conversation + tool specs (the canonical
-     *  `ToolLoopChat`, same seam as `driverAgent`): `routerBrain(cfg)` in production, a scripted
-     *  mock in tests. */
-    brain: ToolLoopChat;
-    /** Local coding harness the driver's worker sessions run in the worktree. Default `claude`. */
-    harness?: LocalHarness;
-    /** Per-worker-session wall-clock timeout (ms). Default = `runLocalHarness` default (5m). */
-    timeoutMs?: number;
-    /** Build the driver's task briefing (domain framing + method + findings) — the same senior
-     *  prompt the worker path uses (`toolBuildPrompt` / `mcpBuildPrompt`). The driver reads it and
-     *  folds what each worker needs into its instruction. Default `defaultBuildPrompt`. */
-    buildPrompt?: (args: {
-        report: unknown;
-        findings: AnalystFinding[];
-    }) => string;
-    /** Verify the worktree (the intrinsic check). Exposed to the driver as `run_verifier` AND
-     *  re-run by code as the final keep/discard gate. Omitted ⇒ the final gate is dirty-tree only
-     *  (legacy `agenticGenerator` behavior sans verifier). */
-    verify?: Verifier;
-    /** Max driver inference turns. Default `max(8, 2 + maxShots * 3)` — room for one
-     *  observe/rate/decide cycle per worker session plus orientation. */
-    maxTurns?: number;
-    /** The research seam (adopt-not-build): when set, the driver gets a
-     *  `research{query}` tool + the `researchDriverNote` doctrine, so it can
-     *  discover an EXISTING external MCP instead of building one. Wire a real
-     *  web/search backend here — none is provisioned by default (the build
-     *  harness has no live web access yet; flagged). */
-    research?: (query: string) => Promise<string>;
-    /** Test seam — inject the harness runner (defaults to `runLocalHarness`). */
-    runHarness?: typeof runLocalHarness;
-    /** Test seam — inject the worktree diff reader (defaults to `git diff` in the worktree). */
-    readDiff?: (worktreePath: string) => string;
-    /** Test seam — inject the changed-paths reader (defaults to `git status --porcelain`). */
-    changedPaths?: (worktreePath: string) => string[];
-}
-/** Driver→worker `CandidateGenerator`: an LLM driver on the canonical tool-loop authors, observes, rates, and steers coding-harness sessions in the worktree until the verifier passes or the session budget is spent. */
-declare function driverLoopGenerator(opts: DriverLoopGeneratorOptions): CandidateGenerator;
-
-/**
- * Typed-findings accessor — the one place `unknown[]` findings become
- * `AnalystFinding[]`.
- *
- * agent-eval's `ProposeContext.findings` is `TFindings[] = unknown[]` on the
- * wire: the loop threads whatever the previous `analyzeGeneration` producer (or
- * the caller's static seed) returned. Consumers that need the typed envelope
- * (`claim`/`severity`/`recommended_action`) were down-casting with a bare
- * `as AnalystFinding[]` — a lie at runtime whenever the seed was a raw string
- * or an ad-hoc digest, which then rendered `undefined` into build prompts.
- *
- * `toAnalystFindings` replaces that cast: real findings pass through
- * unchanged (structural guard, fail-closed), and non-conforming values are
- * LIFTED into a real `AnalystFinding` envelope via `makeFinding` — the most
- * actionable text becomes the claim, the original value rides in `metadata.raw`
- * — so everything downstream of the accessor handles exactly one shape.
- */
-
-/** Analyst id stamped on findings lifted from untyped seed values. */
-declare const LIFTED_FINDING_ANALYST_ID = "lifted-seed";
-/** Structural guard for the schema-versioned `AnalystFinding` envelope.
- *  Strict on the identity fields `makeFinding` always populates — a partial
- *  look-alike is lifted (re-enveloped), not trusted. */
-declare function isAnalystFinding(value: unknown): value is AnalystFinding;
-interface ToAnalystFindingsOptions {
-    /** `analyst_id` stamped on lifted (non-conforming) values.
-     *  Default {@link LIFTED_FINDING_ANALYST_ID}. */
-    analystId?: string;
-    /** `area` stamped on lifted values. Default `'seed'`. */
-    area?: string;
-}
-/**
- * Normalize a mixed `unknown[]` findings array to `AnalystFinding[]`:
- * conforming findings pass through by reference; strings and finding-ish
- * objects are lifted into envelopes (claim = most actionable text, original
- * value under `metadata.raw`); values with no extractable text are dropped.
- * Never throws — a malformed seed must not kill a proposal round.
- */
-declare function toAnalystFindings(findings: readonly unknown[], opts?: ToAnalystFindingsOptions): AnalystFinding[];
-
-/**
- * `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.
- *
- * The spawn + handshake is the SHARED same-host stdio connection
- * (`connectStdioMcp`) — the same code path that later serves the built server
- * LIVE to a scored run (`materializeLocalMcp`), so "verified it serves" and
- * "served while scored" can never drift apart.
- *
- * 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).
- */
-
-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;
-}
-/** Build a `Verifier` that boots a generated MCP server over stdio and checks it exposes tools. */
-declare function mcpServeVerifier(spec: McpServeSpec): Verifier;
-
-/**
- * The senior scientific-method optimizer doctrine — the ONE substantial prompt
- * core shared by every builder/author surface (tool build, MCP build, codebase
- * improvement, strategy authoring) and by the driver that steers build workers
- * (`driverLoopGenerator`).
- *
- * Seeded from the proven senior prompts rather than invented: GEPA's
- * `REFLECTION_SYSTEM` (localize → diagnose → minimal generalizable fix →
- * preserve what works), the /evolve loop (one hypothesis with a mechanism and a
- * falsifiable prediction; attack the largest measured gap first), /pursue (one
- * coherent change set, no partial scaffolding), and the self-improving-loop /
- * supervisor doctrine (a keep is decided by a real check, never by the author;
- * observe → rate → decide). Generalized from "mutate a prompt string" to
- * "build a code surface a held-out measurement will grade".
- */
-/**
- * The shared method block every build/author prompt embeds. Domain framing
- * (what a tool/MCP/codebase-edit deliverable looks like) wraps around it; this
- * is the process itself.
- */
-declare const optimizerMethod: string;
-/**
- * The driver's stance for `driverLoopGenerator` — the build-domain instance of
- * the supervisor doctrine (observe → rate → decide; refine / re-scope /
- * decompose; the check decides delivery, never the driver's prose).
- */
-declare const buildDriverSystem: string;
-/**
- * The driver's ADOPT-not-build doctrine, appended to `buildDriverSystem` when
- * a `research` tool is wired into the loop (`DriverLoopGeneratorOptions.
- * research`). Kept separate so a driver WITHOUT the tool is never told to
- * call a tool it does not have.
- */
-declare const researchDriverNote: string;
-/**
- * The senior authoring process for `authorStrategy` — the same method, shaped
- * to the strategy contract (author-blind, conserved budget, one module out).
- */
-declare const strategyAuthorMethod: string;
-
-type ProfileDiffProposerContext<TFindings = unknown> = ProposeContext<TFindings> & {
-    profile: AgentProfile;
-};
-interface ProfileDiffProposerOptions<TFindings = unknown> {
-    proposeDiffs(context: ProfileDiffProposerContext<TFindings>): Promise<readonly AgentProfileDiff[]> | readonly AgentProfileDiff[];
-}
-/**
- * Turn exact AgentProfileDiffs from any source into full profile candidates for
- * the shared optimization loop. Research, catalogs, humans, and trace miners
- * differ only in `proposeDiffs`; measurement and promotion stay identical.
- */
-declare function profileDiffProposer<TFindings = unknown>(options: ProfileDiffProposerOptions<TFindings>): SurfaceProposer<TFindings>;
-
-/**
- *
- * `rawTraceDistiller` — the meta-harness `analyzeGeneration` producer.
- *
- * The default `generationFailureDistiller` (in `improve.ts`) COMPRESSES each
- * generation's failing cells into ~1500-char structured findings before the next
- * proposal round. That is the ACE-style recipe: a small summary is the proposer's
- * whole view of what went wrong. This producer does the opposite — the
- * meta-harness recipe (yoonholee.com/meta-harness): it does NOT summarize. It
- * points the coding-agent proposer at the generation's RAW run traces already on
- * disk under `runDir` — the durable per-cell `spans.jsonl` event logs,
- * `cached-result.json` scores, and any artifacts the substrate persisted — and
- * instructs the agent to `grep`/`cat`/`ls` them to diagnose the failures itself
- * (up to the harness's full context, ~millions of tokens, vs a ~1500-char digest).
- *
- * It emits `AnalystFinding[]` so it drops into the SAME `opts.analyzeGeneration`
- * slot the default distiller uses, and renders through the same
- * `agenticGenerator` prompt path (`claim` + `recommended_action`). The findings
- * carry ABSOLUTE paths — the coding harness runs with `cwd` = a candidate
- * worktree, so a relative `runDir` would be uncattable from there.
- *
- * Runtime layout it reads (written by agent-eval's optimization loop):
- *
- *   <runDir>/gen-<N>/                     ← the generation dir (input.runDir)
- *     candidate-<i>/                      ← one candidate campaign (campaign.runDir)
- *       <sanitized cellId>/               ← one scenario×rep cell
- *         spans.jsonl                     ← the raw trace (event/span log)
- *         cached-result.json              ← the cell's score + artifact ref
- *         <artifacts…>                    ← whatever the dispatch wrote
- *
- * @experimental
- */
-
-interface RawTraceDistillerOptions {
-    /** Anchor the emitted paths at this run root instead of the generation `runDir`
-     *  the loop passes in. Normally unset — each call points at that generation's
-     *  own directory (`input.runDir`). Pass an absolute path when you construct the
-     *  producer ahead of the loop and want a fixed anchor (e.g. a test fixture). */
-    runDir?: string;
-    /** Max candidates to surface trace paths for, worst-scoring first. Default 12. */
-    maxCandidates?: number;
-    /** Max failing cells to enumerate per candidate before collapsing the rest into
-     *  an "ls the candidate dir" pointer. Default 8. */
-    maxCellsPerCandidate?: number;
-    /** Max concrete file paths to list per cell (the agent can always `ls` the dir
-     *  for the rest). Default 24. */
-    maxFilesPerCell?: number;
-    /** Findings to fall back to when the generation had NO failing cells, so a
-     *  clean round never wipes the proposer's steering context. Mirrors the default
-     *  distiller's static-seed fallback. Default: a single instruction finding. */
-    fallbackFindings?: unknown[];
-}
-/**
- * Build an `analyzeGeneration` producer that feeds the proposer RAW-TRACE
- * FILESYSTEM CONTEXT — paths into the prior generation's real run traces plus a
- * grep/cat-to-diagnose instruction — instead of a pre-summarized digest.
- *
- * Drop-in for `opts.analyzeGeneration` on `improve()` / `selfImprove()`:
- *
- *   await improve(profile, seedFindings, {
- *     surface: 'code',
- *     code: { repoRoot },
- *     runDir: '/abs/run',                 // MUST be a real path — the traces live here
- *     analyzeGeneration: rawTraceDistiller(),
- *     scenarios, judge, agent,
- *   })
- */
-declare function rawTraceDistiller<TScenario extends Scenario = Scenario, TArtifact = unknown>(options?: RawTraceDistillerOptions): NonNullable<SelfImproveOptions<TScenario, TArtifact>['analyzeGeneration']>;
-
-/**
- *
- * `reflectiveGenerator` — the cheap, no-sandbox `CandidateGenerator`. It drafts
- * surface edits via the existing improvement proposer (`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`.
- *
- * @experimental
- */
-
-interface ReflectiveGeneratorOptions {
-    improvementProposalSource: ImprovementProposalSource<SurfaceImprovementEdit>;
-}
-/** Cheap no-sandbox `CandidateGenerator` (the `shots=1` setting): draft surface edits via the improvement adapter and apply them as one coherent candidate. */
-declare function reflectiveGenerator(opts: ReflectiveGeneratorOptions): CandidateGenerator;
-
-/**
- * `rolloutPolicyProposer` — the `'rollout-policy'` surface for `improve()`: the
- * inference-time `StructuralRolloutPolicy` dials { k, repairRounds, testgen } as a
- * held-out-gated optimizable surface.
- *
- * Why this seam: agent-eval's loop contract is already generic — `MutableSurface`
- * admits any string, documented as "serialized tool config" — so the policy rides
- * the SAME serialize→propose→gate→parse-back cycle the tools/mcp/hooks surfaces
- * use. No agent-eval changes; the only net-new piece is this proposer.
- *
- * Why deterministic: prompt-wording proposals are a measured zero on this stack,
- * and the policy space is tiny and fully enumerable. The proposer emits bounded
- * single-dial neighbors (k±2 in [1,10], repairRounds±1 in [0,3], testgen±3 in
- * [0,10], ≤4 per generation) and lets the held-out gate do ALL the deciding — an
- * LLM proposer would add cost and nondeterminism with nothing to reason about.
- *
- * Persistence: the policy lives in `profile.extensions['structural-rollout']`
- * (AgentProfile's designed slot for runtime-specific config). A gated winner is
- * written back there by `improve()`, the same profile-field write-back every other
- * config surface gets; `structuralRolloutPolicyFromProfile` is the read side a
- * runtime caller feeds to `structuralRollout({ policy })`.
- *
- * @experimental
- */
-
-/** The profile extensions namespace the policy persists under. */
-declare const ROLLOUT_POLICY_EXTENSION = "structural-rollout";
-/** Proposal bounds per dial. These are the SEARCH bounds (what the proposer may
- *  explore), chosen so every reachable value is a measured-sane recipe: k=1 is the
- *  low-compute preset, testgen=0 disables check authoring, repairRounds caps where
- *  the measured increment flattens (+1–3pp beyond round 2). */
-declare const ROLLOUT_POLICY_BOUNDS: {
-    readonly k: {
-        readonly min: 1;
-        readonly max: 10;
-        readonly step: 2;
-    };
-    readonly repairRounds: {
-        readonly min: 0;
-        readonly max: 3;
-        readonly step: 1;
-    };
-    readonly testgen: {
-        readonly min: 0;
-        readonly max: 10;
-        readonly step: 3;
-    };
-};
-/** Parse a serialized policy surface. Defensive by design — the proposer reads
- *  `ctx.currentSurface`, which the loop types as `string | CodeSurface`. Returns
- *  `undefined` (never throws) for non-strings, malformed JSON, or a shape that
- *  violates the policy's own invariants: the no-op signal. Unknown dials are
- *  dropped; `diverse`/`temperature` ride through untouched (the proposer never
- *  mutates them — `diverse` is a measured paired null). */
-declare function parseRolloutPolicy(surface: MutableSurface): StructuralRolloutPolicy | undefined;
-/** Normalize an untyped policy bag (a parsed surface or a profile extension) into
- *  a full `StructuralRolloutPolicy`, defaults merged. Returns `undefined` when any
- *  present dial violates the policy invariants (mirrors `resolvePolicy`: integer
- *  k ≥ 1, repairRounds ≥ 0, testgen ≥ 0) — a corrupt config must read as "not
- *  configured", never as a fabricated recipe. */
-declare function normalizeRolloutPolicy(raw: unknown): StructuralRolloutPolicy | undefined;
-/** Stable serialization — dial order is fixed so identical policies produce
- *  identical surfaces (the loop dedupes/hashes candidates by surface content). */
-declare function serializeRolloutPolicy(policy: StructuralRolloutPolicy): string;
-/** Read the persisted policy off the profile. `undefined` when the profile does
- *  not opt into structural rollout — the improve() surface no-ops then, because
- *  tuning dials nothing consumes would ship dead config. */
-declare function structuralRolloutPolicyFromProfile(profile: AgentProfile): StructuralRolloutPolicy | undefined;
-/** Persist a policy into the profile's extensions namespace. Shallow copy; never
- *  mutates the input profile (the applyWinnerToProfile contract). */
-declare function applyRolloutPolicyToProfile(profile: AgentProfile, policy: StructuralRolloutPolicy): AgentProfile;
-/** All bounded single-dial neighbors of `policy`, in a fixed priority order: k
- *  first (selection breadth carries 85–92% of the measured effect), then
- *  repairRounds, then testgen. Steps clamp to the dial's bounds; clamped-to-no-op
- *  and duplicate policies are dropped. */
-declare function enumerateNeighborPolicies(policy: StructuralRolloutPolicy): StructuralRolloutPolicy[];
-/**
- * The deterministic `SurfaceProposer` for the `'rollout-policy'` surface.
- *
- * Each generation: parse the current policy surface, enumerate its bounded
- * single-dial neighbors, and return at most `min(populationSize, 4)` of them,
- * rotating the enumeration window by generation so successive generations explore
- * different neighbors when nothing promoted. Proposes NOTHING when the surface
- * carries no policy (the profile never opted in) — an empty proposal is the
- * loop-native no-op, mirroring `improvementDriver`'s no-findings behavior.
- */
-declare function rolloutPolicyProposer(): SurfaceProposer;
-
-/**
- *
- * Chat-model resolution + catalog validation — the shared primitive every
- * product chat handler needs and was, until now, hand-rolling. Lifts the
- * router `/v1/models` fetch, the fail-closed id validation, and the
- * precedence resolver out of four near-identical per-repo copies.
- *
- * Policy-free by design: callers pass their own precedence order
- * (`resolveChatModel`) and their own known-good `allowlist`
- * (`validateChatModelId`), so each product keeps its resolution policy while
- * sharing the catalog fetch, the malformed-id guard, and the fail-closed
- * admission rule. No React, no `process.env` assumption — `env` is an
- * explicit narrow record so this runs unchanged in Node and in Workers.
- *
- * @stable
- */
-/**
- * A model entry as returned by the Tangle Router `/v1/models` endpoint.
- * Intentionally minimal — only the fields resolution + validation read.
- */
-interface ModelInfo {
-    id: string;
-    name?: string;
-    description?: string;
-    /** Provider slug, when the router exposes it (`provider` or `_provider`). */
-    provider?: string;
-    _provider?: string;
-    architecture?: {
-        modality?: string;
-        input_modalities?: string[];
-        output_modalities?: string[];
-    };
-}
-/** Env keys the router base URL is resolved from. */
-interface RouterEnv {
-    TANGLE_ROUTER_URL?: string;
-    TANGLE_ROUTER_BASE_URL?: string;
-}
-/** Default Tangle Router base URL used when no env override is set. */
-declare const DEFAULT_ROUTER_BASE_URL = "https://router.tangle.tools";
-/** Resolve the router base URL from env, normalised — no trailing `/v1` or `/`. */
-declare function resolveRouterBaseUrl(env?: RouterEnv): string;
-/**
- * Fetch the model catalog from the router's `/v1/models`. Throws on a non-2xx
- * response — callers decide whether to fail open (empty catalog) or closed.
- */
-declare function getModels(routerBaseUrl?: string): Promise<ModelInfo[]>;
-/** Trim a candidate model id; `undefined` for non-strings and blanks. */
-declare function cleanModelId(value: unknown): string | undefined;
-interface ChatModelCandidate {
-    /** Stable label for telemetry — e.g. `request`, `workspace`, `env`. */
-    source: string;
-    model: string | undefined;
-}
-interface ResolvedChatModel {
-    source: string;
-    model: string;
-}
-/**
- * Resolve a chat model by precedence: the first candidate carrying a
- * non-blank model wins, else `fallback`. The caller owns the precedence
- * order, so each product keeps its own policy (request → workspace → env,
- * etc.) while the first-non-blank logic and the telemetry shape stay shared.
- */
-declare function resolveChatModel(candidates: ChatModelCandidate[], fallback: ResolvedChatModel): ResolvedChatModel;
-type ChatModelValidation = {
-    succeeded: true;
-    value: string;
-} | {
-    succeeded: false;
-    error: string;
-};
-/**
- * Validate a caller-supplied chat-model id. Rejects non-strings, malformed
- * ids, and ids absent from both the caller's `allowlist` and the live router
- * catalog. Fails closed: when the catalog cannot be fetched, an unverifiable
- * id is rejected rather than admitted — a bad model never reaches the agent.
- */
-declare function validateChatModelId(modelId: unknown, options?: {
-    /**
-     * Known-good ids that skip the catalog round trip — e.g. the product's
-     * default model plus any env-configured ids.
-     */
-    allowlist?: string[];
-    routerBaseUrl?: string;
-    /** Injectable catalog loader — overridden in tests. */
-    loadModels?: (routerBaseUrl: string) => Promise<ModelInfo[]>;
-}): Promise<ChatModelValidation>;
-
-/**
- *
- * Pure readiness-decision helper. Maps a `KnowledgeReadinessReport` from
- * `@tangle-network/agent-eval` to a three-state branch (`ready` / `blocked` /
- * `caveat`) the runtime, route handlers, and UI shells can all switch on.
- *
- * Default `minimumScore` of 0.7 mirrors the readiness scoring scale in
- * agent-eval; callers tightening or loosening this should keep it consistent
- * across all entry points for the same product so the UI / metrics agree on
- * what "caveat" means.
- *
- * @stable
- */
-
-/**
- * Map a `KnowledgeReadinessReport` to a three-state branch (`ready` / `blocked` / `caveat`) the runtime, route handlers, and UI shells all switch on.
- *
- * @stable
- */
-declare function decideKnowledgeReadiness(report: KnowledgeReadinessReport, options?: {
-    minimumScore?: number;
-}): KnowledgeReadinessDecision;
-
-/**
- * The product-facing backend selector for `runChatThroughRuntime` /
- * `runAgentTaskStream`: one call turns a `--backend {router,tcloud,cli-bridge,
- * sandbox}` choice into the `AgentExecutionBackend` the chat leg runs on.
- *
- * It is the `AgentExecutionBackend` sibling of `resolveSandboxClient` (which
- * resolves the `SandboxClient` a `runAgentRounds` drives). Both exist for the same
- * reason: every in-process eval product hand-rolled the identical
- * "`backend-name` → `createOpenAICompatibleBackend`" branch, and the copies
- * drift. This is the single generic resolver they share.
- *
- *   - `router` / `tcloud` / `cli-bridge` → OpenAI-compatible chat completions.
- *     All three speak `POST {baseUrl}/chat/completions` in OpenAI's SSE shape —
- *     the router (a.k.a. tcloud) IS that endpoint, and cli-bridge fronts a
- *     harness CLI behind the same protocol at its own `/v1`. They differ only
- *     in `baseUrl` / `apiKey` and the `kind` label a product wants on its
- *     traces. cli-bridge REQUIRES `model` in the request body, so it MUST route
- *     through `createOpenAICompatibleBackend` (which sends it), never a
- *     transport that drops the field.
- *   - `sandbox` → the caller's own domain backend. The sandbox variant carries
- *     product specifics (system prompt, workspace id, in-box D1 executor) that
- *     do NOT belong in the substrate, so the product passes a `sandboxBackend()`
- *     seam that this resolver simply invokes.
- *
- * This resolver is PURE backend selection. Product concerns — credit hard-cuts,
- * fetch-capture shims, D1 platform wiring — stay as product-side WRAPPERS
- * around the returned backend. The OpenAI-compat passthrough fields (`tools`,
- * `toolChoice`, `responseFormat`, `temperature`, `maxTokens`, `fetchImpl`,
- * `retry`) are forwarded verbatim so a product can advertise its app tools,
- * preserve generation settings, or install a capturing fetch without
- * re-opening the branch this consolidation closes.
- */
-
-/** The transport a chat backend runs on. */
-type AgentBackendKind = 'router' | 'tcloud' | 'cli-bridge' | 'sandbox';
-/**
- * OpenAI-compat passthrough forwarded to `createOpenAICompatibleBackend` for
- * the `router` / `tcloud` / `cli-bridge` kinds. Mirrors that factory's optional
- * inputs so a product keeps its tool advertising / capture-fetch without
- * re-implementing the backend branch.
- */
-type OpenAICompatPassthrough = Pick<Parameters<typeof createOpenAICompatibleBackend>[0], 'tools' | 'toolChoice' | 'responseFormat' | 'temperature' | 'maxTokens' | 'fetchImpl' | 'retry'>;
-interface ResolveAgentBackendOptions<TInput extends AgentBackendInput = AgentBackendInput> extends OpenAICompatPassthrough {
-    /** The chat transport to resolve. */
-    kind: AgentBackendKind;
-    /**
-     * Bearer credential for the OpenAI-compat kinds. Empty string is valid for a
-     * loopback-anonymous cli-bridge; a `router`/`tcloud` route with an empty key
-     * is a caller bug the product surfaces before calling in.
-     */
-    apiKey: string;
-    /** Base URL for the OpenAI-compat kinds. cli-bridge's is its `/v1`. */
-    baseUrl: string;
-    /** Model id sent on every request. cli-bridge rejects a request without it. */
-    model: string;
-    /** `kind` label stamped on the resolved backend + its traces. Defaults to `kind`. */
-    label?: string;
-    /**
-     * `sandbox` kind: the product's own domain backend. Required for that kind —
-     * the substrate owns no product sandbox shape, so a `sandbox` resolution with
-     * no seam is a caller bug, not a silent fallback.
-     */
-    sandboxBackend?: () => AgentExecutionBackend<TInput>;
-}
-/**
- * Resolve the `AgentExecutionBackend` for the chosen `kind`. Reuse this instead
- * of hand-rolling the `createOpenAICompatibleBackend` branch in each product.
- */
-declare function resolveAgentBackend<TInput extends AgentBackendInput = AgentBackendInput>(opts: ResolveAgentBackendOptions<TInput>): AgentExecutionBackend<TInput>;
-
-/**
- *
- * The two top-level entry points:
- *
- *  - `runAgentTask` — single-shot lifecycle for adapter-driven tasks.
- *  - `runAgentTaskStream` — streaming lifecycle that delegates execution to an
- *    `AgentExecutionBackend` (model API, sandbox, or custom iterable).
- *
- * Both gate the run on `KnowledgeReadinessReport` from `agent-eval`, emit the
- * same lifecycle event vocabulary (under different shapes — see `types.ts`),
- * and route session lifecycle through a pluggable `RuntimeSessionStore`.
- *
- * @stable
- */
-
-/** Stamp cross-cutting defaults onto adapter-projected RunRecords without
- *  overriding anything the adapter set explicitly:
- *   - `scenarioId` — the run's scenario, when the record omits one.
- *   - `failureClass` — the control layer's failure classification promoted
- *     onto the canonical cross-agent key, but ONLY when it's a real taxonomy
- *     class. This is what lets the substrate aggregate failures across every
- *     agent in one vocabulary instead of per-agent ad-hoc strings. */
-declare function applyRunRecordDefaults(records: RunRecord[], scenarioId: string, controlFailureClass: string | undefined): RunRecord[];
-
-/**
- * Single-shot task lifecycle for adapter-driven tasks: readiness-gated, emits the runtime lifecycle event vocabulary, session-store pluggable.
- *
- * @stable
- */
-declare function runAgentTask<TState, TAction, TActionResult, TEval extends ControlEvalResult = ControlEvalResult>(options: RunAgentTaskOptions<TState, TAction, TActionResult, TEval>): Promise<AgentTaskRunResult<TState, TAction, TActionResult, TEval>>;
-/**
- * Streaming task lifecycle: delegates execution to an `AgentExecutionBackend` (model API, sandbox, or custom iterable) and yields lifecycle events as they happen.
- *
- * @stable
- */
-declare function runAgentTaskStream<TInput extends AgentBackendInput = AgentBackendInput>(options: RunAgentTaskStreamOptions<TInput>): AsyncIterable<RuntimeStreamEvent>;
-
-/**
- *
- * Session helpers + an in-memory `RuntimeSessionStore` implementation suitable
- * for tests, scratch processes, and per-request scratch storage in serverless
- * runtimes. Durable stores (D1, postgres, Durable Objects) implement the same
- * interface from `./types`.
- *
- * @stable
- */
-
-/** In-memory `RuntimeSessionStore` for single-process use and tests. @stable */
-declare class InMemoryRuntimeSessionStore implements RuntimeSessionStore {
-    private readonly sessions;
-    private readonly events;
-    get(sessionId: string): RuntimeSession | undefined;
-    put(session: RuntimeSession): void;
-    appendEvent(sessionId: string, event: RuntimeStreamEvent): void;
-    listEvents(sessionId: string): RuntimeStreamEvent[];
-}
-
-/**
- *
- * Server-Sent Events serialization for runtime telemetry streams.
- *
- * Newline-safe by construction: any newline in `id` or `event` is collapsed to
- * a space (browsers terminate fields on newline), and multi-line `data`
- * payloads are split into one `data:` line per source line so JSON.stringify
- * output transports cleanly.
- *
- * @stable
- */
-
-/** @stable */
-interface ServerSentEventOptions {
-    event?: string;
-    id?: string;
-    retry?: number;
-}
-/** Serialize a `KnowledgeReadinessReport` as a Server-Sent Event string. @stable */
-declare function readinessServerSentEvent(report: KnowledgeReadinessReport, options?: RuntimeTelemetryOptions & ServerSentEventOptions): string;
-/** Serialize a `RuntimeStreamEvent` as a Server-Sent Event string. @stable */
-declare function runtimeStreamServerSentEvent(event: RuntimeStreamEvent, options?: RuntimeTelemetryOptions & ServerSentEventOptions): string;
-
-/**
- * Bounded turn-level tool-dispatch loop.
- *
- * `runAgentTaskStream` runs ONE model turn; `runAgentRounds` orchestrates DELEGATED
- * multi-agent topologies (refine / fanout-vote). Neither is the everyday
- * interactive shape: a chat turn where the model may emit tool calls, each is
- * executed, the results are folded back, and the turn re-runs until the model
- * stops (or a turn cap). Every agent app hand-rolls that loop — this is it,
- * as a reusable primitive.
- *
- * Substrate-neutral by design: the caller supplies `streamTurn` (wrapping
- * whatever backend / `runAgentTaskStream` it uses) and `executeToolCall`
- * (routing to its executors). This module owns the LOOP; the caller owns the
- * model and the executors. `Raw` (streaming variant) is the caller's own
- * event type. The only imported contract is the runtime hook type: hooks are
- * execution-scoped observers, not part of the agent profile.
- */
-
-interface ToolLoopCall {
-    toolCallId?: string;
-    toolName: string;
-    args: Record<string, unknown>;
-}
-/** Outcome of one tool dispatch — structurally compatible with a hub/integration
- *  tool-outcome union, so callers can fold either through the loop. */
-type ToolCallOutcome = {
-    ok: true;
-    result: unknown;
-} | {
-    ok: false;
-    code: string;
-    message: string;
-    status?: number;
-};
-/** One OpenAI-shaped tool-call entry carried on an assistant message. */
-interface ToolLoopAssistantToolCall {
-    id: string;
-    type: 'function';
-    function: {
-        name: string;
-        arguments: string;
-    };
-}
-/**
- * A message in the running conversation the loop sends to `streamTurn`.
- *
- * The base `{ role, content }` covers `system` / `user` / plain `assistant`
- * turns. Two optional fields carry the OpenAI function-calling contract so a
- * strict model (Claude, and any OpenAI-compatible provider that validates tool
- * history) reads its own tool use back instead of re-issuing the same call:
- *
- *   - an assistant turn that emitted tool calls carries `tool_calls`, and its
- *     `content` is `null` when the turn was tool-only;
- *   - each tool result is its own `{ role: 'tool', tool_call_id, content }`
- *     message keyed to the call that produced it.
- *
- * Widening is additive: a `streamTurn` that reads only `role` + `content` still
- * works; one that forwards the whole message to an OpenAI-compatible endpoint
- * now sends correct tool history.
- */
-type ToolLoopMessage = {
-    role: string;
-    content: string | null;
-    tool_calls?: ToolLoopAssistantToolCall[];
-    tool_call_id?: string;
-};
-type ToolLoopEvent = {
-    type: 'text';
-    text: string;
-} | {
-    type: 'tool_call';
-    call: ToolLoopCall;
-} | {
-    type: 'other';
-    event: unknown;
-};
-/** Why the loop stopped. `completed` = model finished naturally; `stuck-loop` =
- *  ≥3 consecutive identical tool calls (same tool + args); `backstop` = hit the
- *  runaway-backstop cap (200 by default); `deadline` = wall-clock deadlineMs
- *  exceeded; `budget` = maxCostUsd exhausted. Non-`completed` stops are infra /
- *  resource outcomes — eval scoring must distinguish them from capability failure. */
-type ToolLoopStopReason = 'completed' | 'stuck-loop' | 'backstop' | 'deadline' | 'budget';
-interface ToolLoopResult {
-    finalText: string;
-    toolResults: Array<{
-        call: ToolLoopCall;
-        label: string;
-        outcome: ToolCallOutcome;
-    }>;
-    turns: number;
-    stopReason: ToolLoopStopReason;
-    /** @deprecated Use `stopReason !== 'completed'` instead. */
-    cappedOut: boolean;
-}
-interface RunToolLoopOptions {
-    systemPrompt: string;
-    userMessage: string;
-    priorMessages?: ToolLoopMessage[];
-    streamTurn: (messages: ToolLoopMessage[]) => AsyncIterable<ToolLoopEvent>;
-    executeToolCall: (call: ToolLoopCall) => Promise<ToolCallOutcome>;
-    isExecutableTool: (toolName: string) => boolean;
-    /** Runaway-backstop cap. Default 200 — set far above any legitimate workflow.
-     *  For per-workflow limits, use `maxCostUsd` or `deadlineMs` instead. */
-    maxToolTurns?: number;
-    /** Wall-clock deadline in ms since epoch (Date.now()-based). When exceeded the
-     *  loop stops with stopReason `deadline`. */
-    deadlineMs?: number;
-    /** Maximum total cost in USD. Requires `costOf` to meter each tool call. */
-    maxCostUsd?: number;
-    /** Return the USD cost of one outcome. Required for `maxCostUsd` to work. */
-    costOf?: (call: ToolLoopCall, outcome: ToolCallOutcome) => number;
-    renderResult?: (label: string, outcome: ToolCallOutcome) => string;
-    labelFor?: (call: ToolLoopCall) => string;
-    runId?: string;
-    scenarioId?: string;
-    hooks?: RuntimeHooks;
-}
-/** Run the bounded tool loop and return the final text + every executed tool
- *  outcome. Awaitable — callers needing to stream events to a UI use
- *  {@link streamToolLoop}. */
-declare function runToolLoop(opts: RunToolLoopOptions): Promise<ToolLoopResult>;
-type StreamToolLoopYield<Raw> = {
-    kind: 'event';
-    event: Raw;
-} | {
-    kind: 'tool_result';
-    toolName: string;
-    toolCallId?: string;
-    label: string;
-    outcome: ToolCallOutcome;
-} | {
-    kind: 'capped';
-    pending: number;
-    stopReason: Exclude<ToolLoopStopReason, 'completed'>;
-};
-interface StreamToolLoopOptions<Raw> {
-    systemPrompt: string;
-    userMessage: string;
-    priorMessages?: ToolLoopMessage[];
-    streamTurn: (messages: ToolLoopMessage[]) => AsyncIterable<Raw>;
-    extractText: (event: Raw) => string;
-    extractToolCall: (event: Raw) => ToolLoopCall | null;
-    isExecutableTool: (toolName: string) => boolean;
-    executeToolCall: (call: ToolLoopCall) => Promise<ToolCallOutcome>;
-    /** Runaway-backstop cap. Default 200 — set far above any legitimate workflow. */
-    maxToolTurns?: number;
-    /** Wall-clock deadline in ms since epoch (Date.now()-based). */
-    deadlineMs?: number;
-    /** Maximum total cost in USD. Requires `costOf` to meter each tool call. */
-    maxCostUsd?: number;
-    /** Return the USD cost of one outcome. Required for `maxCostUsd` to work. */
-    costOf?: (call: ToolLoopCall, outcome: ToolCallOutcome) => number;
-    renderResult?: (label: string, outcome: ToolCallOutcome) => string;
-    labelFor?: (call: ToolLoopCall) => string;
-    runId?: string;
-    scenarioId?: string;
-    hooks?: RuntimeHooks;
-}
-/** Streaming bounded tool loop: yields each raw turn event (the caller maps +
- *  telemetries + re-emits it) and each executed `tool_result`; emits one
- *  `capped` if it stops for any non-completed reason with calls still pending. */
-declare function streamToolLoop<Raw>(opts: StreamToolLoopOptions<Raw>): AsyncGenerator<StreamToolLoopYield<Raw>, void, unknown>;
-
-export { AgentBackendInput, type AgentBackendKind, AgentExecutionBackend, AgentTaskRunResult, BackendTransportError, type CampaignOtlpOptions, type CampaignTraceResolverOptions, CandidateGenerator, type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, DEFAULT_ROUTER_BASE_URL, type DriverLoopGeneratorOptions, InMemoryRuntimeSessionStore, LIFTED_FINDING_ANALYST_ID, type McpServeSpec, type ModelInfo, PlannerError, type ProfileDiffProposerContext, type ProfileDiffProposerOptions, ROLLOUT_POLICY_BOUNDS, ROLLOUT_POLICY_EXTENSION, type RawTraceDistillerOptions, type ReflectiveGeneratorOptions, type ResolveAgentBackendOptions, type ResolvedChatModel, type RouterEnv, type RunChatTurnInput, type RunToolLoopOptions, RuntimeHooks, RuntimeRunStateError, RuntimeSessionStore, RuntimeStreamEvent, RuntimeTelemetryOptions, type StreamToolLoopOptions, type StreamToolLoopYield, type ToAnalystFindingsOptions, type ToolCallOutcome, type ToolLoopAssistantToolCall, type ToolLoopCall, type ToolLoopEvent, type ToolLoopMessage, type ToolLoopResult, type ToolLoopStopReason, Verifier, applyRolloutPolicyToProfile, applyRunRecordDefaults, buildDriverSystem, campaignCellSpansToOtlp, campaignTraceResolver, cleanModelId, convertCampaignDirToOtlp, createOpenAICompatibleBackend, decideKnowledgeReadiness, deriveExecutionId, driverLoopGenerator, enumerateNeighborPolicies, findingLines, getModels, handleChatTurn, isAnalystFinding, mcpBuildPrompt, mcpServeVerifier, normalizeRolloutPolicy, optimizerMethod, parseRolloutPolicy, profileDiffProposer, rawTraceDistiller, readinessServerSentEvent, reflectiveGenerator, researchDriverNote, resolveAgentBackend, resolveChatModel, resolveRouterBaseUrl, rolloutPolicyProposer, runAgentTask, runAgentTaskStream, runToolLoop, runtimeStreamServerSentEvent, serializeRolloutPolicy, strategyAuthorMethod, streamToolLoop, structuralRolloutPolicyFromProfile, toAnalystFindings, toolBuildPrompt, validateChatModelId };
+import { _ as RunAgentTaskOptions, a as AgentKnowledgeProvider, b as RuntimeSessionStore, c as AgentTaskContext, d as AgentTaskStatus, f as BackendErrorDetail, g as OpenAIChatToolChoice, h as OpenAIChatTool, i as AgentExecutionBackend, l as AgentTaskRunResult, m as OpenAIChatResponseFormat, n as AgentBackendContext, o as AgentRuntimeEvent, p as KnowledgeReadinessDecision, r as AgentBackendInput, s as AgentRuntimeEventSink, t as AgentAdapter, u as AgentTaskSpec, v as RunAgentTaskStreamOptions, x as RuntimeStreamEvent, y as RuntimeSession } from "./types-C9j4qg6l.js";
+import { A as RuntimeRunCompleteInput, B as RuntimeDecisionPoint, F as RuntimeRunRow, G as RuntimeHookTarget, H as RuntimeHookErrorContext, I as RuntimeRunStatus, J as defineRuntimeHooks, K as RuntimeHooks, L as startRuntimeRun, M as RuntimeRunHandle, N as RuntimeRunOptions, P as RuntimeRunPersistenceAdapter, R as RuntimeDecisionEvidenceRef, U as RuntimeHookEvent, V as RuntimeHookContext, W as RuntimeHookPhase, X as notifyRuntimeHookEvent, Y as notifyRuntimeDecisionPoint, j as RuntimeRunCost, q as composeRuntimeHooks, z as RuntimeDecisionKind } from "./types-BevOjfTY.js";
+import { Bu as RuntimeRunStateError, Fu as BackendTransportError, Iu as ConfigError, Lu as JudgeError, Nu as AgentEvalError, Pu as AgentEvalErrorCode, Ru as NotFoundError, Vu as ValidationError, au as LoopSpanNode, cu as OtelExporter, du as buildLoopOtelSpans, eu as EvalRunEvent, fu as buildLoopSpanNodes, gu as loopEventToOtelSpan, hu as exportEvalRuns, iu as INTELLIGENCE_WIRE_VERSION, lu as OtelSpan, mu as createOtelExporter, nu as EvalRunsExportConfig, ou as OtelAttribute, pc as WorktreeCheckRunner, pu as buildRuntimeEventOtelSpans, ru as EvalRunsExportResult, su as OtelExportConfig, tu as EvalRunGeneration, uu as RuntimeEventOtelOptions, zu as PlannerError } from "./index-DruSKs3Z.js";
+import { A as createRuntimeEventCollector, C as RuntimeEventCollector, D as RuntimeTelemetryOptions, E as RuntimeStreamEventSummary, M as sanitizeAgentRuntimeEvent, N as sanitizeKnowledgeReadinessReport, O as SanitizedKnowledgeReadinessReport, P as sanitizeRuntimeStreamEvent, T as RuntimeStreamEventSink, j as createRuntimeStreamEventCollector, k as SanitizedKnowledgeRequirement, w as RuntimeStreamEventCollector } from "./local-harness-Dh8PJ0ot.js";
+import { C as AgentCandidateCodeSurfaceSource, D as AgentCandidateBundleInput, E as buildAgentCandidateBundle, O as sealAgentCandidateBundle, S as AgentCandidateCodeSource, T as BuildAgentCandidateBundleInput, _ as exactProcessProviderAsCandidateExecutor, a as captureAgentCandidateWorkspace, b as FileAgentCandidateExecutionClaimStore, c as AGENT_CANDIDATE_EXECUTION_SUPPORT, d as recoverExpiredAgentCandidateExecution, f as persistCandidateOutputArtifact, g as ExactProcessCandidateExecutorOptions, h as candidateKnowledgeExecutionPaths, i as CreateAgentCandidateWorkspacePortOptions, l as verifyAgentCandidateBundle, m as CANDIDATE_KNOWLEDGE_ROOT_ENV, n as CaptureAgentCandidateWorkspaceOptions, o as captureAgentCandidateWorkspaceFiles, p as CANDIDATE_KNOWLEDGE_RETRIEVAL_CONFIG_ENV, r as CapturedAgentCandidateWorkspace, s as createAgentCandidateWorkspacePort, t as AgentCandidateWorkspaceArchiveLimits, u as RecoverExpiredAgentCandidateOptions, v as DisposePreparedAgentCandidateOptions, w as AgentCandidateProfileSource, x as FileAgentCandidateExecutionClaimStoreOptions, y as disposePreparedAgentCandidateExecution } from "./index-C-FYUuFG.js";
+import { A as AgentCandidateExecutionTerminalRecord, C as AgentCandidateExecutionFailureClass, D as AgentCandidateExecutionPhaseResult, E as AgentCandidateExecutionPhase, F as candidateExecutionClaim, I as AgentCandidatePreparationEvidence, M as AgentCandidateRetryRejection, N as InMemoryAgentCandidateExecutionClaimStore, O as AgentCandidateExecutionRecoveryEvidence, P as InMemoryAgentCandidateExecutionClaimStoreOptions, S as AgentCandidateExecutionCleanupHandles, T as AgentCandidateExecutionLease, _ as AgentCandidateExecutionAttemptRecord, a as AgentCandidateModelGrantSettleInput, b as AgentCandidateExecutionClaimResult, c as applyExactAgentProfileDiff, d as parseExactAgentProfile, f as parseExactAgentProfileDiff, g as executePreparedAgentCandidate, h as ExecutePreparedAgentCandidateOptions, i as AgentCandidateModelGrantReserveInput, j as AgentCandidateExecutionTerminalResult, k as AgentCandidateExecutionStageResult, l as assertCandidateProfileBinding, m as prepareAgentCandidateExecution, n as AgentCandidateModelGrantClient, o as CreateProtectedAgentCandidateModelPortOptions, p as PrepareAgentCandidateExecutionOptions, r as AgentCandidateModelGrantReservation, s as createProtectedAgentCandidateModelPort, t as AgentCandidateModelGrantActivateInput, v as AgentCandidateExecutionAttemptRef, w as AgentCandidateExecutionFinishResult, x as AgentCandidateExecutionClaimStore, y as AgentCandidateExecutionClaim } from "./protected-model-port-BP6Z4eau.js";
+import { A as CANDIDATE_TRACE_ENV, B as VerifiedAgentCandidate, C as AgentCandidateProtectedModelSettlement, D as AgentCandidateTaskExecution, E as AgentCandidateRunFinalization, F as PreparedAgentCandidateInstruction, I as PreparedAgentCandidateKnowledge, L as PreparedAgentCandidateLaunch, M as CanonicalCandidateDocument, N as PersistedTaskOutcomeEvidence, O as AgentCandidateVerificationPorts, P as PreparedAgentCandidateExecution, R as PreparedAgentCandidateTrace, S as AgentCandidateProtectedModelReservation, T as AgentCandidateRepositoryPort, V as VerifiedAgentCandidateTaskOutcome, _ as AgentCandidateModelLimits, a as AgentCandidateExecutionPorts, b as AgentCandidateOutputPurpose, c as AgentCandidateExecutorPort, d as AgentCandidateExecutorStopRequest, f as AgentCandidateExecutorTaskOutcomeCapture, g as AgentCandidateMemoryResetResult, h as AgentCandidateMemoryPort, i as AgentCandidateContainerPort, j as CANDIDATE_TRACE_TAGS, k as AgentCandidateWorkspacePort, l as AgentCandidateExecutorProfileFile, m as AgentCandidateExecutorWorkspaceInput, n as AgentCandidateBenchmarkGraderIdentity, o as AgentCandidateExecutorFinalCapture, p as AgentCandidateExecutorWorkspaceFile, r as AgentCandidateBenchmarkGraderPort, s as AgentCandidateExecutorMemoryCapture, t as AgentCandidateArtifactPort, u as AgentCandidateExecutorRequest, v as AgentCandidateModelPort, w as AgentCandidateProtectedRunCapture, x as AgentCandidateProtectedModelActivation, y as AgentCandidateOutputArtifactPort, z as ResolvedAgentCandidateContainer } from "./types-BaIpb0XT.js";
+import { $ as sleep, A as RunConversationOptions, B as buildForwardHeaders, C as ConversationResult, D as HaltPredicate, E as HaltContext, F as InMemoryConversationJournal, G as CircuitBreakerState, H as readDepth, I as DEFAULT_MAX_DEPTH, J as RetryBackoff, K as CircuitOpenError, L as FORWARD_HEADERS, M as ConversationJournal, N as ConversationJournalEntry, O as HaltReason, P as FileConversationJournal, Q as makePerAttemptSignal, R as ForwardHeaderName, S as ConversationPolicy, T as ConversationTurn, U as BackendCallPolicy, V as isDepthExceeded, W as CircuitBreakerConfig, X as computeBackoff, Y as RetryableErrorPredicate, Z as defaultIsRetryable, _ as createConversationBackend, a as RunPersonaConfig, b as ConversationDriveState, c as runPersonaDispatch, d as D1DatabaseLike, f as D1StmtLike, g as defineConversation, h as d1ToSqlAdapter, i as PersonaDriver, j as TurnOrder, k as HaltSignal, l as runConversation, m as SqlConversationJournal, n as turnId, o as RunPersonaConversationOptions, p as SqlAdapter, q as DeadlineExceededError, r as PersonaConversationResult, s as runPersonaConversation, t as slugifySpeaker, u as runConversationStream, v as AuthSource, w as ConversationStreamEvent, x as ConversationParticipant, y as Conversation, z as PropagatedHeaders } from "./index-Efjb3nrQ.js";
+import { $ as rawTraceDistiller, A as ResolveAgentBackendOptions, At as handleChatTurn, B as getModels, C as readinessServerSentEvent, Ct as deriveExecutionId, D as runAgentTask, Dt as ChatTurnProducer, E as applyRunRecordDefaults, Et as ChatTurnIdentity, F as DEFAULT_ROUTER_BASE_URL, G as applyRolloutPolicyToProfile, H as resolveRouterBaseUrl, I as ModelInfo, J as serializeRolloutPolicy, K as normalizeRolloutPolicy, L as ResolvedChatModel, M as decideKnowledgeReadiness, Mt as createIterableBackend, N as ChatModelCandidate, Nt as createOpenAICompatibleBackend, O as runAgentTaskStream, Ot as ChatTurnResult, P as ChatModelValidation, Pt as createSandboxPromptBackend, Q as RawTraceDistillerOptions, R as RouterEnv, S as ServerSentEventOptions, St as toolBuildPrompt, T as InMemoryRuntimeSessionStore, Tt as ChatTurnHooks, U as validateChatModelId, V as resolveChatModel, W as ROLLOUT_POLICY_EXTENSION, X as ReflectiveGeneratorOptions, Y as structuralRolloutPolicyFromProfile, Z as reflectiveGenerator, _ as ToolLoopMessage, _t as DriverLoopGeneratorOptions, a as ControlStep, at as OfficialOptimizerContextOptions, b as runToolLoop, bt as findingLines, c as KnowledgeRequirement, ct as OfficialSkillOptOptions, d as StreamToolLoopOptions, dt as McpServeSpec, et as buildDriverSystem, f as StreamToolLoopYield, ft as mcpServeVerifier, g as ToolLoopEvent, gt as toAnalystFindings, h as ToolLoopCall, ht as isAnalystFinding, i as ControlRunResult, it as OfficialGepaOptions, j as resolveAgentBackend, jt as BackendRetryPolicy, k as AgentBackendKind, kt as RunChatTurnInput, l as RunRecord, lt as officialGepa, m as ToolLoopAssistantToolCall, mt as ToAnalystFindingsOptions, n as ControlDecision, nt as researchDriverNote, o as DataAcquisitionPlan, ot as OfficialOptimizerUnavailableError, p as ToolCallOutcome, pt as LIFTED_FINDING_ANALYST_ID, q as parseRolloutPolicy, r as ControlEvalResult, rt as strategyAuthorMethod, s as KnowledgeReadinessReport, st as OfficialSensitiveCandidateInput, t as ControlBudget, tt as optimizerMethod, u as RunToolLoopOptions, ut as officialSkillOpt, v as ToolLoopResult, vt as driverLoopGenerator, w as runtimeStreamServerSentEvent, wt as ChatStreamEvent, x as streamToolLoop, xt as mcpBuildPrompt, y as ToolLoopStopReason, yt as BuildPromptFindingsInput, z as cleanModelId } from "./index-BGdxAwfO.js";
+import { A as AGENTIC_PROFILE_RESOURCE_ROOT, B as CandidateGenerator, C as ImproveSkillsOptions, D as ImprovementProfileCandidate, E as ImprovementCodeCandidate, F as Verifier, I as VerifyResult, L as agenticGenerator, M as AgenticGeneratorShotDisposition, N as AgenticGeneratorShotExecution, O as DeepReadonly, P as AgenticGeneratorShotReceipt, R as commandVerifier, S as ImproveResult, T as ImprovementCandidate, _ as ImproveOptimizationRunOptions, a as ImproveCandidateValidationInput, b as ImproveProfileComponents, c as ImproveCodeResult, d as ImproveLineage, f as ImproveMethodContext, g as ImproveMethodSource, h as ImproveMethodResult, i as improve, j as AgenticGeneratorOptions, k as ReadonlyAgentProfile, l as ImproveCodeRunOptions, m as ImproveMethodOptions, o as ImproveCandidateValidator, p as ImproveMethodFactory, s as ImproveCodeOptions, u as ImproveCost, v as ImproveOptions, w as ImproveSurface, x as ImproveProfileSurface, y as ImproveProfileAgent, z as defaultBuildPrompt } from "./redact-kbIOjfjM.js";
+import { C as KnowledgeImprovementActivationExecutor, S as CreateKnowledgeImprovementActivationExecutorOptions, _ as SupervisedKnowledgeUpdater, a as KnowledgeImprovementJobResult, b as knowledgeReadinessDeliverable, c as createAgentKnowledgeReadinessCheck, d as KnowledgeReadinessCheckInput, f as KnowledgeReadinessCheckResult, g as SupervisedKnowledgeUpdateResult, h as SupervisedKnowledgeUpdateOptions, i as KnowledgeImprovementJobMeasurement, l as runKnowledgeImprovementJob, m as SupervisedKnowledgeUpdateInput, n as KnowledgeImprovementCandidatePair, o as RunKnowledgeImprovementJobOptions, p as RESEARCH_SUPERVISOR_SYSTEM_PROMPT, r as KnowledgeImprovementExperimentBundles, s as buildKnowledgeImprovementExperimentBundles, t as AgentKnowledgeReadinessCheckOptions, u as KnowledgeReadinessCheck, v as createSupervisedKnowledgeUpdater, w as createKnowledgeImprovementActivationExecutor, x as runSupervisedKnowledgeUpdate, y as formatSupervisedKnowledgeTask } from "./index-CbNM40xG.js";
+import { _ as researchLoopRunner, a as DELEGATED_LOOP_MODES, c as DelegatedLoopResult, d as ResearchLoopRunnerOptions, f as RunDelegatedLoopOptions, g as isDelegatedLoopMode, h as auditLoopRunner, i as runLoopRunnerCli, l as DelegatedLoopRunner, m as WorktreeLoopRunnerOptions, n as LoopRunnerCliResult, o as DelegatedLoopMode, p as VetoedFact, r as parseLoopRunnerArgv, s as DelegatedLoopRegistry, t as LoopRunnerCliArgs, u as ResearchLoopResult, v as runDelegatedLoop, y as worktreeLoopRunner } from "./loop-runner-bin-BXsFEUcf.js";
+import { n as mcpToolsForRuntimeMcpSubset, t as mcpToolsForRuntimeMcp } from "./openai-tools-B68JaOCx.js";
+export { AGENTIC_PROFILE_RESOURCE_ROOT, AGENT_CANDIDATE_EXECUTION_SUPPORT, type AgentAdapter, type AgentBackendContext, type AgentBackendInput, type AgentBackendKind, type AgentCandidateArtifactPort, type AgentCandidateBenchmarkGraderIdentity, type AgentCandidateBenchmarkGraderPort, type AgentCandidateBundleInput, type AgentCandidateCodeSource, type AgentCandidateCodeSurfaceSource, type AgentCandidateContainerPort, type AgentCandidateExecutionAttemptRecord, type AgentCandidateExecutionAttemptRef, type AgentCandidateExecutionClaim, type AgentCandidateExecutionClaimResult, type AgentCandidateExecutionClaimStore, type AgentCandidateExecutionCleanupHandles, type AgentCandidateExecutionFailureClass, type AgentCandidateExecutionFinishResult, type AgentCandidateExecutionLease, type AgentCandidateExecutionPhase, type AgentCandidateExecutionPhaseResult, type AgentCandidateExecutionPorts, type AgentCandidateExecutionRecoveryEvidence, type AgentCandidateExecutionStageResult, type AgentCandidateExecutionTerminalRecord, type AgentCandidateExecutionTerminalResult, type AgentCandidateExecutorFinalCapture, type AgentCandidateExecutorMemoryCapture, type AgentCandidateExecutorPort, type AgentCandidateExecutorProfileFile, type AgentCandidateExecutorRequest, type AgentCandidateExecutorStopRequest, type AgentCandidateExecutorTaskOutcomeCapture, type AgentCandidateExecutorWorkspaceFile, type AgentCandidateExecutorWorkspaceInput, type AgentCandidateMemoryPort, type AgentCandidateMemoryResetResult, type AgentCandidateModelGrantActivateInput, type AgentCandidateModelGrantClient, type AgentCandidateModelGrantReservation, type AgentCandidateModelGrantReserveInput, type AgentCandidateModelGrantSettleInput, type AgentCandidateModelLimits, type AgentCandidateModelPort, type AgentCandidateOutputArtifactPort, type AgentCandidateOutputPurpose, type AgentCandidatePreparationEvidence, type AgentCandidateProfileSource, type AgentCandidateProtectedModelActivation, type AgentCandidateProtectedModelReservation, type AgentCandidateProtectedModelSettlement, type AgentCandidateProtectedRunCapture, type AgentCandidateRepositoryPort, type AgentCandidateRetryRejection, type AgentCandidateRunFinalization, type AgentCandidateTaskExecution, type AgentCandidateVerificationPorts, type AgentCandidateWorkspaceArchiveLimits, type AgentCandidateWorkspacePort, AgentEvalError, type AgentEvalErrorCode, type AgentExecutionBackend, type AgentKnowledgeProvider, type AgentKnowledgeReadinessCheckOptions, type AgentRuntimeEvent, type AgentRuntimeEventSink, type AgentTaskContext, type AgentTaskRunResult, type AgentTaskSpec, type AgentTaskStatus, type AgenticGeneratorOptions, type AgenticGeneratorShotDisposition, type AgenticGeneratorShotExecution, type AgenticGeneratorShotReceipt, type AuthSource, type BackendCallPolicy, type BackendErrorDetail, type BackendRetryPolicy, BackendTransportError, type BuildAgentCandidateBundleInput, type BuildPromptFindingsInput, CANDIDATE_KNOWLEDGE_RETRIEVAL_CONFIG_ENV, CANDIDATE_KNOWLEDGE_ROOT_ENV, CANDIDATE_TRACE_ENV, CANDIDATE_TRACE_TAGS, type CandidateGenerator, type CanonicalCandidateDocument, type CaptureAgentCandidateWorkspaceOptions, type CapturedAgentCandidateWorkspace, type ChatModelCandidate, type ChatModelValidation, type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, type CircuitBreakerConfig, CircuitBreakerState, CircuitOpenError, ConfigError, type ControlBudget, type ControlDecision, type ControlEvalResult, type ControlRunResult, type ControlStep, type Conversation, type ConversationDriveState, type ConversationJournal, type ConversationJournalEntry, type ConversationParticipant, type ConversationPolicy, type ConversationResult, type ConversationStreamEvent, type ConversationTurn, type CreateAgentCandidateWorkspacePortOptions, type CreateKnowledgeImprovementActivationExecutorOptions, type CreateProtectedAgentCandidateModelPortOptions, type D1DatabaseLike, type D1StmtLike, DEFAULT_MAX_DEPTH, DEFAULT_ROUTER_BASE_URL, DELEGATED_LOOP_MODES, type DataAcquisitionPlan, DeadlineExceededError, type DeepReadonly, type DelegatedLoopMode, type DelegatedLoopRegistry, type DelegatedLoopResult, type DelegatedLoopRunner, type DisposePreparedAgentCandidateOptions, type DriverLoopGeneratorOptions, type EvalRunEvent, type EvalRunGeneration, type EvalRunsExportConfig, type EvalRunsExportResult, type ExactProcessCandidateExecutorOptions, type ExecutePreparedAgentCandidateOptions, FORWARD_HEADERS, FileAgentCandidateExecutionClaimStore, type FileAgentCandidateExecutionClaimStoreOptions, FileConversationJournal, type ForwardHeaderName, type HaltContext, type HaltPredicate, type HaltReason, type HaltSignal, INTELLIGENCE_WIRE_VERSION, type ImproveCandidateValidationInput, type ImproveCandidateValidator, type ImproveCodeOptions, type ImproveCodeResult, type ImproveCodeRunOptions, type ImproveCost, type ImproveLineage, type ImproveMethodContext, type ImproveMethodFactory, type ImproveMethodOptions, type ImproveMethodResult, type ImproveMethodSource, type ImproveOptimizationRunOptions, type ImproveOptions, type ImproveProfileAgent, type ImproveProfileComponents, type ImproveProfileSurface, type ImproveResult, type ImproveSkillsOptions, type ImproveSurface, type ImprovementCandidate, type ImprovementCodeCandidate, type ImprovementProfileCandidate, InMemoryAgentCandidateExecutionClaimStore, type InMemoryAgentCandidateExecutionClaimStoreOptions, InMemoryConversationJournal, InMemoryRuntimeSessionStore, JudgeError, type KnowledgeImprovementActivationExecutor, type KnowledgeImprovementCandidatePair, type KnowledgeImprovementExperimentBundles, type KnowledgeImprovementJobMeasurement, type KnowledgeImprovementJobResult, type KnowledgeReadinessCheck, type KnowledgeReadinessCheckInput, type KnowledgeReadinessCheckResult, type KnowledgeReadinessDecision, type KnowledgeReadinessReport, type KnowledgeRequirement, LIFTED_FINDING_ANALYST_ID, type LoopRunnerCliArgs, type LoopRunnerCliResult, type LoopSpanNode, type McpServeSpec, type ModelInfo, NotFoundError, type OfficialGepaOptions, type OfficialOptimizerContextOptions, OfficialOptimizerUnavailableError, type OfficialSensitiveCandidateInput, type OfficialSkillOptOptions, type OpenAIChatResponseFormat, type OpenAIChatTool, type OpenAIChatToolChoice, type OtelAttribute, type OtelExportConfig, type OtelExporter, type OtelSpan, type PersistedTaskOutcomeEvidence, type PersonaConversationResult, type PersonaDriver, PlannerError, type PrepareAgentCandidateExecutionOptions, type PreparedAgentCandidateExecution, type PreparedAgentCandidateInstruction, type PreparedAgentCandidateKnowledge, type PreparedAgentCandidateLaunch, type PreparedAgentCandidateTrace, type PropagatedHeaders, RESEARCH_SUPERVISOR_SYSTEM_PROMPT, ROLLOUT_POLICY_EXTENSION, type RawTraceDistillerOptions, type ReadonlyAgentProfile, type RecoverExpiredAgentCandidateOptions, type ReflectiveGeneratorOptions, type ResearchLoopResult, type ResearchLoopRunnerOptions, type ResolveAgentBackendOptions, type ResolvedAgentCandidateContainer, type ResolvedChatModel, type RetryBackoff, type RetryableErrorPredicate, type RouterEnv, type RunAgentTaskOptions, type RunAgentTaskStreamOptions, type RunChatTurnInput, type RunConversationOptions, type RunDelegatedLoopOptions, type RunKnowledgeImprovementJobOptions, type RunPersonaConfig, type RunPersonaConversationOptions, type RunRecord, type RunToolLoopOptions, type RuntimeDecisionEvidenceRef, type RuntimeDecisionKind, type RuntimeDecisionPoint, type RuntimeEventCollector, type RuntimeEventOtelOptions, type RuntimeHookContext, type RuntimeHookErrorContext, type RuntimeHookEvent, type RuntimeHookPhase, type RuntimeHookTarget, type RuntimeHooks, type RuntimeRunCompleteInput, type RuntimeRunCost, type RuntimeRunHandle, type RuntimeRunOptions, type RuntimeRunPersistenceAdapter, type RuntimeRunRow, RuntimeRunStateError, type RuntimeRunStatus, type RuntimeSession, type RuntimeSessionStore, type RuntimeStreamEvent, type RuntimeStreamEventCollector, type RuntimeStreamEventSink, type RuntimeStreamEventSummary, type RuntimeTelemetryOptions, type SanitizedKnowledgeReadinessReport, type SanitizedKnowledgeRequirement, type ServerSentEventOptions, type SqlAdapter, SqlConversationJournal, type StreamToolLoopOptions, type StreamToolLoopYield, type SupervisedKnowledgeUpdateInput, type SupervisedKnowledgeUpdateOptions, type SupervisedKnowledgeUpdateResult, type SupervisedKnowledgeUpdater, type ToAnalystFindingsOptions, type ToolCallOutcome, type ToolLoopAssistantToolCall, type ToolLoopCall, type ToolLoopEvent, type ToolLoopMessage, type ToolLoopResult, type ToolLoopStopReason, type TurnOrder, ValidationError, type VerifiedAgentCandidate, type VerifiedAgentCandidateTaskOutcome, type Verifier, type VerifyResult, type VetoedFact, type WorktreeCheckRunner, type WorktreeLoopRunnerOptions, agenticGenerator, applyExactAgentProfileDiff, applyRolloutPolicyToProfile, applyRunRecordDefaults, assertCandidateProfileBinding, auditLoopRunner, buildAgentCandidateBundle, buildDriverSystem, buildForwardHeaders, buildKnowledgeImprovementExperimentBundles, buildLoopOtelSpans, buildLoopSpanNodes, buildRuntimeEventOtelSpans, candidateExecutionClaim, candidateKnowledgeExecutionPaths, captureAgentCandidateWorkspace, captureAgentCandidateWorkspaceFiles, cleanModelId, commandVerifier, composeRuntimeHooks, computeBackoff, createAgentCandidateWorkspacePort, createAgentKnowledgeReadinessCheck, createConversationBackend, createIterableBackend, createKnowledgeImprovementActivationExecutor, createOpenAICompatibleBackend, createOtelExporter, createProtectedAgentCandidateModelPort, createRuntimeEventCollector, createRuntimeStreamEventCollector, createSandboxPromptBackend, createSupervisedKnowledgeUpdater, d1ToSqlAdapter, decideKnowledgeReadiness, defaultBuildPrompt, defaultIsRetryable, defineConversation, defineRuntimeHooks, deriveExecutionId, disposePreparedAgentCandidateExecution, driverLoopGenerator, exactProcessProviderAsCandidateExecutor, executePreparedAgentCandidate, exportEvalRuns, findingLines, formatSupervisedKnowledgeTask, getModels, handleChatTurn, improve, isAnalystFinding, isDelegatedLoopMode, isDepthExceeded, knowledgeReadinessDeliverable, loopEventToOtelSpan, makePerAttemptSignal, mcpBuildPrompt, mcpServeVerifier, mcpToolsForRuntimeMcp, mcpToolsForRuntimeMcpSubset, normalizeRolloutPolicy, notifyRuntimeDecisionPoint, notifyRuntimeHookEvent, officialGepa, officialSkillOpt, optimizerMethod, parseExactAgentProfile, parseExactAgentProfileDiff, parseLoopRunnerArgv, parseRolloutPolicy, persistCandidateOutputArtifact, prepareAgentCandidateExecution, rawTraceDistiller, readDepth, readinessServerSentEvent, recoverExpiredAgentCandidateExecution, reflectiveGenerator, researchDriverNote, researchLoopRunner, resolveAgentBackend, resolveChatModel, resolveRouterBaseUrl, runAgentTask, runAgentTaskStream, runConversation, runConversationStream, runDelegatedLoop, runKnowledgeImprovementJob, runLoopRunnerCli, runPersonaConversation, runPersonaDispatch, runSupervisedKnowledgeUpdate, runToolLoop, runtimeStreamServerSentEvent, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, sealAgentCandidateBundle, serializeRolloutPolicy, sleep, slugifySpeaker, startRuntimeRun, strategyAuthorMethod, streamToolLoop, structuralRolloutPolicyFromProfile, toAnalystFindings, toolBuildPrompt, turnId, validateChatModelId, verifyAgentCandidateBundle, worktreeLoopRunner };