@tangle-network/agent-runtime 0.197.1 → 0.198.1

package/dist/index.d.ts

@@ -1,23 +1,18 @@
-import { $ as OpenAIChatToolChoice, A as RuntimeRunCompleteInput, B as AgentBackendInput, F as RuntimeRunRow, G as AgentTaskContext, H as AgentKnowledgeProvider, I as RuntimeRunStatus, J as AgentTaskStatus, K as AgentTaskRunResult, L as startRuntimeRun, M as RuntimeRunHandle, N as RuntimeRunOptions, P as RuntimeRunPersistenceAdapter, Q as OpenAIChatTool, R as AgentAdapter, U as AgentRuntimeEvent, V as AgentExecutionBackend, W as AgentRuntimeEventSink, X as KnowledgeReadinessDecision, Y as BackendErrorDetail, Z as OpenAIChatResponseFormat, at as RuntimeStreamEvent, et as RunAgentTaskOptions, it as RuntimeSessionStore, j as RuntimeRunCost, m as LoopResult, nt as RuntimeCanonicalStreamEvent, q as AgentTaskSpec, r as Driver, rt as RuntimeSession, tt as RunAgentTaskStreamOptions, z as AgentBackendContext } from "./types-Q0PMagdm.js";
+import { $ as OpenAIChatToolChoice, A as RuntimeRunCompleteInput, B as AgentBackendInput, F as RuntimeRunRow, G as AgentTaskContext, H as AgentKnowledgeProvider, I as RuntimeRunStatus, J as AgentTaskStatus, K as AgentTaskRunResult, L as startRuntimeRun, M as RuntimeRunHandle, N as RuntimeRunOptions, P as RuntimeRunPersistenceAdapter, Q as OpenAIChatTool, R as AgentAdapter, U as AgentRuntimeEvent, V as AgentExecutionBackend, W as AgentRuntimeEventSink, X as KnowledgeReadinessDecision, Y as BackendErrorDetail, Z as OpenAIChatResponseFormat, at as RuntimeStreamEvent, et as RunAgentTaskOptions, it as RuntimeSessionStore, j as RuntimeRunCost, nt as RuntimeCanonicalStreamEvent, q as AgentTaskSpec, rt as RuntimeSession, tt as RunAgentTaskStreamOptions, z as AgentBackendContext } from "./types-Q0PMagdm.js";
 import { i as SurfaceImprovementEdit } from "./improvement-adapter-D5gwwoXQ.js";
 import { o as ImprovementProposalSource } from "./types-zWfqDjeL.js";
-import { Ap as PlannerError, Dp as ConfigError, Ep as BackendTransportError, Fp as RuntimeRunStateError, Hu as AuthoredAnalystDefinition, Ip as ValidationError, Ju as CoordinationEvent, Kr as StructuralRolloutPolicy, Lu as AnalystKind, Mp as RetainedInteractiveBindingError, Np as RetainedRunAdmissionError, Op as JudgeError, Pp as RetainedRunDispatchBindingError, Tp as AgentEvalErrorCode, Ys as SupervisorFinalizer, jp as RetainedInteractiveAdmissionError, kp as NotFoundError, qs as FinalizeContext, wp as AgentEvalError, zu as AnalystRegistry } from "./index-CYOJsxSg.js";
+import { Ap as PlannerError, Dp as ConfigError, Ep as BackendTransportError, Fp as RuntimeRunStateError, Ip as ValidationError, Kr as StructuralRolloutPolicy, Mp as RetainedInteractiveBindingError, Np as RetainedRunAdmissionError, Op as JudgeError, Pp as RetainedRunDispatchBindingError, Tp as AgentEvalErrorCode, jp as RetainedInteractiveAdmissionError, kp as NotFoundError, ps as SupervisorProfile, qp as DeliverableSpec, wp as AgentEvalError, zo as SuperviseOptions } from "./index-D8LWK3Ha.js";
 import { a as RuntimeHookErrorContext, c as RuntimeHookTarget, d as defineRuntimeHooks, f as notifyRuntimeDecisionPoint, i as RuntimeHookContext, l as RuntimeHooks, n as RuntimeDecisionKind, o as RuntimeHookEvent, p as notifyRuntimeHookEvent, r as RuntimeDecisionPoint, s as RuntimeHookPhase, t as RuntimeDecisionEvidenceRef, u as composeRuntimeHooks } from "./runtime-hooks-Bj6wJHlH.js";
-import { $t as sanitizeAgentRuntimeEvent, A as ProviderModelAttemptEvidence, At as OtelExporter, B as Scope, Bt as loopEventToOtelSpan, Ct as EvalRunGeneration, Dt as LoopSpanNode, Et as INTELLIGENCE_WIRE_VERSION, Ft as buildRuntimeEventOtelSpans, Gt as RuntimeStreamEventCollector, Ht as padTraceId, It as createOpenInferenceFileExporter, J as SpendChannel, Jt as RuntimeTelemetryOptions, Kt as RuntimeStreamEventSink, L as RootProviderModelEvidence, Lt as createOtelExporter, Mt as RuntimeEventOtelOptions, Nt as buildLoopOtelSpans, Ot as OtelAttribute, Pt as buildLoopSpanNodes, Q as Supervisor, Qt as createRuntimeStreamEventCollector, Rt as exportEvalRuns, St as EvalRunEvent, Tt as EvalRunsExportResult, Ut as toOtelAttributes, V as Settled, Vt as padSpanId, Wt as RuntimeEventCollector, Xt as SanitizedKnowledgeRequirement, Y as SpendGap, Yt as SanitizedKnowledgeReadinessReport, Z as SupervisedResult, Zt as createRuntimeEventCollector, _ as ExecutorRegistry, en as sanitizeKnowledgeReadinessReport, et as TokenUsageProvenance, i as Budget, j as ProviderModelExecutionEvidence, jt as OtelSpan, kt as OtelExportConfig, lt as WorkerTraceEvidence, q as Spend, qt as RuntimeStreamEventSummary, r as AgentSpec, s as Executor, tn as sanitizeRuntimeStreamEvent, ut as WorkerTraceUnavailableReason, wt as EvalRunsExportConfig, zt as generateSpanId } from "./types-DFLZMaeh.js";
-import { c as Redactor } from "./stream-agent-turn-urHpmO_Z.js";
-import { ct as WorktreeCheckRunner } from "./runtime-0xNaV6TJ.js";
-import { A as AgentCandidateWorkspacePort, B as ResolvedAgentCandidateContainer, C as AgentCandidateProtectedModelSettlement, D as AgentCandidateRunFinalization, E as AgentCandidateRepositoryPort, F as PreparedAgentCandidateExecution, H as VerifiedAgentCandidateTaskOutcome, I as PreparedAgentCandidateInstruction, L as PreparedAgentCandidateKnowledge, M as CANDIDATE_TRACE_TAGS, N as CanonicalCandidateDocument, O as AgentCandidateTaskExecution, P as PersistedTaskOutcomeEvidence, R as PreparedAgentCandidateLaunch, S as AgentCandidateProtectedModelReservation, T as AgentCandidateProtectedRunCapture, U as AgentCandidateExecutionRoots, V as VerifiedAgentCandidate, _ 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_ENV, k as AgentCandidateVerificationPorts, 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 AgentCandidateProtectedModelSettlementCall, x as AgentCandidateProtectedModelActivation, y as AgentCandidateOutputArtifactPort, z as PreparedAgentCandidateTrace } from "./types-1s_29INY.js";
-import { A as ExactProcessCandidateExecutorOptions, B as buildAgentCandidateBundle, C as RunProtectedAgentCandidateModelGrantOptions, D as CANDIDATE_KNOWLEDGE_RETRIEVAL_CONFIG_ENV, E as persistCandidateOutputArtifact, F as FileAgentCandidateExecutionClaimStoreOptions, G as candidateWorkspaceManifest, H as sealAgentCandidateBundle, I as AgentCandidateCodeSource, K as scanMaterializedWorkspaceManifest, L as AgentCandidateCodeSurfaceSource, M as DisposePreparedAgentCandidateOptions, N as disposePreparedAgentCandidateExecution, O as CANDIDATE_KNOWLEDGE_ROOT_ENV, P as FileAgentCandidateExecutionClaimStore, R as AgentCandidateProfileSource, S as ProtectedAgentCandidateModelGrantContext, T as runProtectedAgentCandidateModelGrant, U as WorkspaceScanLimits, V as AgentCandidateBundleInput, W as WorkspaceScanOptions, _ as AGENT_CANDIDATE_EXECUTION_SUPPORT, a as WorkspaceTreeEntryPolicy, b as recoverExpiredAgentCandidateExecution, c as describeWorkspaceTree, d as CaptureAgentCandidateWorkspaceOptions, f as CapturedAgentCandidateWorkspace, g as createAgentCandidateWorkspacePort, h as captureAgentCandidateWorkspaceFiles, i as WorkspaceTreeDescriptor, j as exactProcessProviderAsCandidateExecutor, k as candidateKnowledgeExecutionPaths, l as seedWorkspaceTree, m as captureAgentCandidateWorkspace, n as SeedWorkspaceTreeInput, o as WorkspaceTreeExclusion, p as CreateAgentCandidateWorkspacePortOptions, q as verifyMaterializedWorkspace, r as WorkspaceTreeAlgorithm, s as WorkspaceTreeExclusionReason, t as DescribeWorkspaceTreeOptions, u as AgentCandidateWorkspaceArchiveLimits, v as verifyAgentCandidateBundle, w as RunProtectedAgentCandidateModelGrantResult, x as AgentCandidateModelGrantRunReservationInput, y as RecoverExpiredAgentCandidateOptions, z as BuildAgentCandidateBundleInput } from "./index-CUosKU4N.js";
-import { A as AgentCandidateExecutionPhase, B as AgentCandidatePreparationEvidence, C as AgentCandidateExecutionClaim, D as AgentCandidateExecutionFailureClass, E as AgentCandidateExecutionCleanupHandles, F as AgentCandidateExecutionTerminalResult, I as AgentCandidateRetryRejection, L as InMemoryAgentCandidateExecutionClaimStore, M as AgentCandidateExecutionRecoveryEvidence, N as AgentCandidateExecutionStageResult, O as AgentCandidateExecutionFinishResult, P as AgentCandidateExecutionTerminalRecord, R as InMemoryAgentCandidateExecutionClaimStoreOptions, S as AgentCandidateExecutionAttemptRef, T as AgentCandidateExecutionClaimStore, _ as PrepareAgentCandidateExecutionOptions, a as AgentCandidateModelGrantSettleInput, b as executePreparedAgentCandidate, c as agentCandidateProfileAsAgentProfile, d as freezeGenericAgentCandidateProfile, f as omitUndefinedObjectFields, g as parseExactCandidateProfile, h as parseExactAgentProfileDiff, i as AgentCandidateModelGrantReserveInput, j as AgentCandidateExecutionPhaseResult, k as AgentCandidateExecutionLease, l as applyExactAgentProfileDiff, m as parseExactAgentProfile, n as AgentCandidateModelGrantClient, o as CreateProtectedAgentCandidateModelPortOptions, r as AgentCandidateModelGrantReservation, s as createProtectedAgentCandidateModelPort, t as AgentCandidateModelGrantActivateInput, u as assertCandidateProfileBinding, v as prepareAgentCandidateExecution, w as AgentCandidateExecutionClaimResult, x as AgentCandidateExecutionAttemptRecord, y as ExecutePreparedAgentCandidateOptions, z as candidateExecutionClaim } from "./protected-model-port-BtXp2dUY.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, et as createProfileExecutionBackend, 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-D9mb6fn2.js";
-import { $ as CandidateGenerator, A as ImprovementProfileCandidate, B as ImprovementRefusedProfilePopulationCandidate, C as ImproveRuntimeCodeGeneratorOptions, D as ImprovementCandidate, E as ImproveSurface, F as ImprovementProfilePopulationCandidate, G as AgenticGeneratorShotDisposition, H as ReadonlyAgentProfile, I as ImprovementProfilePopulationCandidateSource, J as Verifier, K as AgenticGeneratorShotExecution, L as ImprovementProfilePopulationLineage, M as ImprovementProfileCandidatePopulationAvailable, N as ImprovementProfileCandidatePopulationUnavailable, O as ImprovementCodeCandidate, P as ImprovementProfilePopulationArtifactSource, Q as defaultBuildPrompt, R as ImprovementProfilePopulationLineageNode, S as ImproveResult, T as ImproveSkillsOptions, U as AgenticGeneratorExecutorForWorktree, V as DeepReadonly, W as AgenticGeneratorOptions, X as agenticGenerator, Y as VerifyResult, Z as commandVerifier, _ as ImproveOptimizationRunOptions, a as ImproveCodeOptions, b as ImproveProfileComponents, c as ImproveCost, d as ImproveMethodContext, f as ImproveMethodFactory, g as ImproveMethodSource, h as ImproveMethodResult, i as ImproveCodeBaseOptions, j as ImprovementProfileCandidatePopulation, k as ImprovementMaterializedProfilePopulationCandidate, l as ImproveCustomCodeGeneratorOptions, m as ImproveMethodOptions, n as ImproveCandidateValidationInput, o as ImproveCodeResult, p as ImproveMethodLineage, q as AgenticGeneratorShotReceipt, r as ImproveCandidateValidator, s as ImproveCodeRunOptions, t as improve, u as ImproveLineage, v as ImproveOptions, w as ImproveScenarioPartitions, x as ImproveProfileSurface, y as ImproveProfileAgent, z as ImprovementProfilePopulationObservationSource } from "./improve-DZs0KXhK.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-ZnxSe6iK.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-DwrSB04m.js";
+import { $i as sanitizeAgentRuntimeEvent, Ai as OtelExporter, Bi as loopEventToOtelSpan, Ci as EvalRunGeneration, Di as LoopSpanNode, Ei as INTELLIGENCE_WIRE_VERSION, Fi as buildRuntimeEventOtelSpans, Gi as RuntimeStreamEventCollector, Hi as padTraceId, Ii as createOpenInferenceFileExporter, Ji as RuntimeTelemetryOptions, Ki as RuntimeStreamEventSink, Li as createOtelExporter, Mi as RuntimeEventOtelOptions, Ni as buildLoopOtelSpans, Oi as OtelAttribute, Pi as buildLoopSpanNodes, Qi as createRuntimeStreamEventCollector, Qn as Redactor, Ri as exportEvalRuns, Si as EvalRunEvent, Ti as EvalRunsExportResult, Ui as toOtelAttributes, Vi as padSpanId, Wi as RuntimeEventCollector, Xi as SanitizedKnowledgeRequirement, Yi as SanitizedKnowledgeReadinessReport, Zi as createRuntimeEventCollector, Zr as SupervisedResult, Zt as WorktreeCheckRunner, ea as sanitizeKnowledgeReadinessReport, h as ExecutorConfig, ir as Budget, ji as OtelSpan, ki as OtelExportConfig, pr as ExecutorFactory, qi as RuntimeStreamEventSummary, ta as sanitizeRuntimeStreamEvent, wi as EvalRunsExportConfig, zi as generateSpanId } from "./stream-agent-turn-CLOQr497.js";
+import { y as AgentCandidateOutputArtifactPort } from "./types-1s_29INY.js";
+import { $ as ImprovementProfilePopulationLineageNode, A as ImproveMethodResult, B as ImproveSkillsOptions, C as ImproveCost, D as ImproveMethodFactory, E as ImproveMethodContext, F as ImproveProfileComponents, G as ImprovementProfileCandidate, H as ImprovementCandidate, I as ImproveProfileSurface, J as ImprovementProfileCandidatePopulationUnavailable, K as ImprovementProfileCandidatePopulation, L as ImproveResult, M as ImproveOptimizationRunOptions, N as ImproveOptions, O as ImproveMethodLineage, P as ImproveProfileAgent, Q as ImprovementProfilePopulationLineage, R as ImproveRuntimeCodeGeneratorOptions, S as ImproveCodeRunOptions, T as ImproveLineage, U as ImprovementCodeCandidate, V as ImproveSurface, W as ImprovementMaterializedProfilePopulationCandidate, X as ImprovementProfilePopulationCandidate, Y as ImprovementProfilePopulationArtifactSource, Z as ImprovementProfilePopulationCandidateSource, _ as ImproveCandidateValidationInput, at as AgenticGeneratorOptions, b as ImproveCodeOptions, ct as AgenticGeneratorShotReceipt, dt as agenticGenerator, et as ImprovementProfilePopulationObservationSource, ft as commandVerifier, g as improve, i as AgentImprovementActivationTransition, it as AgenticGeneratorExecutorForWorktree, j as ImproveMethodSource, k as ImproveMethodOptions, lt as Verifier, mt as CandidateGenerator, n as AgentImprovementActivationResultStore, nt as DeepReadonly, ot as AgenticGeneratorShotDisposition, pt as defaultBuildPrompt, q as ImprovementProfileCandidatePopulationAvailable, rt as ReadonlyAgentProfile, st as AgenticGeneratorShotExecution, t as AgentImprovementActivationReconciliation, tt as ImprovementRefusedProfilePopulationCandidate, ut as VerifyResult, v as ImproveCandidateValidator, w as ImproveCustomCodeGeneratorOptions, x as ImproveCodeResult, y as ImproveCodeBaseOptions, z as ImproveScenarioPartitions } from "./activation-DFRTurvU.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-Bn-0o_4k.js";
 import { n as mcpToolsForRuntimeMcpSubset, t as mcpToolsForRuntimeMcp } from "./openai-tools-CRQhVT_V.js";
-import { AgentProfile, Sha256Digest } from "@tangle-network/agent-interface";
-import { ControlBudget, ControlDecision, ControlEvalResult, ControlEvalResult as ControlEvalResult$1, ControlRunResult, ControlStep, DataAcquisitionPlan, KnowledgeReadinessReport, KnowledgeReadinessReport as KnowledgeReadinessReport$1, KnowledgeRequirement, ProposalFinding, RunRecord, RunRecord as RunRecord$1 } from "@tangle-network/agent-eval";
-import { GepaOptimizationMethodConfig, SkillOptOptimizationMethodConfig } from "@tangle-network/agent-eval/campaign";
+import { AgentCandidateBundle, AgentCandidateCapturedArtifact, AgentCandidateKnowledge, AgentProfile, Sha256Digest } from "@tangle-network/agent-interface";
+import { AgentProfile as AgentProfile$1, ControlBudget, ControlDecision, ControlEvalResult, ControlEvalResult as ControlEvalResult$1, ControlRunResult, ControlStep, DataAcquisitionPlan, KnowledgeReadinessReport, KnowledgeReadinessReport as KnowledgeReadinessReport$1, KnowledgeRequirement, MaximumCharge, ProposalFinding, RunRecord, RunRecord as RunRecord$1 } from "@tangle-network/agent-eval";
+import { GepaOptimizationMethodConfig, ProfileDispatchFn, Scenario, SkillOptOptimizationMethodConfig } from "@tangle-network/agent-eval/campaign";
 import { MutableSurface, Scenario as Scenario$1, SelfImproveOptions } from "@tangle-network/agent-eval/contract";
+import { BuildEvalKnowledgeBundleOptions, KnowledgeBaseQualityOptions, KnowledgeImprovementOptions, KnowledgeImprovementResult, KnowledgeReadinessSpec, PromoteKnowledgeCandidateOptions, RagKnowledgeUpdateResult } from "@tangle-network/agent-knowledge";
 //#region src/backends.d.ts
 /** Wrap any custom async-iterable stream into a typed `AgentExecutionBackend`. @stable */
 declare function createIterableBackend<TInput extends AgentBackendInput>(options: {
@@ -36,6 +31,560 @@ declare function createSandboxPromptBackend<TBox, TInput extends AgentBackendInp
   getSessionId?: (box: TBox, input: TInput) => string | undefined;
 }): AgentExecutionBackend<TInput>;
 //#endregion
+//#region src/runtime/profile-execution-backend.d.ts
+/**
+ * Bind one exact profile and Runtime executor to the stable `AgentExecutionBackend` contract used
+ * by `runAgentTaskStream` and conversations.
+ *
+ * Runtime still owns the model call through `streamAgentTurn`.
+ * The adapter only translates the two stream protocols and carries the caller's request headers
+ * into `ExecutorContext` so an HTTP executor can preserve authorization, recursion depth, and
+ * trace identity.
+ *
+ * @stable
+ */
+declare function createProfileExecutionBackend(options: {
+  profile: AgentProfile;
+  executor: ExecutorFactory<unknown>;
+}): AgentExecutionBackend;
+//#endregion
+//#region src/conversation/call-policy.d.ts
+/**
+ *
+ * Per-call resilience policy for participant backends: deadline, retry with
+ * backoff, and a circuit breaker. Each policy is applied *around* a single
+ * turn's backend invocation, not across the whole conversation — the
+ * conversation-level credit cap and `maxTurns` bound the broader run.
+ *
+ * Deadlines abort the underlying backend stream via `AbortSignal` linkage so
+ * the OpenAI/SDK clients tear down their HTTP request cleanly instead of
+ * leaking sockets. Retries replay the same logical turn (same `turnId`) so
+ * any caching gateway can dedupe. Circuit breakers are *per participant*: A's
+ * failures don't open B's breaker.
+ *
+ * @stable
+ */
+/** Pure judgment of whether an error is worth retrying. Defaults: TimeoutError, AbortError, fetch-level network errors. */
+type RetryableErrorPredicate = (err: unknown) => boolean;
+/** Backoff between attempts. Constant ms, or `(attempt: 1-indexed) => ms`. */
+type RetryBackoff = number | ((attempt: number) => number);
+/** Circuit-breaker tuning. `failuresToOpen` consecutive failures opens it; closed only after `cooldownMs`. */
+interface CircuitBreakerConfig {
+  failuresToOpen: number;
+  cooldownMs: number;
+}
+interface BackendCallPolicy {
+  /** Per-attempt wall clock limit. Exceeding fires an AbortSignal and is treated as a retryable failure. */
+  perAttemptDeadlineMs?: number;
+  /** Number of retries after the first attempt; total attempts = 1 + maxRetries. Default 0. */
+  maxRetries?: number;
+  /** Backoff between attempts. Default 250ms with jitter. */
+  retryBackoffMs?: RetryBackoff;
+  /** Custom retry classifier. Defaults to retrying transport failures and retryable HTTP statuses. */
+  isRetryable?: RetryableErrorPredicate;
+  /** Circuit breaker that opens after N consecutive failures per participant. */
+  circuitBreaker?: CircuitBreakerConfig;
+}
+//#endregion
+//#region src/conversation/headers.d.ts
+/**
+ * Header bag carried through `AgentBackendContext.propagatedHeaders` so
+ * backends that opt in can merge them into their outbound HTTP requests.
+ * Distinct from `buildForwardHeaders` so callers can attach extra
+ * non-protocol headers (e.g. tracing) without colliding.
+ */
+type PropagatedHeaders = Readonly<Record<string, string>>;
+//#endregion
+//#region src/conversation/journal.d.ts
+interface ConversationJournalEntry {
+  runId: string;
+  startedAt: string;
+  /** Set when the run reaches a terminal state. */
+  halted?: HaltReason;
+  endedAt?: string;
+  turns: ConversationTurn[];
+}
+interface ConversationJournal {
+  /**
+   * Load any prior state for `runId`. Returns `undefined` for a fresh run.
+   * Implementations MUST NOT mutate the returned object — the runner clones
+   * before continuing — but the runtime treats absence and emptiness
+   * identically, so a journal with zero turns is equivalent to "fresh."
+   */
+  loadRun(runId: string): Promise<ConversationJournalEntry | undefined>;
+  /**
+   * Initialise journal state for a fresh run. Called once per run, before any
+   * `appendTurn`. Idempotent: calling with an existing runId is a no-op if
+   * the entry already exists with the same `startedAt`.
+   */
+  beginRun(runId: string, startedAt: string): Promise<void>;
+  /**
+   * Append a committed turn. The runner only calls this AFTER the turn's
+   * backend stream completed and the credit total has been updated, so an
+   * appended turn is observed-committed and never speculative.
+   */
+  appendTurn(runId: string, turn: ConversationTurn): Promise<void>;
+  /**
+   * Record the run's terminal halt reason + end time. Once called, the run
+   * is observed-final; subsequent `loadRun` returns the same halt.
+   */
+  recordHalt(runId: string, halt: HaltReason, endedAt: string): Promise<void>;
+}
+/** In-memory `ConversationJournal` — suitable for testing and single-process runs. */
+declare class InMemoryConversationJournal implements ConversationJournal {
+  private readonly entries;
+  loadRun(runId: string): Promise<ConversationJournalEntry | undefined>;
+  beginRun(runId: string, startedAt: string): Promise<void>;
+  appendTurn(runId: string, turn: ConversationTurn): Promise<void>;
+  recordHalt(runId: string, halt: HaltReason, endedAt: string): Promise<void>;
+}
+/**
+ * JSONL on disk. One line per record; first line is the `begin`, subsequent
+ * lines are `turn` records, terminal line is `halt`. Replays the whole file
+ * on `loadRun` — cheap for the conversation sizes this is designed for
+ * (thousands of turns, not millions). For huge runs, plug in a real DB
+ * adapter; the interface is small.
+ *
+ * Reads and appends over the shared append-only spine (`durable/jsonl-file`): each
+ * `appendTurn` / `recordHalt` finishes a short write and calls `fsync`, so a process
+ * crash between writes never loses an acknowledged turn, and a crash DURING one leaves
+ * an uncommitted final line that the next read skips and the next append truncates.
+ */
+declare class FileConversationJournal implements ConversationJournal {
+  private readonly path;
+  constructor(path: string);
+  loadRun(runId: string): Promise<ConversationJournalEntry | undefined>;
+  beginRun(runId: string, startedAt: string): Promise<void>;
+  appendTurn(runId: string, turn: ConversationTurn): Promise<void>;
+  recordHalt(runId: string, halt: HaltReason, endedAt: string): Promise<void>;
+  private appendRecord;
+}
+//#endregion
+//#region src/conversation/types.d.ts
+/** @stable */
+interface ConversationParticipant {
+  /**
+   * Stable name used as the speaker label in the transcript. Must be unique
+   * within a `Conversation`.
+   */
+  name: string;
+  /**
+   * Backend that runs this participant's turn. Reuses the existing
+   * `AgentExecutionBackend` contract from `runAgentTaskStream`, so an iterable,
+   * sandbox, or profile-backed Runtime executor works through the same runner.
+   */
+  backend: AgentExecutionBackend;
+  /**
+   * Optional human label for traces / dashboards. Distinct from `name`, which
+   * is the addressing key.
+   */
+  label?: string;
+  /**
+   * Optional per-participant override of the conversation's default
+   * `callPolicy`. Use to tighten the deadline or raise the retry budget for
+   * a participant known to be slow or flaky.
+   */
+  callPolicy?: BackendCallPolicy;
+  /**
+   * Who pays for THIS participant's outbound calls?
+   *
+   * - `'forward-user'` (default) — propagate the caller's
+   *   `X-Tangle-Forwarded-Authorization` so the downstream gateway bills the
+   *   original user. Right for pass-through agents that aggregate/route
+   *   without taking economic risk.
+   * - `'agent-owned'` — DO NOT forward the user's auth; the participant's
+   *   backend uses its own credentials (typically a sk-tan-AGENT or x402
+   *   wallet baked into the backend at construction). Downstream charges
+   *   land on the agent, not the user. Right for resold-bundle agents that
+   *   take margin between their inbound price and their sub-agent costs.
+   * - `(state) => AuthSource` — per-turn / per-condition decision, e.g. base
+   *   sub-services are agent-owned but premium add-ons forward the user.
+   *
+   * The agent's own credentials live on its caller-owned backend or
+   * profile-bound Runtime executor; this field is purely about *whether to
+   * also forward the user's identity downstream*.
+   */
+  authSource?: AuthSource;
+}
+/** @stable */
+type AuthSource = 'forward-user' | 'agent-owned' | ((state: ConversationDriveState) => 'forward-user' | 'agent-owned');
+/** @stable */
+type TurnOrder = 'alternate' | 'round-robin' | ((state: ConversationDriveState) => number);
+/** @stable */
+interface ConversationDriveState {
+  transcript: readonly ConversationTurn[];
+  turnIndex: number;
+  spentCreditsCents: number;
+}
+/** @stable */
+interface HaltContext extends ConversationDriveState {
+  lastTurn: ConversationTurn;
+}
+/** @stable */
+interface HaltSignal {
+  halted: true;
+  reason: string;
+}
+/** @stable */
+type HaltPredicate = (ctx: HaltContext) => boolean | HaltSignal | Promise<boolean | HaltSignal>;
+/** @stable */
+type HaltReason = {
+  kind: 'max_turns';
+  turns: number;
+} | {
+  kind: 'max_credits';
+  spentCents: number;
+  capCents: number;
+} | {
+  kind: 'predicate';
+  reason: string;
+} | {
+  kind: 'abort';
+} | {
+  kind: 'participant_error';
+  participant: string;
+  message: string;
+};
+/** @stable */
+interface ConversationPolicy {
+  /** Hard cap on speaker-turns. Each call into a participant's backend counts as 1. */
+  maxTurns: number;
+  /**
+   * Hard cap on aggregate credit spend across all participants, in cents.
+   * Computed by summing `llm_call.costUsd` from every participant's stream.
+   * Unset (`undefined`) means no credit ceiling — the run is bounded only by
+   * `maxTurns` and `haltOn`.
+   */
+  maxCreditsCents?: number;
+  /**
+   * Speaker selection. Defaults to `'alternate'` for two-participant
+   * conversations and `'round-robin'` for any other arity.
+   */
+  turnOrder?: TurnOrder;
+  /**
+   * Optional convergence / content-based halt. Called after every turn ends;
+   * returning truthy stops the loop with `{ kind: 'predicate', ... }`.
+   */
+  haltOn?: HaltPredicate;
+  /**
+   * Default per-turn resilience policy applied to every participant call
+   * (deadline, retries, circuit breaker). Individual participants may
+   * override via `ConversationParticipant.callPolicy`.
+   */
+  defaultCallPolicy?: BackendCallPolicy;
+}
+/** @stable */
+interface ConversationTurn {
+  index: number;
+  speaker: string;
+  /**
+   * Deterministic turn identifier — stable across retries of the same logical
+   * turn so caching gateways and trace backends can dedupe. Shape:
+   * `${runId}.t${index}.${speakerSlug}`.
+   */
+  turnId: string;
+  /** Backend session used for this turn. Present on turns recorded by session-aware runners. */
+  sessionId?: string;
+  text: string;
+  /**
+   * Aggregated backend usage for this turn alone. Populated from any
+   * `llm_call` stream events the backend emitted; `undefined` when the
+   * backend reports no usage.
+   */
+  usage?: {
+    tokensIn?: number;
+    tokensOut?: number;
+    costUsd?: number;
+    latencyMs?: number;
+    model?: string;
+  };
+  /**
+   * Number of attempts that ran before this turn committed. `1` is the
+   * common case; higher means the call policy retried after transient
+   * failures.
+   */
+  attempts: number;
+  startedAt: string;
+  endedAt: string;
+}
+/** @stable */
+interface Conversation {
+  participants: readonly ConversationParticipant[];
+  policy: ConversationPolicy;
+}
+/** @stable */
+interface RunConversationOptions {
+  /** First message kicking off the conversation. Routes to the first speaker. */
+  seed: string;
+  /**
+   * Optional run identifier for cross-participant trace correlation. Auto-
+   * generated when omitted. Reusing a runId against the same `journal`
+   * resumes the prior run — the runner replays the persisted transcript and
+   * continues from the first un-recorded turn.
+   */
+  runId?: string;
+  /** Cancellation signal — aborts mid-stream and halts with `{ kind: 'abort' }`. */
+  signal?: AbortSignal;
+  /**
+   * Event sink for per-turn micro-events. Distinct from the result transcript:
+   * the sink fires for every text-delta, every turn-start/end, and the
+   * conversation-start/end markers. Used to drive SSE / dashboard updates
+   * without waiting for the conversation to finish.
+   */
+  onEvent?: (event: ConversationStreamEvent) => void | Promise<void>;
+  /**
+   * Optional durable transcript. When set, the runner persists every
+   * committed turn before yielding `turn_end`. Reusing the same `runId`
+   * against the same journal resumes from the last committed turn — so a
+   * driver process crash mid-run loses zero acknowledged turns.
+   */
+  journal?: ConversationJournal;
+  /**
+   * Stores each participant's backend session. The runner keeps an in-memory
+   * store for one invocation when omitted. Reuse a durable store with the same
+   * `runId` and journal after a process restart. Backends implementing `resume`
+   * continue their provider session; other backends receive the full transcript.
+   */
+  sessionStore?: RuntimeSessionStore;
+  /**
+   * Headers to forward verbatim to every participant backend call (gateway
+   * propagation: `X-Tangle-Forwarded-Authorization`, run/turn correlation,
+   * depth counter). Backends opt in by reading `propagatedHeaders` from
+   * their `AgentBackendContext`; backends that ignore the field still work.
+   */
+  propagatedHeaders?: PropagatedHeaders;
+  /**
+   * Inbound depth at the point this driver was invoked. The runner
+   * increments it on every outbound participant call; gateways refuse at
+   * `DEFAULT_MAX_DEPTH`. Default 0 (origin caller).
+   */
+  inboundDepth?: number;
+  /**
+   * Parent turn id when this conversation is *inside* another turn (i.e. the
+   * driver is itself a participant via `createConversationBackend`). The
+   * runner stamps each outbound call with this as `X-Tangle-Parent-TurnId`
+   * so trace stitching survives nested orchestration.
+   */
+  parentTurnId?: string;
+}
+/** @stable */
+interface ConversationResult {
+  runId: string;
+  transcript: ConversationTurn[];
+  turns: number;
+  spentCreditsCents: number;
+  halted: HaltReason;
+  durationMs: number;
+  startedAt: string;
+  endedAt: string;
+}
+/** @stable */
+type ConversationStreamEvent = {
+  type: 'conversation_start';
+  runId: string;
+  participants: readonly string[];
+  seed: string;
+  timestamp: string;
+} | {
+  type: 'conversation_resumed';
+  runId: string;
+  participants: readonly string[];
+  transcript: readonly ConversationTurn[];
+  timestamp: string;
+} | {
+  type: 'turn_start';
+  runId: string;
+  index: number;
+  speaker: string;
+  turnId: string;
+  attempt: number;
+  timestamp: string;
+} | {
+  type: 'turn_text_delta';
+  runId: string;
+  index: number;
+  speaker: string;
+  turnId: string;
+  text: string;
+  timestamp?: string;
+} | {
+  type: 'turn_retry';
+  runId: string;
+  index: number;
+  speaker: string;
+  turnId: string;
+  attempt: number;
+  reason: string;
+  timestamp: string;
+} | {
+  type: 'turn_end';
+  runId: string;
+  turn: ConversationTurn;
+  timestamp: string;
+} | {
+  type: 'conversation_end';
+  runId: string;
+  result: ConversationResult;
+  timestamp: string;
+};
+//#endregion
+//#region src/conversation/conversation-backend.d.ts
+/** Adapt a multi-participant conversation into the standard execution backend contract. */
+declare function createConversationBackend(options: {
+  conversation: Conversation;
+  /** Optional backend kind label. Defaults to `'conversation'`. */
+  kind?: string;
+}): AgentExecutionBackend;
+//#endregion
+//#region src/conversation/define-conversation.d.ts
+/** Validate and define a conversation before execution. */
+declare function defineConversation(input: {
+  participants: ConversationParticipant[];
+  policy: ConversationPolicy;
+}): Conversation;
+//#endregion
+//#region src/conversation/journal-sql.d.ts
+/**
+ * Minimal SQL driver shape. Implementations forward to whichever client the
+ * deployment already uses; agent-runtime takes no opinion on which.
+ *
+ * Parameter placeholders MUST be `?` (positional). All adapters listed in the
+ * file header accept this convention.
+ */
+interface SqlAdapter {
+  /** Execute a write statement (INSERT/UPDATE/DELETE/DDL). */
+  exec(sql: string, params?: readonly unknown[]): Promise<{
+    rowsAffected: number;
+  }>;
+  /** Execute a read statement (SELECT). Returns rows as plain objects. */
+  query<TRow = Record<string, unknown>>(sql: string, params?: readonly unknown[]): Promise<TRow[]>;
+}
+/**
+ * Adapt a Cloudflare D1 binding to the SqlAdapter shape. Lives here so D1
+ * consumers don't have to write the wrapper themselves; the runtime never
+ * imports `@cloudflare/workers-types` directly (peer-style typing).
+ */
+declare function d1ToSqlAdapter(db: D1DatabaseLike): SqlAdapter;
+/**
+ * Structural type matching the surface of `D1Database` we depend on, so the
+ * SDK never imports `@cloudflare/workers-types`. Consumers pass their real
+ * `D1Database` from `env.DB` and TS structural compatibility lines it up.
+ */
+interface D1DatabaseLike {
+  prepare(sql: string): D1StmtLike;
+}
+interface D1StmtLike {
+  bind(...params: unknown[]): D1StmtLike;
+  run(): Promise<unknown>;
+  all<TRow = unknown>(): Promise<{
+    results?: TRow[];
+  }>;
+}
+/**
+ * SQL-backed ConversationJournal. Two tables — runs (one row per runId, holds
+ * start/halt timestamps + halt reason) and turns (one row per committed turn,
+ * payload is the ConversationTurn JSON). Replays the turns table on
+ * `loadRun` and writes append-only per `appendTurn`.
+ */
+declare class SqlConversationJournal implements ConversationJournal {
+  private readonly db;
+  private readonly table;
+  /**
+   * @param db    SQL adapter (D1, postgres, sqlite, libSQL — all work)
+   * @param table Table-name prefix; the journal creates `${table}_runs` and
+   *              `${table}_turns`. Lets multiple journals share a database
+   *              without colliding (e.g. one per product surface).
+   */
+  constructor(db: SqlAdapter, table?: string);
+  /**
+   * Create the journal's tables if absent. Idempotent. Call once at deploy
+   * (or at app boot) — running on every request is harmless but adds latency.
+   */
+  migrate(): Promise<void>;
+  loadRun(runId: string): Promise<ConversationJournalEntry | undefined>;
+  beginRun(runId: string, startedAt: string): Promise<void>;
+  appendTurn(runId: string, turn: ConversationTurn): Promise<void>;
+  recordHalt(runId: string, halt: HaltReason, endedAt: string): Promise<void>;
+}
+//#endregion
+//#region src/conversation/run-conversation.d.ts
+/** Run a conversation to completion and return its terminal result. */
+declare function runConversation(conversation: Conversation, options: RunConversationOptions): Promise<ConversationResult>;
+/** Streaming conversation orchestrator: drives N participants in turn through their own backends, enforcing `maxTurns` / `maxCreditsCents` / `haltOn`, yielding per-event stream markers. */
+declare function runConversationStream(conversation: Conversation, options: RunConversationOptions): AsyncIterable<ConversationStreamEvent>;
+//#endregion
+//#region src/conversation/run-persona.d.ts
+/** A persona that drives the conversation: either a full driver `AgentProfile`
+ *  (an LLM user-sim) or a deterministic script of user turns (the fast-path). */
+type PersonaDriver = {
+  kind: 'profile';
+  profile: AgentProfile$1;
+} | {
+  kind: 'scripted';
+  turns: string[];
+};
+interface RunPersonaConversationOptions {
+  /** The agent under test. Metered; its rendered prompt leads its turns. */
+  worker: AgentProfile$1;
+  /** The simulated user driving the dialogue. */
+  persona: PersonaDriver;
+  /** Resolve transport/executable ports for the exact profile. Runtime still materializes the
+   * profile and owns every model call. Applied to the worker and a profile-driven persona. */
+  executorFor: (profile: AgentProfile$1, role: 'worker' | 'persona') => ExecutorFactory<unknown>;
+  /** Speaker-turn cap. Default for a scripted persona = `2 * turns.length`
+   *  (worker answers each user turn). REQUIRED for a `profile` persona. */
+  maxTurns?: number;
+  /** Kickoff message routed to the first speaker (the persona). Default 'Begin.' */
+  seed?: string;
+  /** Content-based "until satisfied" halt, called after every turn. `maxTurns` is the
+   *  hard ceiling; this is the early stop (the persona declares the goal met / unreachable). */
+  haltOn?: HaltPredicate;
+  signal?: AbortSignal;
+  /** Worker participant / transcript speaker label. Default 'agent'. */
+  workerName?: string;
+}
+interface PersonaConversationResult {
+  transcript: ConversationTurn[];
+  turns: number;
+  halted: HaltReason;
+  /** Worker-only spend (the side under test). */
+  costUsd: number;
+  tokensIn: number;
+  tokensOut: number;
+  /** Absent means every worker call reported complete token usage. */
+  tokensKnown?: false;
+  /** Absent means every worker call reported provider-billed cost, including a known zero. */
+  costUsdKnown?: false;
+}
+/**
+ * Run one worker profile against one persona as a multi-round conversation.
+ * The persona leads (participant 0): it speaks, the worker answers, repeat,
+ * until `maxTurns`. Returns the persistent transcript + worker-only usage.
+ */
+declare function runPersonaConversation(opts: RunPersonaConversationOptions): Promise<PersonaConversationResult>;
+interface RunPersonaConfig<TScenario extends Scenario, TArtifact> {
+  /** Resolve transport/executable ports for each exact profile. */
+  executorFor: (profile: AgentProfile$1, role: 'worker' | 'persona') => ExecutorFactory<unknown>;
+  /** The persona driving each scenario — a driver profile or scripted turns. */
+  personaOf: (scenario: TScenario) => PersonaDriver;
+  /** Build the scored artifact from the finished transcript. */
+  artifactOf: (transcript: ConversationTurn[], scenario: TScenario) => TArtifact;
+  /** Speaker-turn cap (required when a persona is profile-driven). */
+  maxTurns?: (scenario: TScenario) => number;
+  seed?: (scenario: TScenario) => string;
+  workerName?: string;
+  /** Provider- or executor-enforced maximum for the whole worker conversation.
+   * Required before execution when the enclosing campaign is cost-capped. */
+  maximumCharge?: MaximumCharge | ((worker: AgentProfile$1, scenario: TScenario) => MaximumCharge | undefined);
+}
+/**
+ * Wrap {@link runPersonaConversation} as a `ProfileDispatchFn` for
+ * `runProfileMatrix`: the profile axis is the worker-under-test, the scenario
+ * axis is the persona, and the runner is the cell. Meters the worker through
+ * `ctx.cost` so the matrix's backend-integrity guard sees real usage.
+ */
+declare function runPersonaDispatch<TScenario extends Scenario, TArtifact>(config: RunPersonaConfig<TScenario, TArtifact>): ProfileDispatchFn<TScenario, TArtifact>;
+//#endregion
 //#region src/improvement/build-prompts.d.ts
 /** Evidence supplied to a generated tool or MCP build instruction. */
 interface BuildPromptFindingsInput {
@@ -280,6 +829,135 @@ declare function structuralRolloutPolicyFromProfile(profile: ReadonlyAgentProfil
 /** Persist a detached policy under the profile extension without mutating the input. */
 declare function applyRolloutPolicyToProfile(profile: ReadonlyAgentProfile, policy: StructuralRolloutPolicy): AgentProfile;
 //#endregion
+//#region src/knowledge/activation.d.ts
+interface CreateKnowledgeImprovementActivationExecutorOptions extends Omit<PromoteKnowledgeCandidateOptions, 'root' | 'candidate'> {
+  root: string;
+  identity: string;
+  results: AgentImprovementActivationResultStore;
+}
+interface KnowledgeImprovementActivationExecutor {
+  transition: AgentImprovementActivationTransition;
+  reconcile: AgentImprovementActivationReconciliation;
+}
+/** Apply or restore one local knowledge candidate through the shared activation contract. */
+declare function createKnowledgeImprovementActivationExecutor(options: CreateKnowledgeImprovementActivationExecutorOptions): KnowledgeImprovementActivationExecutor;
+//#endregion
+//#region src/knowledge/supervised-update.d.ts
+/** Standing prompt for a supervisor that grows a shared knowledge base through spawned researchers. */
+declare const RESEARCH_SUPERVISOR_SYSTEM_PROMPT: string;
+interface KnowledgeReadinessCheckInput {
+  root: string;
+  goal: string;
+  readinessSpecs?: readonly unknown[];
+  readinessTaskId?: string;
+  readiness?: unknown;
+}
+type KnowledgeReadinessCheckResult = boolean | {
+  ready: boolean;
+  summary?: string;
+  metadata?: Record<string, unknown>;
+};
+type KnowledgeReadinessCheck = (input: KnowledgeReadinessCheckInput) => Promise<KnowledgeReadinessCheckResult> | KnowledgeReadinessCheckResult;
+interface SupervisedKnowledgeUpdateInput {
+  goal?: string;
+  root?: string;
+  candidateRoot?: string;
+  findings?: readonly unknown[];
+  metadata?: Record<string, unknown>;
+}
+interface SupervisedKnowledgeUpdateResult {
+  applied: boolean;
+  summary: string;
+  supervised: SupervisedResult<unknown>;
+  metadata: NonNullable<RagKnowledgeUpdateResult['metadata']>;
+}
+interface SupervisedKnowledgeUpdateOptions {
+  root: string;
+  goal: string;
+  readiness: KnowledgeReadinessCheck;
+  readinessSpecs?: readonly unknown[];
+  readinessTaskId?: string;
+  readinessOptions?: unknown;
+  findings?: readonly unknown[];
+  metadata?: Record<string, unknown>;
+  budget: Budget;
+  backend?: ExecutorConfig;
+  makeWorkerAgent?: SuperviseOptions['makeWorkerAgent'];
+  /** Caller-owned exact supervisor harness/provider/model identity. */
+  supervisorProfile: SupervisorProfile;
+  superviseOptions?: Partial<Omit<SuperviseOptions, 'budget' | 'backend' | 'deliverable' | 'makeWorkerAgent' | 'allowedModels'>>;
+  allowedModels?: readonly string[];
+  runSupervised?: (profile: SupervisorProfile, task: unknown, opts: SuperviseOptions) => Promise<SupervisedResult<unknown>>;
+}
+type SupervisedKnowledgeUpdater = (input: SupervisedKnowledgeUpdateInput) => Promise<SupervisedKnowledgeUpdateResult>;
+/** Build the completion check a supervised KB update uses to stop only when the KB is ready. */
+declare function knowledgeReadinessDeliverable(options: Pick<SupervisedKnowledgeUpdateOptions, 'root' | 'goal' | 'readiness' | 'readinessSpecs' | 'readinessTaskId' | 'readinessOptions'>): DeliverableSpec<unknown>;
+/** Create an `improveKnowledgeBase` update callback backed by runtime supervision. */
+declare function createSupervisedKnowledgeUpdater(options: SupervisedKnowledgeUpdateOptions): SupervisedKnowledgeUpdater;
+/** Run a runtime supervisor that updates one candidate knowledge base and stops on readiness. */
+declare function runSupervisedKnowledgeUpdate(options: SupervisedKnowledgeUpdateOptions): Promise<SupervisedKnowledgeUpdateResult>;
+/** Format the supervisor task with the KB root, readiness requirements, current findings, and metadata. */
+declare function formatSupervisedKnowledgeTask(options: Pick<SupervisedKnowledgeUpdateOptions, 'root' | 'goal' | 'readinessSpecs' | 'readinessTaskId' | 'findings' | 'metadata'>): string;
+//#endregion
+//#region src/knowledge/improvement-job.d.ts
+interface RunKnowledgeImprovementJobOptions extends Omit<KnowledgeImprovementOptions, 'updateKnowledge'> {
+  budget: Budget;
+  readinessCheck?: KnowledgeReadinessCheck;
+  backend?: ExecutorConfig;
+  makeWorkerAgent?: SuperviseOptions['makeWorkerAgent'];
+  supervisorProfile: SupervisorProfile;
+  superviseOptions?: Partial<Omit<SuperviseOptions, 'budget' | 'backend' | 'deliverable' | 'makeWorkerAgent' | 'allowedModels'>>;
+  allowedModels?: readonly string[];
+  runSupervised?: (profile: SupervisorProfile, task: unknown, opts: SuperviseOptions) => Promise<SupervisedResult<unknown>>;
+  candidateArtifacts?: AgentCandidateOutputArtifactPort;
+  onMeasurement?: (measurement: KnowledgeImprovementJobMeasurement) => Promise<void> | void;
+}
+interface KnowledgeImprovementJobMeasurement {
+  startedAt: string;
+  finishedAt: string;
+  durationMs: number;
+  updateCalls: number;
+  updateDurationMs: number;
+  supervisedSpent: {
+    iterations: number;
+    inputTokens: number;
+    outputTokens: number;
+    usdKnown: boolean;
+    usd: number;
+    ms: number;
+  };
+}
+interface KnowledgeImprovementJobResult {
+  improvement: KnowledgeImprovementResult;
+  knowledge?: KnowledgeImprovementCandidatePair;
+  measurement: KnowledgeImprovementJobMeasurement;
+  blocked: boolean;
+}
+interface KnowledgeImprovementCandidatePair {
+  reference: AgentCandidateKnowledge['candidate'];
+  evaluation: AgentCandidateCapturedArtifact;
+  baseline: AgentCandidateKnowledge['snapshot'];
+  candidate: AgentCandidateKnowledge['snapshot'];
+}
+interface KnowledgeImprovementExperimentBundles {
+  baseline: AgentCandidateBundle;
+  candidate: AgentCandidateBundle;
+}
+interface AgentKnowledgeReadinessCheckOptions {
+  goal: string;
+  readinessSpecs?: readonly KnowledgeReadinessSpec[];
+  readinessTaskId?: string;
+  readiness?: Omit<BuildEvalKnowledgeBundleOptions, 'taskId' | 'index' | 'specs'>;
+  strict?: boolean;
+  kbQuality?: KnowledgeBaseQualityOptions;
+}
+/** Build the default readiness check backed by `@tangle-network/agent-knowledge` validation and scoring. */
+declare function createAgentKnowledgeReadinessCheck(options: AgentKnowledgeReadinessCheckOptions): KnowledgeReadinessCheck;
+/** Produce a frozen KB candidate while leaving live knowledge content unchanged. */
+declare function runKnowledgeImprovementJob(options: RunKnowledgeImprovementJobOptions): Promise<KnowledgeImprovementJobResult>;
+/** Attach both frozen knowledge inputs to one otherwise-identical bundle pair. */
+declare function buildKnowledgeImprovementExperimentBundles(bundle: AgentCandidateBundle, knowledge: KnowledgeImprovementCandidatePair): KnowledgeImprovementExperimentBundles;
+//#endregion
 //#region src/model-resolution.d.ts
 /**
  *
@@ -425,5 +1103,5 @@ declare function readinessServerSentEvent(report: KnowledgeReadinessReport$1, op
 /** Serialize a `RuntimeStreamEvent` as a Server-Sent Event string. @stable */
 declare function runtimeStreamServerSentEvent(event: RuntimeStreamEvent, options?: RuntimeTelemetryOptions & ServerSentEventOptions): string;
 //#endregion
-export { AGENT_CANDIDATE_EXECUTION_SUPPORT, type AgentAdapter, type AgentBackendContext, type AgentBackendInput, 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 AgentCandidateExecutionRoots, 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 AgentCandidateModelGrantRunReservationInput, type AgentCandidateModelGrantSettleInput, type AgentCandidateModelLimits, type AgentCandidateModelPort, type AgentCandidateOutputArtifactPort, type AgentCandidateOutputPurpose, type AgentCandidatePreparationEvidence, type AgentCandidateProfileSource, type AgentCandidateProtectedModelActivation, type AgentCandidateProtectedModelReservation, type AgentCandidateProtectedModelSettlement, type AgentCandidateProtectedModelSettlementCall, 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 AgentSpec, type AgentTaskContext, type AgentTaskRunResult, type AgentTaskSpec, type AgentTaskStatus, type AgenticGeneratorExecutorForWorktree, type AgenticGeneratorOptions, type AgenticGeneratorShotDisposition, type AgenticGeneratorShotExecution, type AgenticGeneratorShotReceipt, type AnalystKind, type AnalystRegistry, type AuthSource, type AuthoredAnalystDefinition, type BackendCallPolicy, type BackendErrorDetail, BackendTransportError, type Budget, 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 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 CoordinationEvent, type CreateAgentCandidateWorkspacePortOptions, type CreateKnowledgeImprovementActivationExecutorOptions, type CreateProfileImprovementHarnessOptions, 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 DescribeWorkspaceTreeOptions, type DisposePreparedAgentCandidateOptions, type Driver, type EvalRunEvent, type EvalRunGeneration, type EvalRunsExportConfig, type EvalRunsExportResult, type ExactProcessCandidateExecutorOptions, type ExecutePreparedAgentCandidateOptions, type Executor, type ExecutorRegistry, FORWARD_HEADERS, FileAgentCandidateExecutionClaimStore, type FileAgentCandidateExecutionClaimStoreOptions, FileConversationJournal, type FinalizeContext, type ForwardHeaderName, type HaltContext, type HaltPredicate, type HaltReason, type HaltSignal, INTELLIGENCE_WIRE_VERSION, type ImproveCandidateValidationInput, type ImproveCandidateValidator, type ImproveCodeBaseOptions, type ImproveCodeOptions, type ImproveCodeResult, type ImproveCodeRunOptions, type ImproveCost, type ImproveCustomCodeGeneratorOptions, type ImproveLineage, type ImproveMethodContext, type ImproveMethodFactory, type ImproveMethodLineage, type ImproveMethodOptions, type ImproveMethodResult, type ImproveMethodSource, type ImproveOptimizationRunOptions, type ImproveOptions, type ImproveProfileAgent, type ImproveProfileComponents, type ImproveProfileSurface, type ImproveResult, type ImproveRuntimeCodeGeneratorOptions, type ImproveScenarioPartitions, type ImproveSkillsOptions, type ImproveSurface, type ImprovementCandidate, type ImprovementCodeCandidate, type ImprovementMaterializedProfilePopulationCandidate, type ImprovementProfileCandidate, type ImprovementProfileCandidatePopulation, type ImprovementProfileCandidatePopulationAvailable, type ImprovementProfileCandidatePopulationUnavailable, type ImprovementProfilePopulationArtifactSource, type ImprovementProfilePopulationCandidate, type ImprovementProfilePopulationCandidateSource, type ImprovementProfilePopulationLineage, type ImprovementProfilePopulationLineageNode, type ImprovementProfilePopulationObservationSource, type ImprovementRefusedProfilePopulationCandidate, 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, type LoopResult, 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, PROMPT_INSTRUCTION_COMPONENT_PREFIX, type PersistedTaskOutcomeEvidence, type PersonaConversationResult, type PersonaDriver, PlannerError, type PrepareAgentCandidateExecutionOptions, type PreparedAgentCandidateExecution, type PreparedAgentCandidateInstruction, type PreparedAgentCandidateKnowledge, type PreparedAgentCandidateLaunch, type PreparedAgentCandidateTrace, type ProfileImprovementHarness, type ProfileImprovementHarnessRunOptions, type PropagatedHeaders, type ProtectedAgentCandidateModelGrantContext, type ProviderModelAttemptEvidence, type ProviderModelExecutionEvidence, RESEARCH_SUPERVISOR_SYSTEM_PROMPT, ROLLOUT_POLICY_EXTENSION, type RawTraceDistillerOptions, type ReadonlyAgentProfile, type RecoverExpiredAgentCandidateOptions, type ReflectiveGeneratorOptions, type ResearchLoopResult, type ResearchLoopRunnerOptions, type ResolvedAgentCandidateContainer, type ResolvedChatModel, RetainedInteractiveAdmissionError, RetainedInteractiveBindingError, RetainedRunAdmissionError, RetainedRunDispatchBindingError, type RetryBackoff, type RetryableErrorPredicate, type RootProviderModelEvidence, type RouterEnv, type RunAgentTaskOptions, type RunAgentTaskStreamOptions, type RunConversationOptions, type RunDelegatedLoopOptions, type RunKnowledgeImprovementJobOptions, type RunPersonaConfig, type RunPersonaConversationOptions, type RunProtectedAgentCandidateModelGrantOptions, type RunProtectedAgentCandidateModelGrantResult, type RunRecord, type RuntimeCanonicalStreamEvent, 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 Scope, type SeedWorkspaceTreeInput, type ServerSentEventOptions, type Settled, type Spend, type SpendChannel, type SpendGap, type SqlAdapter, SqlConversationJournal, type SupervisedKnowledgeUpdateInput, type SupervisedKnowledgeUpdateOptions, type SupervisedKnowledgeUpdateResult, type SupervisedKnowledgeUpdater, type SupervisedResult, type Supervisor, type SupervisorFinalizer, type TokenUsageProvenance, type TurnOrder, ValidationError, type VerifiedAgentCandidate, type VerifiedAgentCandidateTaskOutcome, type Verifier, type VerifyResult, type VetoedFact, type WorkerTraceEvidence, type WorkerTraceUnavailableReason, type WorkspaceScanLimits, type WorkspaceScanOptions, type WorkspaceTreeAlgorithm, type WorkspaceTreeDescriptor, type WorkspaceTreeEntryPolicy, type WorkspaceTreeExclusion, type WorkspaceTreeExclusionReason, type WorktreeCheckRunner, type WorktreeLoopRunnerOptions, agentCandidateProfileAsAgentProfile, agenticGenerator, applyExactAgentProfileDiff, applyRolloutPolicyToProfile, applyRunRecordDefaults, assertCandidateProfileBinding, auditLoopRunner, buildAgentCandidateBundle, buildForwardHeaders, buildKnowledgeImprovementExperimentBundles, buildLoopOtelSpans, buildLoopSpanNodes, buildRuntimeEventOtelSpans, candidateExecutionClaim, candidateKnowledgeExecutionPaths, candidateWorkspaceManifest, captureAgentCandidateWorkspace, captureAgentCandidateWorkspaceFiles, cleanModelId, commandVerifier, composeRuntimeHooks, computeBackoff, createAgentCandidateWorkspacePort, createAgentKnowledgeReadinessCheck, createConversationBackend, createIterableBackend, createKnowledgeImprovementActivationExecutor, createOpenInferenceFileExporter, createOtelExporter, createProfileExecutionBackend, createProfileImprovementHarness, createProtectedAgentCandidateModelPort, createRuntimeEventCollector, createRuntimeStreamEventCollector, createSandboxPromptBackend, createSupervisedKnowledgeUpdater, d1ToSqlAdapter, decideKnowledgeReadiness, defaultBuildPrompt, defaultIsRetryable, defineConversation, defineRuntimeHooks, describeWorkspaceTree, disposePreparedAgentCandidateExecution, exactProcessProviderAsCandidateExecutor, executePreparedAgentCandidate, exportEvalRuns, findingLines, formatSupervisedKnowledgeTask, freezeGenericAgentCandidateProfile, generateSpanId, getModels, improve, isDelegatedLoopMode, isDepthExceeded, knowledgeReadinessDeliverable, loopEventToOtelSpan, makePerAttemptSignal, mcpBuildPrompt, mcpServeVerifier, mcpToolsForRuntimeMcp, mcpToolsForRuntimeMcpSubset, normalizeRolloutPolicy, notifyRuntimeDecisionPoint, notifyRuntimeHookEvent, officialGepa, officialSkillOpt, omitUndefinedObjectFields, optimizerMethod, padSpanId, padTraceId, parseExactAgentProfile, parseExactAgentProfileDiff, parseExactCandidateProfile, parseLoopRunnerArgv, parseRolloutPolicy, persistCandidateOutputArtifact, prepareAgentCandidateExecution, promptInstructionsProfileComponents, rawTraceDistiller, readDepth, readinessServerSentEvent, recoverExpiredAgentCandidateExecution, reflectiveGenerator, researchLoopRunner, resolveChatModel, resolveRouterBaseUrl, runAgentTask, runAgentTaskStream, runConversation, runConversationStream, runDelegatedLoop, runKnowledgeImprovementJob, runLoopRunnerCli, runPersonaConversation, runPersonaDispatch, runProtectedAgentCandidateModelGrant, runSupervisedKnowledgeUpdate, runtimeStreamServerSentEvent, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, scanMaterializedWorkspaceManifest, sealAgentCandidateBundle, seedWorkspaceTree, serializeRolloutPolicy, sleep, slugifySpeaker, startRuntimeRun, strategyAuthorMethod, structuralRolloutPolicyFromProfile, toOtelAttributes, toolBuildPrompt, turnId, validateChatModelId, verifyAgentCandidateBundle, verifyMaterializedWorkspace, worktreeLoopRunner };
+export { type AgentAdapter, type AgentBackendContext, type AgentBackendInput, AgentEvalError, type AgentEvalErrorCode, type AgentExecutionBackend, type AgentKnowledgeProvider, type AgentKnowledgeReadinessCheckOptions, type AgentRuntimeEvent, type AgentRuntimeEventSink, type AgentTaskContext, type AgentTaskRunResult, type AgentTaskSpec, type AgentTaskStatus, type AgenticGeneratorExecutorForWorktree, type AgenticGeneratorOptions, type AgenticGeneratorShotDisposition, type AgenticGeneratorShotExecution, type AgenticGeneratorShotReceipt, type AuthSource, type BackendCallPolicy, type BackendErrorDetail, BackendTransportError, type BuildPromptFindingsInput, type CandidateGenerator, type ChatModelCandidate, type ChatModelValidation, type CircuitBreakerConfig, 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 CreateKnowledgeImprovementActivationExecutorOptions, type CreateProfileImprovementHarnessOptions, type D1DatabaseLike, type D1StmtLike, DEFAULT_ROUTER_BASE_URL, DELEGATED_LOOP_MODES, type DataAcquisitionPlan, type DeepReadonly, type DelegatedLoopMode, type DelegatedLoopRegistry, type DelegatedLoopResult, type DelegatedLoopRunner, type EvalRunEvent, type EvalRunGeneration, type EvalRunsExportConfig, type EvalRunsExportResult, FileConversationJournal, type HaltContext, type HaltPredicate, type HaltReason, type HaltSignal, INTELLIGENCE_WIRE_VERSION, type ImproveCandidateValidationInput, type ImproveCandidateValidator, type ImproveCodeBaseOptions, type ImproveCodeOptions, type ImproveCodeResult, type ImproveCodeRunOptions, type ImproveCost, type ImproveCustomCodeGeneratorOptions, type ImproveLineage, type ImproveMethodContext, type ImproveMethodFactory, type ImproveMethodLineage, type ImproveMethodOptions, type ImproveMethodResult, type ImproveMethodSource, type ImproveOptimizationRunOptions, type ImproveOptions, type ImproveProfileAgent, type ImproveProfileComponents, type ImproveProfileSurface, type ImproveResult, type ImproveRuntimeCodeGeneratorOptions, type ImproveScenarioPartitions, type ImproveSkillsOptions, type ImproveSurface, type ImprovementCandidate, type ImprovementCodeCandidate, type ImprovementMaterializedProfilePopulationCandidate, type ImprovementProfileCandidate, type ImprovementProfileCandidatePopulation, type ImprovementProfileCandidatePopulationAvailable, type ImprovementProfileCandidatePopulationUnavailable, type ImprovementProfilePopulationArtifactSource, type ImprovementProfilePopulationCandidate, type ImprovementProfilePopulationCandidateSource, type ImprovementProfilePopulationLineage, type ImprovementProfilePopulationLineageNode, type ImprovementProfilePopulationObservationSource, type ImprovementRefusedProfilePopulationCandidate, 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, 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, PROMPT_INSTRUCTION_COMPONENT_PREFIX, type PersonaConversationResult, type PersonaDriver, PlannerError, type ProfileImprovementHarness, type ProfileImprovementHarnessRunOptions, RESEARCH_SUPERVISOR_SYSTEM_PROMPT, ROLLOUT_POLICY_EXTENSION, type RawTraceDistillerOptions, type ReadonlyAgentProfile, type ReflectiveGeneratorOptions, type ResearchLoopResult, type ResearchLoopRunnerOptions, type ResolvedChatModel, RetainedInteractiveAdmissionError, RetainedInteractiveBindingError, RetainedRunAdmissionError, RetainedRunDispatchBindingError, type RetryBackoff, type RetryableErrorPredicate, type RouterEnv, type RunAgentTaskOptions, type RunAgentTaskStreamOptions, type RunConversationOptions, type RunDelegatedLoopOptions, type RunKnowledgeImprovementJobOptions, type RunPersonaConfig, type RunPersonaConversationOptions, type RunRecord, type RuntimeCanonicalStreamEvent, 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 SupervisedKnowledgeUpdateInput, type SupervisedKnowledgeUpdateOptions, type SupervisedKnowledgeUpdateResult, type SupervisedKnowledgeUpdater, type TurnOrder, ValidationError, type Verifier, type VerifyResult, type VetoedFact, type WorktreeCheckRunner, type WorktreeLoopRunnerOptions, agenticGenerator, applyRolloutPolicyToProfile, applyRunRecordDefaults, auditLoopRunner, buildKnowledgeImprovementExperimentBundles, buildLoopOtelSpans, buildLoopSpanNodes, buildRuntimeEventOtelSpans, cleanModelId, commandVerifier, composeRuntimeHooks, createAgentKnowledgeReadinessCheck, createConversationBackend, createIterableBackend, createKnowledgeImprovementActivationExecutor, createOpenInferenceFileExporter, createOtelExporter, createProfileExecutionBackend, createProfileImprovementHarness, createRuntimeEventCollector, createRuntimeStreamEventCollector, createSandboxPromptBackend, createSupervisedKnowledgeUpdater, d1ToSqlAdapter, decideKnowledgeReadiness, defaultBuildPrompt, defineConversation, defineRuntimeHooks, exportEvalRuns, findingLines, formatSupervisedKnowledgeTask, generateSpanId, getModels, improve, isDelegatedLoopMode, knowledgeReadinessDeliverable, loopEventToOtelSpan, mcpBuildPrompt, mcpServeVerifier, mcpToolsForRuntimeMcp, mcpToolsForRuntimeMcpSubset, normalizeRolloutPolicy, notifyRuntimeDecisionPoint, notifyRuntimeHookEvent, officialGepa, officialSkillOpt, optimizerMethod, padSpanId, padTraceId, parseLoopRunnerArgv, parseRolloutPolicy, promptInstructionsProfileComponents, rawTraceDistiller, readinessServerSentEvent, reflectiveGenerator, researchLoopRunner, resolveChatModel, resolveRouterBaseUrl, runAgentTask, runAgentTaskStream, runConversation, runConversationStream, runDelegatedLoop, runKnowledgeImprovementJob, runLoopRunnerCli, runPersonaConversation, runPersonaDispatch, runSupervisedKnowledgeUpdate, runtimeStreamServerSentEvent, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, serializeRolloutPolicy, startRuntimeRun, strategyAuthorMethod, structuralRolloutPolicyFromProfile, toOtelAttributes, toolBuildPrompt, validateChatModelId, worktreeLoopRunner };
 //# sourceMappingURL=index.d.ts.map