@tangle-network/agent-knowledge 19.1.5 → 20.0.0

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { A as SourceAnchor, C as KnowledgeUnit, D as ResearchClaimLedger, E as ResearchClaimEvidence, M as SourceRegistry, N as TrackedClaim, O as ResearchClaimRecord, S as KnowledgeSearchResult, T as KnowledgeWriteParseResult, _ as KnowledgePolicy, a as KnowledgeBaseCandidate, b as KnowledgeRelationNode, c as KnowledgeEventType, d as KnowledgeGraphNode, f as KnowledgeId, g as KnowledgePageInvalidation, h as KnowledgePage, i as KNOWLEDGE_EVENT_TYPES, j as SourceRecord, k as ResearchSourceVersion, l as KnowledgeGraph, m as KnowledgeLintFinding, n as DeepQuestion, o as KnowledgeClaim, p as KnowledgeIndex, r as DeepQuestionKind, s as KnowledgeEvent, t as ClaimRef, u as KnowledgeGraphEdge, v as KnowledgeRelation, w as KnowledgeWriteBlock, x as KnowledgeRelease, y as KnowledgeRelationGraph } from "./types-m2QB86fF.js";
-import { $ as RetrievalConfig, A as KnowledgeBenchmarkResponder, At as AgentMemoryScope, B as KnowledgeMemoryEvent, Bt as RetrievalHoldoutSessionState, C as KnowledgeBenchmarkArtifact, Ct as createInMemoryBenchmarkAdapter, D as KnowledgeBenchmarkEvaluation, Dt as AgentMemoryContext, E as KnowledgeBenchmarkDistribution, Et as AgentMemoryBranchIsolation, F as KnowledgeBenchmarkSplit, Ft as RetrievalHoldoutCallContext, G as MemoryAdapterBenchmarkCandidate, H as KnowledgeRetrievalBenchmarkCase, I as KnowledgeBenchmarkTaskKind, It as RetrievalHoldoutConfig, J as RunKnowledgeBenchmarkSuiteResult, K as MemoryAdapterBenchmarkRankingRow, L as KnowledgeClaimMatcher, Lt as RetrievalHoldoutEligibleItem, M as KnowledgeBenchmarkSliceSummary, Mt as AgentMemoryWriteInput, N as KnowledgeBenchmarkSource, Nt as AgentMemoryWriteResult, O as KnowledgeBenchmarkFamily, Ot as AgentMemoryHit, P as KnowledgeBenchmarkSpec, Pt as RetrievalHoldoutBypassReason, Q as PartitionRetrievalScenariosOptions, R as KnowledgeMemoryBenchmarkCase, Rt as RetrievalHoldoutEvent, S as KnowledgeAnswerBenchmarkTaskKind, St as acquireAgentMemoryRunLease, T as KnowledgeBenchmarkCaseBase, Tt as AgentMemoryAdapter, U as KnowledgeRetrievalBenchmarkQrel, V as KnowledgeMemoryFactMatcher, W as KnowledgeRetrievalBenchmarkQuery, X as RunMemoryAdapterBenchmarkResult, Y as RunMemoryAdapterBenchmarkOptions, Z as BuildRetrievalEvalDispatchOptions, _ as buildIndustryRagBenchmarkSmokeCases, _t as scoreRetrievalArtifact, a as runKnowledgeBenchmarkSuite, at as RetrievalGoldTarget, b as BuildRetrievalBenchmarkCasesFromQrelsOptions, bt as AgentMemoryRunLease, c as buildRetrievalBenchmarkCasesFromQrels, ct as RetrievalRecallJudgeOptions, d as summarizeKnowledgeBenchmarkCampaign, dt as RetrievedSourceSpan, et as RetrievalEvalArtifact, f as runMemoryAdapterBenchmark, ft as buildRetrievalEvalDispatch, g as buildIndustryMemoryBenchmarkSmokeCases, gt as retrievalRecallJudge, h as buildFirstPartyMemoryLifecycleBenchmarkCases, ht as retrievalConfigSurface, i as renderKnowledgeBenchmarkReportMarkdown, it as RetrievalEvalScenario, j as KnowledgeBenchmarkScenario, jt as AgentMemorySearchOptions, k as KnowledgeBenchmarkReport, kt as AgentMemoryKind, l as parseKnowledgeBenchmarkJsonl, lt as RetrievalScenarioPartitions, m as INDUSTRY_RAG_BENCHMARKS, mt as retrievalConfigFromSurface, n as buildKnowledgeBenchmarkScenarios, nt as RetrievalEvalRetrieverInput, o as scoreKnowledgeBenchmarkArtifact, ot as RetrievalMetricSummary, p as INDUSTRY_MEMORY_BENCHMARKS, pt as partitionRetrievalScenarios, q as RunKnowledgeBenchmarkSuiteOptions, r as knowledgeBenchmarkJudge, rt as RetrievalEvalRetrieverResult, s as scoreMemoryBenchmarkArtifact, st as RetrievalMetricWeights, t as isKnowledgeMemoryBenchmarkCase, tt as RetrievalEvalRetriever, u as parseKnowledgeBenchmarkQrels, ut as RetrievedKnowledgeHit, v as respondToIndustryMemoryBenchmarkSmokeCase, vt as AgentMemoryAcquireRunLease, w as KnowledgeBenchmarkCase, wt as createNoopMemoryBenchmarkAdapter, x as KnowledgeAnswerBenchmarkCase, xt as OwnedAgentMemoryRunLease, y as respondToIndustryRagBenchmarkSmokeCase, yt as AgentMemoryControllerMode, z as KnowledgeMemoryBenchmarkTaskKind, zt as RetrievalHoldoutResult } from "./index-DZeFm-BP.js";
-import { $ as hindsightMemoryBankId, $t as forkAgentMemoryBranchSnapshot, A as AgentMemoryActivationDriver, At as AgentMemorySequence, B as RetrievalHoldoutOffPolicyResult, Bt as RunAgentMemoryExperimentOptions, C as createMemoryExecutionPool, Ct as AgentMemoryExperimentRunLease, D as sleepForMemoryRecovery, Dt as AgentMemoryLearningCellComparison, E as runBoundedMemoryLifecycle, Et as AgentMemoryLearningCandidateSummary, F as AgentMemoryPromotionDecision, Ft as AgentMemorySequenceStep, G as emitRetrievalHoldoutBypass, Gt as AgentMemoryBranchLifetime, H as applyRetrievalHoldout, Ht as RunAgentMemoryLearningExperimentOptions, I as MemoryConfigScenario, It as AgentMemoryTransferCellComparison, J as toOffPolicyTrajectory, Jt as AgentMemorySharingPolicy, K as resetRetrievalHoldoutRegistry, Kt as AgentMemoryBranchSnapshot, L as RunAgentMemoryImprovementOptions, Lt as AgentMemoryTransferStepSummary, M as AgentMemoryFinalEvaluation, Mt as AgentMemorySequenceProbe, N as AgentMemoryFinalPair, Nt as AgentMemorySequenceProbeResult, O as runAgentMemoryImprovement, Ot as AgentMemoryLearningComparison, P as AgentMemoryImprovementRunLease, Pt as AgentMemorySequenceScenario, Q as createHindsightMemoryAdapter, Qt as createAgentMemoryBranch, R as RunAgentMemoryImprovementResult, Rt as BuildAgentMemorySequencesFromBenchmarkCasesOptions, S as DEFAULT_MEMORY_CLEANUP_TIMEOUT_MS, St as AgentMemoryExperimentRankingRow, T as resolveMemoryCleanupTimeoutMs, Tt as AgentMemoryLearningArmOrder, U as applySessionStickyRetrievalHoldout, Ut as RunAgentMemoryLearningExperimentResult, V as RetrievalHoldoutSessionSummary, Vt as RunAgentMemoryExperimentResult, W as deterministicRng, Wt as AgentMemoryBranch, X as HindsightMemoryAdapterOptions, Xt as CreateAgentMemoryBranchOptions, Y as HindsightClientLike, Yt as AgentMemoryVisibility, Z as HindsightOperationUnknownError, Zt as ForkAgentMemoryBranchSnapshotOptions, _ as Mem0OssMemoryAdapterOptions, _t as AgentMemoryExecutionPaidCallResult, a as memoryWriteResultToSourceRecord, an as SerializedCandidateCodec, at as runAgentMemoryExperiment, b as AgentMemoryLifecycleTimeoutError, bt as AgentMemoryExperimentCandidateRef, c as AgentMemoryScopeSchema, cn as runSerializedKnowledgeOptimization, ct as agentMemorySequenceJudge, d as createNeo4jAgentMemoryAdapter, dt as AgentMemoryAttemptEvent, en as defaultGetMemoryContext, et as GraphitiMcpClientLike, f as Mem0ClientMode, ft as AgentMemoryEvidenceRef, g as Mem0OssClient, gt as AgentMemoryExecutionPaidCallInput, h as Mem0MemoryAdapterOptions, ht as AgentMemoryExecutionCostReceipt, i as memoryHitToSourceRecord, in as SerializedCandidate, it as graphitiMemoryAdapterIdentity, j as AgentMemoryDimensionComparison, jt as AgentMemorySequenceArtifact, k as AgentMemoryActivation, kt as AgentMemoryMode, l as AgentMemoryWriteInputSchema, ln as scenarioContentFingerprint, lt as buildAgentMemorySequenceScenarios, m as Mem0HostedMemoryAdapterOptions, mt as AgentMemoryExecutionCostMeter, n as PlayMemoryRetrievalReceipt, nn as RunSerializedKnowledgeOptimizationOptions, nt as GraphitiToolNames, o as AgentMemoryHitSchema, on as jsonCandidateCodec, ot as compareAgentMemoryLearning, p as Mem0HostedClient, pt as AgentMemoryExecutionContext, q as retrievalHoldoutConfigHash, qt as AgentMemoryJournalEntry, r as createPlayMemoryTools, rn as RunSerializedKnowledgeOptimizationResult, rt as createGraphitiMemoryAdapter, s as AgentMemoryKindSchema, sn as jsonObjectCandidateCodec, st as runAgentMemoryLearningExperiment, t as CreatePlayMemoryToolsOptions, tn as renderMemoryContext, tt as GraphitiMemoryAdapterOptions, u as Neo4jAgentMemoryAdapterOptions, ut as buildAgentMemorySequencesFromBenchmarkCases, v as createMem0MemoryAdapter, vt as AgentMemoryExecutionStep, w as memoryRecoveryDelayMs, wt as AgentMemoryForgettingComparison, x as AgentMemoryLifecycleUnsafeError, xt as AgentMemoryExperimentComparisonRef, y as mem0MemoryAdapterIdentity, yt as AgentMemoryExperimentCandidate, z as RetrievalHoldoutOffPolicyOptions, zt as CompareAgentMemoryLearningOptions } from "./index-Bh9wLd0_.js";
-import { CornellLiiSelector, CornellLiiSourceOptions, FetchOpts, FragmentProvenance, IRS_DIMENSION_HINTS, IrsPublicationsSourceOptions, KnowledgeFragment, KnowledgeSource, MAX_RESPONSE_BYTES, MIN_REQUEST_GAP_MS, POLITE_USER_AGENT, PoliteFetchOptions, PoliteFetchResult, StateSosEntity, StateSosSourceConfig, __resetHttpThrottle, createCornellLiiSource, createIrsPublicationsSource, createStateSosSource, extractLinks, firstMatch, htmlToText, innerHtmlById, looksLikeBlockPage, politeFetch } from "./sources/index.js";
+import { A as SourceRegistry, C as KnowledgeWriteParseResult, D as ResearchSourceVersion, E as ResearchClaimRecord, O as SourceAnchor, S as KnowledgeWriteBlock, T as ResearchClaimLedger, _ as KnowledgePolicy, a as KnowledgeBaseCandidate, b as KnowledgeSearchResult, c as KnowledgeEventType, d as KnowledgeGraphNode, f as KnowledgeId, g as KnowledgePageInvalidation, h as KnowledgePage, i as KNOWLEDGE_EVENT_TYPES, j as TrackedClaim, k as SourceRecord, l as KnowledgeGraph, m as KnowledgeLintFinding, n as DeepQuestion, o as KnowledgeClaim, p as KnowledgeIndex, r as DeepQuestionKind, s as KnowledgeEvent, t as ClaimRef, u as KnowledgeGraphEdge, v as KnowledgeRelation, w as ResearchClaimEvidence, x as KnowledgeUnit, y as KnowledgeRelease } from "./types-BekdNwGD.js";
+import { a as AgentMemoryKind, c as AgentMemoryWriteInput, d as RetrievalHoldoutCallContext, f as RetrievalHoldoutConfig, g as RetrievalHoldoutSessionState, h as RetrievalHoldoutResult, i as AgentMemoryHit, l as AgentMemoryWriteResult, m as RetrievalHoldoutEvent, n as AgentMemoryBranchIsolation, o as AgentMemoryScope, p as RetrievalHoldoutEligibleItem, r as AgentMemoryContext, s as AgentMemorySearchOptions, t as AgentMemoryAdapter, u as RetrievalHoldoutBypassReason } from "./types-BWV_Fvp7.js";
+import { n as createNoopMemoryBenchmarkAdapter, t as createInMemoryBenchmarkAdapter } from "./index-OAxtm6is.js";
+import { $ as AgentMemoryVisibility, A as RetrievalHoldoutSessionSummary, B as HindsightOperationUnknownError, C as createMemoryExecutionPool, D as sleepForMemoryRecovery, E as runBoundedMemoryLifecycle, F as resetRetrievalHoldoutRegistry, G as GraphitiToolNames, H as hindsightMemoryBankId, I as retrievalHoldoutConfigHash, J as AgentMemoryBranch, K as createGraphitiMemoryAdapter, L as toOffPolicyTrajectory, M as applySessionStickyRetrievalHoldout, N as deterministicRng, O as RetrievalHoldoutOffPolicyOptions, P as emitRetrievalHoldoutBypass, Q as AgentMemorySharingPolicy, R as HindsightClientLike, S as DEFAULT_MEMORY_CLEANUP_TIMEOUT_MS, T as resolveMemoryCleanupTimeoutMs, U as GraphitiMcpClientLike, V as createHindsightMemoryAdapter, W as GraphitiMemoryAdapterOptions, X as AgentMemoryBranchSnapshot, Y as AgentMemoryBranchLifetime, Z as AgentMemoryJournalEntry, _ as Mem0OssMemoryAdapterOptions, a as memoryWriteResultToSourceRecord, at as renderMemoryContext, b as AgentMemoryLifecycleTimeoutError, c as AgentMemoryScopeSchema, d as createNeo4jAgentMemoryAdapter, et as CreateAgentMemoryBranchOptions, f as Mem0ClientMode, g as Mem0OssClient, h as Mem0MemoryAdapterOptions, i as memoryHitToSourceRecord, it as defaultGetMemoryContext, j as applyRetrievalHoldout, k as RetrievalHoldoutOffPolicyResult, l as AgentMemoryWriteInputSchema, m as Mem0HostedMemoryAdapterOptions, n as PlayMemoryRetrievalReceipt, nt as createAgentMemoryBranch, o as AgentMemoryHitSchema, p as Mem0HostedClient, q as graphitiMemoryAdapterIdentity, r as createPlayMemoryTools, rt as forkAgentMemoryBranchSnapshot, s as AgentMemoryKindSchema, t as CreatePlayMemoryToolsOptions, tt as ForkAgentMemoryBranchSnapshotOptions, u as Neo4jAgentMemoryAdapterOptions, v as createMem0MemoryAdapter, w as memoryRecoveryDelayMs, x as AgentMemoryLifecycleUnsafeError, y as mem0MemoryAdapterIdentity, z as HindsightMemoryAdapterOptions } from "./index-BhvSH4E4.js";
 import { AgentCandidateJsonValue, AgentCandidateKnowledgeRef, AgentImprovementActivation, AgentImprovementActivationResult, Sha256Digest, ToolDefinition } from "@tangle-network/agent-interface";
 import { AnalystFinding, AnalystSeverity, ControlEvalResult, ControlRuntimeConfig, DataAcquisitionPlan, DatasetScenario, HeldOutGateDecision, KnowledgeAcquisitionMode, KnowledgeBundle, KnowledgeFreshness, KnowledgeImportance, KnowledgeReadinessReport, KnowledgeRequirement, KnowledgeRequirementCategory, KnowledgeSensitivity, ReleaseConfidenceScorecard, ReleaseTraceEvidence, RunRecord, UserQuestion } from "@tangle-network/agent-eval";
 import { z } from "zod";
-import { ComparisonCost, DispatchContext, JudgeConfig, OptimizationMethod, Scenario } from "@tangle-network/agent-eval/campaign";
+import { CompareOptimizationMethodsOptions, ComparisonCost, DispatchContext, JudgeConfig, MutableSurface, OptimizationMethod, OptimizationMethodComparison, OptimizationMethodRunOptions, Scenario } from "@tangle-network/agent-eval/campaign";
 import { EvidenceRef } from "@tangle-network/agent-eval/analyst";
 import { LockOptions } from "proper-lockfile";
 //#region src/adapters.d.ts
@@ -121,450 +121,6 @@ export interface EvalKnowledgeBundleBuildResult {
 }
 export declare function buildEvalKnowledgeBundle(options: BuildEvalKnowledgeBundleOptions): EvalKnowledgeBundleBuildResult;
 //#endregion
-//#region src/sources.d.ts
-export interface AddSourceOptions {
-  copyIntoRaw?: boolean;
-  adapters?: SourceAdapter[];
-  now?: () => Date;
-}
-export interface AddSourceTextInput {
-  uri: string;
-  text: string;
-  title?: string;
-  mediaType?: string;
-  validUntil?: string;
-  lastVerifiedAt?: string;
-  metadata?: Record<string, unknown>;
-}
-/** Copy and freeze an untrusted source proposal before any asynchronous work. */
-export declare function snapshotSourceTextInput(input: AddSourceTextInput): AddSourceTextInput;
-export declare function loadSourceRegistry(root: string): Promise<SourceRegistry>;
-export declare function writeSourceRegistry(root: string, registry: SourceRegistry): Promise<void>;
-export declare function addSourcePath(root: string, sourcePath: string, options?: AddSourceOptions): Promise<SourceRecord[]>;
-export declare function addSourceText(root: string, input: AddSourceTextInput, options?: Pick<AddSourceOptions, 'adapters' | 'now'>): Promise<SourceRecord>;
-export declare function sourceRegistryPath(root: string): string;
-//#endregion
-//#region src/verified-research-loop.d.ts
-/**
- * A knowledge gap the loop surfaces from `scoreKnowledgeReadiness`. The worker
- * targets these; the driver folds the unfilled remainder into the worker's next
- * prompt and runs its own gap-fill pass over them.
- */
-export interface KnowledgeGap {
-  /** Readiness-spec id this gap belongs to. */
-  id: string;
-  /** Human-readable description of what's missing. */
-  description: string;
-  /** The search query the readiness check ran for this requirement. */
-  query: string;
-  /** True when the gap blocks readiness (vs. a soft, non-blocking gap). */
-  blocking: boolean;
-}
-/** A new source the worker (or driver) discovered and wants to add to the KB. */
-export type ResearchSourceProposal = AddSourceTextInput;
-/**
- * What a research agent contributes in one round. Both the worker and (when
- * `driverResearches` is on) the driver produce this shape — the worker ADDS
- * primary findings, the driver gap-FILLS the ones the worker missed.
- *
- * `proposalText` is the safe write-protocol text (`---FILE: knowledge/...---`
- * blocks). The loop only applies it AFTER the driver has verified the round's
- * sources, so a rejected source never reaches the curated pages.
- */
-export interface ResearchContribution {
-  /** Immutable sources to register (the raw evidence). */
-  sources?: ResearchSourceProposal[];
-  /** Safe write-protocol text producing curated `knowledge/*.md` pages. */
-  proposalText?: string;
-  /**
-   * Build the page write-protocol text FROM the sources the driver accepted —
-   * the curated, citing pages the readiness gate searches. Receives the
-   * registered `SourceRecord`s (with their assigned ids, so a page's frontmatter
-   * `sources:` can cite them). Returns `---FILE: knowledge/...---` block text or
-   * `undefined`. Runs after verification, so a page never cites a rejected
-   * source. Concatenated after any static `proposalText`.
-   */
-  buildPages?: (acceptedSources: SourceRecord[]) => string | undefined;
-  /** Free-form research transcript — products can persist this. */
-  notes?: string;
-  metadata?: Record<string, unknown>;
-}
-/** Context handed to the worker each round. */
-export interface WorkerResearchContext {
-  root: string;
-  goal: string;
-  round: number;
-  index: KnowledgeIndex;
-  /** Gaps the readiness gate currently reports — what the worker should close. */
-  gaps: KnowledgeGap[];
-  /** Steer text the driver folded in from the previous round's remaining gaps. */
-  steer?: string;
-  readiness: EvalKnowledgeBundleBuildResult;
-  signal?: AbortSignal;
-}
-/** Context handed to the driver's verifier for one candidate source. */
-export interface SourceVerificationContext {
-  root: string;
-  goal: string;
-  round: number;
-  index: KnowledgeIndex;
-  gaps: KnowledgeGap[];
-  /** Sources already accepted earlier THIS round (in-round dedup). */
-  acceptedThisRound: ResearchSourceProposal[];
-  signal?: AbortSignal;
-}
-/** A single rejected source plus the reason the driver gave. */
-export interface RejectedSource {
-  source: ResearchSourceProposal;
-  reason: string;
-}
-/** Context handed to the driver's gap-fill pass (only when `driverResearches`). */
-export interface DriverResearchContext {
-  root: string;
-  goal: string;
-  round: number;
-  index: KnowledgeIndex;
-  /** Gaps STILL open after the worker's accepted contribution applied. */
-  remainingGaps: KnowledgeGap[];
-  readiness: EvalKnowledgeBundleBuildResult;
-  signal?: AbortSignal;
-}
-/**
- * The differentiated driver role.
- *
- * - `verifySource` — the gate the worker's additions pass before they commit.
- *   Return `{ accept: true }` to keep a source or `{ accept: false, reason }`
- *   to reject it (not real / not relevant / duplicate). The loop dedups exact
- *   duplicates (same `uri` already in the KB or accepted this round) BEFORE
- *   calling this, so the verifier only sees genuinely-new candidates.
- * - `research` — the driver's OWN gap-fill pass over the gaps the worker left
- *   open. Only invoked when `driverResearches` is true.
- * - `foldGaps` — turn the remaining gaps into a steer string for the worker's
- *   next prompt. Defaults to a compact bulleted list when omitted.
- * - `isComplete` — require the driver's research objectives as well as storage readiness.
- * - `checkpoint` — write whatever state the driver accumulated to durable
- *   storage. Called at the end of every round, after `foldGaps`, so state that
- *   a synchronous hook produced is on disk before the next round can crash.
- * - `prepareFold` — durably announce the next synchronous fold before it runs,
- *   so a crash between question generation and `checkpoint` can be recovered.
- * - `commitSources` — confirm exact source records are durable after verification;
- *   drivers with pending evidence must not count it before this callback.
- */
-export interface ResearchDriver {
-  verifySource(source: ResearchSourceProposal, ctx: SourceVerificationContext): Promise<SourceVerdict> | SourceVerdict;
-  research?(ctx: DriverResearchContext): Promise<ResearchContribution> | ResearchContribution;
-  foldGaps?(gaps: KnowledgeGap[]): string;
-  isComplete?(): boolean;
-  prepareFold?(): Promise<void> | void;
-  commitSources?(sources: readonly SourceRecord[]): Promise<void> | void;
-  checkpoint?(): Promise<void> | void;
-}
-export type SourceVerdict = {
-  accept: true;
-} | {
-  accept: false;
-  reason: string;
-};
-/** The worker: primary research targeting the round's gaps. */
-export type ResearchWorker = (ctx: WorkerResearchContext) => Promise<ResearchContribution> | ResearchContribution;
-export interface VerifiedResearchLoopOptions {
-  root: string;
-  goal: string;
-  worker: ResearchWorker;
-  driver: ResearchDriver;
-  /**
-   * When false (default), the driver ONLY verifies + gates — a pure coordinator
-   * that contributes no research of its own (the "doesn't participate in the
-   * work" mode). When true, the driver also runs its `research` gap-fill pass
-   * each round over the gaps the worker left open.
-   */
-  driverResearches?: boolean;
-  maxRounds?: number;
-  actor?: string;
-  /** Readiness specs define the gate; an empty list means the loop never gates. */
-  readinessSpecs?: KnowledgeReadinessSpec[];
-  readinessTaskId?: string;
-  readiness?: Omit<BuildEvalKnowledgeBundleOptions, 'taskId' | 'index' | 'specs'>;
-  sourceOptions?: Pick<AddSourceOptions, 'adapters' | 'now'>;
-  signal?: AbortSignal;
-  onRound?: (round: VerifiedResearchRound) => Promise<void> | void;
-}
-export interface VerifiedResearchRound {
-  round: number;
-  /** Gaps reported at the START of the round (what the worker targeted). */
-  gaps: KnowledgeGap[];
-  /** Worker sources accepted by the driver and written to the KB. */
-  acceptedWorkerSources: SourceRecord[];
-  /** Worker sources the driver rejected (with reasons) — never written. */
-  rejectedWorkerSources: RejectedSource[];
-  /** Sources the driver itself added in its gap-fill pass. */
-  driverSources: SourceRecord[];
-  /** Curated pages written this round (worker proposal + driver proposal). */
-  writtenPages: string[];
-  readiness?: EvalKnowledgeBundleBuildResult;
-  /** True once readiness passes and the driver reports completion, when configured. */
-  ready: boolean;
-  event: KnowledgeEvent;
-  notes: {
-    worker?: string;
-    driver?: string;
-  };
-}
-export interface VerifiedResearchLoopResult {
-  root: string;
-  goal: string;
-  rounds: number;
-  ready: boolean;
-  index: KnowledgeIndex;
-  readiness?: EvalKnowledgeBundleBuildResult;
-  steps: VerifiedResearchRound[];
-}
-/**
- * Two-agent (driver + worker) sibling of `runKnowledgeResearchLoop`.
- *
- * Both agents research to grow ONE knowledge base. The roles are differentiated:
- *
- * - **WORKER** = primary research. Each round it reads the open gaps, discovers
- *   new sources, and proposes additions (`sources` + `proposalText`). It ADDS.
- * - **DRIVER** = the verifier / gap-filler / gate. It (1) VERIFIES the worker's
- *   sources before they commit — dedup against the KB, then `verifySource`
- *   rejects ones that aren't real/relevant; (2) GAP-FILLS the gaps the worker
- *   missed with its own research pass (when `driverResearches`); (3) folds the
- *   remaining gaps into the worker's next prompt; and (4) GATES on
- *   `scoreKnowledgeReadiness` and optional `isComplete` — the loop stops when
- *   readiness passes and the driver has no unfinished research.
- *
- * Set `driverResearches: false` (default) for the pure-coordinator mode: the
- * driver only verifies + gates and contributes no research itself.
- *
- * Composes existing atoms — `initKnowledgeBase`, `addSourceText`,
- * `applyKnowledgeWriteBlocks`, `buildEvalKnowledgeBundle` (the readiness gate),
- * and `searchKnowledge` — and reinvents none of them.
- */
-export declare function runVerifiedResearchLoop(options: VerifiedResearchLoopOptions): Promise<VerifiedResearchLoopResult>;
-/**
- * Helper for verifiers: does the candidate source's text/title overlap any page
- * the readiness search returns for a gap query? A cheap relevance heuristic the
- * driver can compose into `verifySource` (real verifiers can do more).
- */
-export declare function sourceMatchesGaps(source: ResearchSourceProposal, index: KnowledgeIndex, gaps: KnowledgeGap[]): KnowledgeSearchResult[];
-//#endregion
-//#region src/web-research-worker.d.ts
-/** One live web result, as the router's `/v1/search` returns it. */
-export interface WebSearchHit {
-  title: string;
-  url: string;
-  snippet?: string;
-}
-/**
- * The two router capabilities the worker/driver need. Injectable so tests can
- * supply a client; the default uses the published TCloud SDK.
- */
-export interface RouterClient {
-  /** Live web search — returns title/url/snippet hits. */
-  search(query: string, opts?: {
-    maxResults?: number;
-  }): Promise<WebSearchHit[]>;
-  /** Chat completion — returns the assistant message's visible text. */
-  chat(messages: {
-    role: 'system' | 'user';
-    content: string;
-  }[], maxTokens?: number): Promise<string>;
-  /** Cumulative cost (chat + search) since this client was created. */
-  usage(): RouterUsage;
-}
-/**
- * Cumulative router cost — the per-arm signal the A/B reports ALONGSIDE quality,
- * so "2.3 fewer sources" can be read against the token/$/latency it cost. A
- * two-agent round is one worker pass plus N `verifySource` LLM calls; counting
- * each call here is what surfaces that the two-agent loop spends more inference
- * than its "equal passes" budget implies.
- */
-export interface RouterUsage {
-  chatCalls: number;
-  searchCalls: number;
-  promptTokens: number;
-  completionTokens: number;
-  /** Reported cost only. NaN once a successful response omits its cost receipt. */
-  usd: number;
-  wallMs: number;
-}
-export interface TangleRouterOptions {
-  /** Router base URL. Defaults to `https://router.tangle.tools/v1`. */
-  baseUrl?: string;
-  /** Bearer key. Defaults to `process.env.TANGLE_API_KEY`. */
-  apiKey?: string;
-  /** Chat model id. Defaults to `glm-5.2`. */
-  model?: string;
-  /** Optional preferred search provider (exa | you | perplexity | …). */
-  searchProvider?: string;
-  /** SDK retries for 429/502/503/504. Default 4. Kept for API compatibility. */
-  maxRetries?: number;
-  /** Initial SDK retry backoff in ms. Default 1500. */
-  retryBaseMs?: number;
-  signal?: AbortSignal;
-}
-/** Compatibility error facade. HTTP execution and classification belong to TCloud. */
-export declare class RouterError extends Error {
-  readonly status: number;
-  constructor(status: number, message: string);
-}
-/** Adapt Knowledge's public contract to the published SDK, without a second transport. */
-export declare function createTangleRouterClient(options?: TangleRouterOptions): RouterClient;
-export interface WebResearchWorkerOptions {
-  /** Router client. Defaults to a live Tangle router client from env creds. */
-  router?: RouterClient;
-  router_options?: TangleRouterOptions;
-  /** Max search queries the LLM may form per gap. Default 2. */
-  queriesPerGap?: number;
-  /** Max web results fetched per query. Default 3. */
-  resultsPerQuery?: number;
-  /** Hard cap on sources proposed per round (across all gaps). Default 6. */
-  maxSourcesPerRound?: number;
-  /** Disk cache dir for `politeFetch`. Optional; speeds repeat runs. */
-  cacheDir?: string;
-  /** Minimum readable text length to keep a fetched page. Default 200. */
-  minTextChars?: number;
-  /** Max chars of page text stored per source (keeps pages bounded). Default 4000. */
-  maxTextChars?: number;
-}
-/**
- * The real web-research worker. Conforms to the loop's `ResearchWorker`
- * contract: given the open gaps, it returns the sources it found plus a
- * `buildPages` that emits citing pages from the sources the driver accepted.
- */
-export declare function createWebResearchWorker(options?: WebResearchWorkerOptions): ResearchWorker;
-export interface VerifyingDriverOptions {
-  router?: RouterClient;
-  router_options?: TangleRouterOptions;
-  /**
-   * When the LLM verdict can't be parsed, default to REJECT (fail-closed) so a
-   * model hiccup never poisons the KB with an unverified source. Set `true` to
-   * accept-on-parse-failure only if you have a reason to. Default false.
-   */
-  acceptOnParseFailure?: boolean;
-}
-/**
- * The verifying driver: a real LLM pass that judges each candidate source's
- * on-topic relevance to the goal + open gaps and whether it duplicates material
- * already accepted this round. This is the differentiated coordinator role — it
- * GATES the worker's additions; it adds nothing itself.
- *
- * The loop already dedups exact-uri duplicates and only calls this on genuinely
- * new candidates, so the verifier focuses on relevance + near-duplicate
- * judgement, not bookkeeping.
- */
-export declare function createVerifyingResearchDriver(options?: VerifyingDriverOptions): ResearchDriver;
-//#endregion
-//#region src/adaptive-driver.d.ts
-/**
- * Canonicalize a URL for duplicate detection: lowercase host, strip a leading
- * `www.`, drop the scheme, the fragment, a trailing slash, and tracking query
- * params (`utm_*`, `ref`, `fbclid`, `gclid`, …). Two URLs that differ only by
- * those decorations canonicalize to the same key, so the dedup stage treats them
- * as the same source. Falls back to the lowercased raw string when the input is
- * not a parseable absolute URL (so non-http identifiers still dedup by equality).
- */
-export declare function canonicalizeUrl(uri: string): string;
-/**
- * A stable content key for a fetched page: the sha256 of its normalized text
- * (lowercased, punctuation/whitespace collapsed). Two pages whose readable body
- * is the same modulo formatting collide here, so the dedup stage rejects a
- * mirror/syndication of an already-accepted source even when the URL differs.
- */
-export declare function contentKey(text: string): string;
-/** Why the deterministic dedup stage rejected a candidate (for audit/notes). */
-export type DedupReason = 'duplicate-url' | 'duplicate-content';
-/** The cheap-triage classification of a unique survivor. */
-export type TriageClass = 'keep' | 'drop' | 'ambiguous';
-/** One source's adaptive routing decision, for instrumentation and the doc. */
-export interface AdaptiveDecision {
-  uri: string;
-  /** The stage that decided this source: dedup | heuristic | llm. */
-  stage: 'dedup' | 'heuristic' | 'llm';
-  accepted: boolean;
-  /** The triage class assigned (set once past dedup). */
-  triage?: TriageClass;
-  reason?: string;
-}
-/** Running tally of where the adaptive driver spent its decisions. */
-export interface AdaptiveStats {
-  total: number;
-  /** Rejected by deterministic dedup (URL or content). $0. */
-  dedupRejected: number;
-  /** Kept by the cheap heuristic without an LLM call. $0. */
-  heuristicKept: number;
-  /** Dropped by the cheap heuristic without an LLM call. $0. */
-  heuristicDropped: number;
-  /** Escalated to the LLM relevance verifier ($ — the only paid stage). */
-  llmCalls: number;
-  /** Of the escalations, how many the LLM accepted. */
-  llmAccepted: number;
-  decisions: AdaptiveDecision[];
-}
-export interface AdaptiveDriverOptions {
-  /** Router client for the LLM escalation. Defaults to a live client from env. */
-  router?: RouterClient;
-  router_options?: TangleRouterOptions;
-  /** Passed through to the escalation relevance verifier. */
-  verifying?: Pick<VerifyingDriverOptions, 'acceptOnParseFailure'>;
-  /**
-   * Hosts an authoritative source lives on. A unique survivor on one of these,
-   * with a substantial body, is KEPT deterministically (no LLM). Suffix-matched
-   * against the canonical host, so `arxiv.org` matches `export.arxiv.org`. The
-   * defaults cover papers, official docs, and standards bodies.
-   */
-  authoritativeHosts?: string[];
-  /**
-   * Title/snippet patterns that mark obvious spam / listicle / marketing — a
-   * unique survivor matching one is DROPPED deterministically (no LLM).
-   */
-  spamPatterns?: RegExp[];
-  /**
-   * Below this many readable chars a survivor is too thin to be a real reference
-   * and is dropped deterministically. Default 400.
-   */
-  minBodyChars?: number;
-  /**
-   * A survivor whose body is at or above this many chars AND on an authoritative
-   * host is kept without an LLM call. Default 600.
-   */
-  substantialBodyChars?: number;
-  /** Receives each routing decision as it is made (for live instrumentation). */
-  onDecision?: (decision: AdaptiveDecision) => void;
-}
-/**
- * Classify a UNIQUE survivor (already past dedup) with cheap host/title/length
- * signals only — no LLM. Returns `keep`, `drop`, or `ambiguous`. `ambiguous` is
- * the residue the LLM is reserved for: on-topic-looking pages on unknown hosts
- * with a plausible body, which a host/title rule cannot adjudicate.
- */
-export declare function triageSource(source: ResearchSourceProposal, options: {
-  authoritativeHosts: string[];
-  spamPatterns: RegExp[];
-  minBodyChars: number;
-  substantialBodyChars: number;
-}): {
-  triage: TriageClass;
-  reason: string;
-};
-export interface AdaptiveResearchDriver {
-  verifySource(source: ResearchSourceProposal, ctx: SourceVerificationContext): Promise<SourceVerdict>;
-  /** Live tally of where decisions were spent — the cost/quality instrumentation. */
-  stats(): AdaptiveStats;
-}
-/**
- * Build the adaptive verifier. The deterministic stages (dedup + heuristic
- * triage) cost $0; only AMBIGUOUS survivors escalate to the LLM relevance
- * verifier. `stats()` exposes where every decision was spent so the A/B can read
- * the LLM $/calls the adaptive driver saved against the cleanliness it kept.
- *
- * Dedup state is kept on the driver instance: it tracks the canonical URLs and
- * content hashes it has ACCEPTED, plus those it sees in the verification
- * context's `acceptedThisRound` and the KB index. Use one driver per loop run.
- */
-export declare function createAdaptiveResearchDriver(options?: AdaptiveDriverOptions): AdaptiveResearchDriver;
-//#endregion
 //#region src/knowledge-state-scope.d.ts
 /** Authoritative local state included in a KB improvement candidate. */
 interface KnowledgeStateScope {
@@ -578,6 +134,52 @@ export declare function normalizeKnowledgeStateScope(scope?: KnowledgeStateScope
   researchState: boolean;
 };
 //#endregion
+//#region src/optimization.d.ts
+export interface SerializedCandidateCodec<TCandidate extends AgentCandidateJsonValue> {
+  serialize(candidate: TCandidate): string;
+  parse(surface: string): TCandidate;
+}
+export interface SerializedCandidate<TCandidate extends AgentCandidateJsonValue> {
+  value: TCandidate;
+  surface: string;
+  surfaceHash: string;
+}
+type ComparisonOptions<TScenario extends Scenario, TArtifact> = Omit<CompareOptimizationMethodsOptions<TScenario, TArtifact>, 'methods' | 'baselineSurface' | 'trainScenarios' | 'selectionScenarios' | 'testScenarios' | 'dispatchWithSurface' | 'dispatchRef' | 'optimizationRunOptions'>;
+export interface RunSerializedKnowledgeOptimizationOptions<TCandidate extends AgentCandidateJsonValue, TScenario extends Scenario, TArtifact> extends ComparisonOptions<TScenario, TArtifact> {
+  /** Immutable identity for candidate execution, judges, models, indexes, and external settings. */
+  executionRef: string;
+  baseline: TCandidate;
+  method: OptimizationMethod<TScenario, TArtifact>;
+  trainScenarios: readonly TScenario[];
+  selectionScenarios: readonly TScenario[];
+  finalScenarios: readonly TScenario[];
+  dispatchCandidate(input: {
+    candidate: TCandidate;
+    candidateSurface: string;
+    candidateSurfaceHash: string;
+    scenario: TScenario;
+    context: DispatchContext;
+  }): Promise<TArtifact>;
+  codec?: SerializedCandidateCodec<TCandidate>;
+  /** Detects duplicated cases whose IDs differ within or across data partitions. */
+  scenarioFingerprint?: (scenario: TScenario) => string;
+  optimizationRunOptions?: Omit<OptimizationMethodRunOptions<TScenario, TArtifact>, 'dispatchRef'>;
+}
+export interface RunSerializedKnowledgeOptimizationResult<TCandidate extends AgentCandidateJsonValue> {
+  methodName: string;
+  baseline: SerializedCandidate<TCandidate>;
+  winner: SerializedCandidate<TCandidate>;
+  comparison: OptimizationMethodComparison;
+}
+/**
+ * Runs one complete agent-eval method over a serialized knowledge candidate.
+ * The method receives train and selection data; agent-eval owns final scoring.
+ */
+export declare function runSerializedKnowledgeOptimization<TCandidate extends AgentCandidateJsonValue, TScenario extends Scenario, TArtifact>(options: RunSerializedKnowledgeOptimizationOptions<TCandidate, TScenario, TArtifact>): Promise<RunSerializedKnowledgeOptimizationResult<TCandidate>>;
+export declare function jsonCandidateCodec<TCandidate extends AgentCandidateJsonValue>(): SerializedCandidateCodec<TCandidate>;
+export declare function jsonObjectCandidateCodec<TCandidate extends Record<string, AgentCandidateJsonValue>>(): SerializedCandidateCodec<TCandidate>;
+export declare function scenarioContentFingerprint(scenario: Scenario): string;
+//#endregion
 //#region src/rag-optimization.d.ts
 export type RagOptimizationConfig = Record<string, AgentCandidateJsonValue>;
 type RagOptimizationBaseOptions = Omit<RunSerializedKnowledgeOptimizationOptions<RagOptimizationConfig, RagAnswerEvalScenario, RagAnswerEvalArtifact>, 'baseline' | 'method' | 'trainScenarios' | 'selectionScenarios' | 'finalScenarios' | 'dispatchCandidate' | 'judges' | 'codec' | 'scenarioFingerprint'>;
@@ -976,6 +578,29 @@ export interface ApplyKnowledgeWriteBlocksOptions extends KnowledgePagesOptions
 export declare function applyKnowledgeWriteBlocks(root: string, proposalText: string, options?: ApplyKnowledgeWriteBlocksOptions): Promise<ApplyWriteBlocksResult>;
 export declare function applyKnowledgeWriteBlocksFile(root: string, proposalPath: string, options?: ApplyKnowledgeWriteBlocksOptions): Promise<ApplyWriteBlocksResult>;
 //#endregion
+//#region src/sources.d.ts
+export interface AddSourceOptions {
+  copyIntoRaw?: boolean;
+  adapters?: SourceAdapter[];
+  now?: () => Date;
+}
+export interface AddSourceTextInput {
+  uri: string;
+  text: string;
+  title?: string;
+  mediaType?: string;
+  validUntil?: string;
+  lastVerifiedAt?: string;
+  metadata?: Record<string, unknown>;
+}
+/** Copy and freeze an untrusted source proposal before any asynchronous work. */
+export declare function snapshotSourceTextInput(input: AddSourceTextInput): AddSourceTextInput;
+export declare function loadSourceRegistry(root: string): Promise<SourceRegistry>;
+export declare function writeSourceRegistry(root: string, registry: SourceRegistry): Promise<void>;
+export declare function addSourcePath(root: string, sourcePath: string, options?: AddSourceOptions): Promise<SourceRecord[]>;
+export declare function addSourceText(root: string, input: AddSourceTextInput, options?: Pick<AddSourceOptions, 'adapters' | 'now'>): Promise<SourceRecord>;
+export declare function sourceRegistryPath(root: string): string;
+//#endregion
 //#region src/validate.d.ts
 export interface ValidateKnowledgeOptions {
   strict?: boolean;
@@ -1086,6 +711,119 @@ export type KnowledgeControlLoopAdapter = Pick<ControlRuntimeConfig<KnowledgeCon
 export declare function createKnowledgeControlLoopAdapter(options: KnowledgeControlLoopAdapterOptions): KnowledgeControlLoopAdapter;
 export declare function runKnowledgeResearchLoop(options: RunKnowledgeResearchLoopOptions): Promise<KnowledgeResearchLoopResult>;
 //#endregion
+//#region src/retrieval-eval.d.ts
+export type RetrievalConfig = Record<string, AgentCandidateJsonValue>;
+export type RetrievalGoldTarget = {
+  kind: 'page';
+  pageId: string;
+} | {
+  kind: 'page-path';
+  path: string;
+} | {
+  kind: 'source';
+  sourceId: string;
+} | {
+  kind: 'source-anchor';
+  sourceId: string;
+  anchorId: string;
+} | {
+  kind: 'source-span';
+  sourceId: string;
+  charStart: number;
+  charEnd: number;
+};
+export interface RetrievalEvalScenario extends Scenario {
+  kind: 'retrieval-eval';
+  query: string;
+  expected: RetrievalGoldTarget | readonly RetrievalGoldTarget[];
+  k?: number;
+}
+export interface RetrievedSourceSpan {
+  sourceId: string;
+  anchorId?: string;
+  charStart?: number;
+  charEnd?: number;
+}
+export interface RetrievedKnowledgeHit {
+  pageId: string;
+  path: string;
+  title?: string;
+  rank: number;
+  score?: number;
+  normalizedScore?: number;
+  sourceIds?: readonly string[];
+  sourceSpans?: readonly RetrievedSourceSpan[];
+  snippet?: string;
+  metadata?: Record<string, AgentCandidateJsonValue>;
+}
+export interface RetrievalEvalArtifact {
+  config: RetrievalConfig;
+  query: string;
+  requestedK: number;
+  hits: readonly RetrievedKnowledgeHit[];
+  durationMs: number;
+  /** Informational copy. Billable retrievers account through context.cost.runPaidCall. */
+  costUsd?: number;
+  metadata?: Record<string, AgentCandidateJsonValue>;
+}
+export interface RetrievalMetricSummary {
+  recall: number;
+  mrr: number;
+  ndcg: number;
+  precisionAtK: number;
+  expectedCount: number;
+  matchedCount: number;
+  relevantHitCount: number;
+  firstHitRank: number | null;
+  matchedTargetIds: readonly string[];
+}
+export interface RetrievalEvalRetrieverInput {
+  index?: KnowledgeIndex;
+  config: RetrievalConfig;
+  scenario: RetrievalEvalScenario;
+  k: number;
+  signal: AbortSignal;
+  context: DispatchContext;
+}
+export interface RetrievalEvalRetrieverResult {
+  hits: readonly RetrievedKnowledgeHit[];
+  /** Informational copy. Billable retrievers account through context.cost.runPaidCall. */
+  costUsd?: number;
+  metadata?: Record<string, AgentCandidateJsonValue>;
+}
+export type RetrievalEvalRetriever = (input: RetrievalEvalRetrieverInput) => Promise<readonly RetrievedKnowledgeHit[] | RetrievalEvalRetrieverResult>;
+export interface BuildRetrievalEvalDispatchOptions {
+  index?: KnowledgeIndex;
+  defaultK?: number;
+  retrieve?: RetrievalEvalRetriever;
+}
+export interface RetrievalMetricWeights {
+  recall?: number;
+  mrr?: number;
+  ndcg?: number;
+  precisionAtK?: number;
+}
+export interface RetrievalRecallJudgeOptions {
+  name?: string;
+  weights?: RetrievalMetricWeights;
+}
+export interface PartitionRetrievalScenariosOptions {
+  selectionFraction?: number;
+  finalFraction?: number;
+  seed?: number;
+}
+export interface RetrievalScenarioPartitions {
+  trainScenarios: RetrievalEvalScenario[];
+  selectionScenarios: RetrievalEvalScenario[];
+  finalScenarios: RetrievalEvalScenario[];
+}
+export declare function retrievalConfigSurface(config: RetrievalConfig): string;
+export declare function retrievalConfigFromSurface(surface: MutableSurface): RetrievalConfig;
+export declare function buildRetrievalEvalDispatch(options: BuildRetrievalEvalDispatchOptions): (surface: MutableSurface, scenario: RetrievalEvalScenario, context: DispatchContext) => Promise<RetrievalEvalArtifact>;
+export declare function retrievalRecallJudge(options?: RetrievalRecallJudgeOptions): JudgeConfig<RetrievalEvalArtifact, RetrievalEvalScenario>;
+export declare function scoreRetrievalArtifact(artifact: RetrievalEvalArtifact, scenario: RetrievalEvalScenario): RetrievalMetricSummary;
+export declare function partitionRetrievalScenarios(scenarios: readonly RetrievalEvalScenario[], options?: PartitionRetrievalScenariosOptions): RetrievalScenarioPartitions;
+//#endregion
 //#region src/retrieval-optimization.d.ts
 type RetrievalOptimizationBaseOptions = Omit<RunSerializedKnowledgeOptimizationOptions<RetrievalConfig, RetrievalEvalScenario, RetrievalEvalArtifact>, 'baseline' | 'method' | 'trainScenarios' | 'selectionScenarios' | 'finalScenarios' | 'dispatchCandidate' | 'judges' | 'codec' | 'scenarioFingerprint'>;
 export interface RunRetrievalImprovementLoopOptions extends RetrievalOptimizationBaseOptions {
@@ -1377,10 +1115,6 @@ interface KnowledgeBaseQualityReport {
 }
 type MaybePromise<T> = T | Promise<T>;
 //#endregion
-//#region src/rag-eval/calibration.d.ts
-export declare function createRagAnswerQualityHook(options: RagAnswerQualityHookOptions): () => Promise<RagAnswerQualityResult>;
-export declare function calibrateRagAnswerJudge(options: RagCalibrationOptions): Promise<RagCalibrationResult>;
-//#endregion
 //#region src/rag-eval/knowledge-base.d.ts
 export declare function scoreKnowledgeBaseIndex(index: KnowledgeIndex, options?: KnowledgeBaseQualityOptions): KnowledgeBaseQualityReport;
 //#endregion
@@ -1728,119 +1462,9 @@ interface KnowledgeImprovementOptions {
 /** Load the durable result for one exact activation without changing knowledge or run state. */
 export declare function loadKnowledgeImprovementActivationResult(options: LoadKnowledgeImprovementActivationResultOptions): Promise<AgentImprovementActivationResult | null>;
 //#endregion
-//#region src/kb-improvement/optimization.d.ts
-type PolicyCandidateOptions = Omit<KnowledgeImprovementOptions, 'root' | 'goal' | 'implementationRef' | 'runId' | 'maxCandidates' | 'step' | 'knowledgeResearch' | 'updateKnowledge'>;
-type PolicyOptimizationBaseOptions<TPolicy extends AgentCandidateJsonValue, TScenario extends Scenario, TArtifact> = Omit<RunSerializedKnowledgeOptimizationOptions<TPolicy, TScenario, TArtifact>, 'baseline' | 'method' | 'trainScenarios' | 'selectionScenarios' | 'finalScenarios' | 'executionRef'>;
-interface OptimizeKnowledgeBasePolicyOptions<TPolicy extends AgentCandidateJsonValue, TScenario extends Scenario, TArtifact> extends PolicyOptimizationBaseOptions<TPolicy, TScenario, TArtifact> {
-  root: string;
-  goal: string;
-  baselinePolicy: TPolicy;
-  method: OptimizationMethod<TScenario, TArtifact>;
-  trainScenarios: readonly TScenario[];
-  selectionScenarios: readonly TScenario[];
-  finalScenarios: readonly TScenario[];
-  /** Commit or content identity for evaluation, applyPolicy, and external dependencies. */
-  policyApplicationRef: string;
-  /** Optional namespace for parallel materialization of the same measured policy. */
-  candidateRunLabel?: string;
-  candidate?: PolicyCandidateOptions;
-  applyPolicy(input: KnowledgeImprovementUpdateInput & {
-    policy: TPolicy;
-    policySurface: string;
-    policySurfaceHash: string;
-    optimizationMethod: string;
-  }): Promise<{
-    applied: boolean;
-    summary: string;
-    metadata?: Record<string, AgentCandidateJsonValue>;
-  }>;
-}
-interface OptimizeKnowledgeBasePolicyResult<TPolicy extends AgentCandidateJsonValue> {
-  optimization: RunSerializedKnowledgeOptimizationResult<TPolicy>;
-  improvement: KnowledgeImprovementResult;
-}
-/**
- * Optimizes a serialized KB-maintenance policy, then materializes the selected
- * policy in one isolated knowledge candidate. Activation remains explicit.
- */
-export declare function optimizeKnowledgeBasePolicy<TPolicy extends AgentCandidateJsonValue, TScenario extends Scenario, TArtifact>(options: OptimizeKnowledgeBasePolicyOptions<TPolicy, TScenario, TArtifact>): Promise<OptimizeKnowledgeBasePolicyResult<TPolicy>>;
-type KnowledgePolicyDispatch<TPolicy extends AgentCandidateJsonValue, TScenario extends Scenario, TArtifact> = (input: {
-  candidate: TPolicy;
-  candidateSurface: string;
-  candidateSurfaceHash: string;
-  scenario: TScenario;
-  context: DispatchContext;
-}) => Promise<TArtifact>;
-//#endregion
 //#region src/kb-improvement/run.d.ts
 export declare function improveKnowledgeBase(options: KnowledgeImprovementOptions): Promise<KnowledgeImprovementResult>;
 //#endregion
-//#region src/kb-improvement/selected-candidate.d.ts
-declare const measuredSelectionReceiptSchema: z.ZodObject<{
-  kind: z.ZodLiteral<"measured-knowledge-change-selection-receipt">;
-  version: z.ZodLiteral<1>;
-  receiptHash: z.ZodString;
-  selectionDigest: z.ZodString;
-  sourceCandidate: z.ZodObject<{
-    kind: z.ZodLiteral<"knowledge-improvement-candidate">;
-    runId: z.ZodString;
-    candidateId: z.ZodString;
-    goalHash: z.ZodString;
-    baseHash: z.ZodString;
-    candidateHash: z.ZodString;
-    evidenceHash: z.ZodString;
-    promotionPlanHash: z.ZodString;
-  }, z.core.$strict>;
-  sourcePlanHash: z.ZodString;
-  selectedPaths: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
-  derivedImplementationRef: z.ZodString;
-  runId: z.ZodString;
-  derivedCandidateId: z.ZodString;
-  derivedCandidateStatus: z.ZodString;
-  selectedCandidateHash: z.ZodString;
-  selectedPlanHash: z.ZodString;
-  selectedEvidenceHash: z.ZodString;
-  rationale: z.ZodOptional<z.ZodString>;
-  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
-}, z.core.$strict>;
-type KnowledgeEvaluationPhase = Exclude<RagKnowledgeImprovementPhase, 'knowledge-acquisition' | 'knowledge-update'>;
-interface ImproveSelectedKnowledgeCandidateOptions extends Omit<KnowledgeImprovementOptions, 'root' | 'goal' | 'implementationRef' | 'runId' | 'step' | 'knowledgeResearch' | 'acquireKnowledge' | 'updateKnowledge' | 'enabledPhases' | 'requiredPhases'> {
-  root: string;
-  goal: string;
-  /** Identity of the helper, policy, or human procedure choosing the subset. */
-  implementationRef: string;
-  /** Previously measured whole candidate from which the subset is derived. */
-  sourceCandidate: KnowledgeImprovementCandidateRef;
-  /** Exact changed file paths to carry into the derived candidate. */
-  selectedPaths: readonly string[];
-  /** Optional explicit run identity. The default includes the selection digest. */
-  runId?: string;
-  /** Human-readable reason for selecting this subset. */
-  rationale?: string;
-  /** JSON-safe policy output retained in the selection receipt. */
-  selectionMetadata?: Record<string, AgentCandidateJsonValue>;
-  /** Diagnosis and evaluation phases. `knowledge-update` is inserted by this helper. */
-  enabledEvaluationPhases?: readonly KnowledgeEvaluationPhase[];
-  /** Diagnosis and evaluation phases that must complete. `knowledge-update` is always required. */
-  requiredEvaluationPhases?: readonly KnowledgeEvaluationPhase[];
-}
-type MeasuredKnowledgeSelectionReceipt = z.infer<typeof measuredSelectionReceiptSchema>;
-interface ImproveSelectedKnowledgeCandidateResult extends KnowledgeImprovementResult {
-  selection: MeasuredKnowledgeSelectionReceipt;
-}
-/**
- * Derive a subset from an already measured candidate, then measure the subset as
- * a new candidate before it can be promoted.
- *
- * Directly filtering an activation plan is unsafe: a whole candidate can pass
- * while one page subset breaks links, removes supporting sources, or changes a
- * readiness score. This helper instead applies the chosen changed paths to an
- * isolated baseline, recomputes the index, runs the ordinary improvement
- * evaluator, and returns the ordinary candidate reference. Promotion therefore
- * remains one path and can never admit an unmeasured hybrid.
- */
-export declare function improveSelectedKnowledgeCandidate(options: ImproveSelectedKnowledgeCandidateOptions): Promise<ImproveSelectedKnowledgeCandidateResult>;
-//#endregion
 //#region src/kb-improvement/state.d.ts
 export declare function knowledgeImprovementRunId(root: string, goal: string): string;
 export declare function knowledgeImprovementRunDir(root: string, runId: string): string;
@@ -1895,91 +1519,6 @@ export declare function toAgentCandidateKnowledgeRef(candidate: KnowledgeImprove
 /** Recover agent-knowledge's candidate identity from the shared contract. */
 export declare function fromAgentCandidateKnowledgeRef(candidate: AgentCandidateKnowledgeRef): KnowledgeImprovementCandidateRef;
 //#endregion
-//#region src/changes.d.ts
-/**
- * Change detection across snapshots of one source's fragments.
- *
- * The output drives the continuous-ingestion loop: each `KnowledgeChange`
- * carries the eval dimensions affected (`affectedDimensions`), which an
- * agent-eval campaign scheduler consumes to decide which campaigns to
- * re-run. Three change kinds:
- *
- *   - `added` — fragment id appears in `next` but not `prev`.
- *   - `removed` — fragment id appears in `prev` but not `next`. Typical
- *     trigger: an authority retires a Wex slug, or a state SOS reorganises
- *     its forms catalogue.
- *   - `modified` — fragment id appears in both, body hash differs. This
- *     is the dominant change kind in practice — the Ryan-LLC v. FTC
- *     vacatur case manifests as a `modified` on the Wex non-compete
- *     fragment, NOT as a removed one.
- *
- * Unverifiable fragments are filtered out before diffing — comparing a
- * captcha-blocked snapshot against a real one would falsely fire every
- * fragment as removed. The caller can inspect the raw lists if they want
- * to surface block-page failures.
- *
- * Within-snapshot duplicate ids are an upstream bug; this function picks
- * the LAST one and emits a diagnostic via the `warnings` field.
- *
- * @stable
- */
-export type KnowledgeChangeKind = 'added' | 'removed' | 'modified';
-export interface KnowledgeChange {
-  /** Source-scoped id (matches `KnowledgeFragment.id`). */
-  fragmentId: string;
-  kind: KnowledgeChangeKind;
-  /**
-   * For `added`: full body of the new fragment.
-   * For `removed`: full body of the prior fragment.
-   * For `modified`: unified-diff-style payload `{ before, after }` body strings.
-   */
-  diff?: {
-    before?: string;
-    after?: string;
-  };
-  /**
-   * Eval dimensions to re-score. Computed as the union of both fragments'
-   * `dimensionHints`. The eval cron treats this as a set of campaign tags.
-   */
-  affectedDimensions: string[];
-  /** URL of the affected authority page (from whichever side has it). */
-  url?: string;
-  /**
-   * Source-attested change time. For `modified`, takes the NEXT fragment's
-   * `sourceUpdatedAt`. For `removed`, takes the PRIOR fragment's
-   * `sourceUpdatedAt`. For `added`, takes the NEXT fragment's
-   * `sourceUpdatedAt`. Consumers index changes by this date.
-   */
-  detectedAt: string;
-}
-export interface DetectChangesResult {
-  changes: KnowledgeChange[];
-  /** Counts by kind — handy for dashboards. */
-  summary: {
-    added: number;
-    removed: number;
-    modified: number;
-  };
-  /** Non-fatal diagnostics (duplicate ids, dropped unverifiable fragments). */
-  warnings: string[];
-}
-export interface DetectChangesOptions {
-  /**
-   * When true (default), unverifiable fragments are dropped from both
-   * sides before comparison. Set false ONLY when debugging block-page
-   * issues — comparing against unverifiable content emits false
-   * `removed`/`modified` changes.
-   */
-  skipUnverifiable?: boolean;
-  /**
-   * When provided, only changes whose `affectedDimensions` intersect this
-   * set are returned. Useful for cron loops that schedule per-dimension
-   * eval campaigns and only care about a subset.
-   */
-  filterDimensions?: string[];
-}
-export declare function detectChanges(prev: KnowledgeFragment[], next: KnowledgeFragment[], options?: DetectChangesOptions): DetectChangesResult;
-//#endregion
 //#region src/chunking.d.ts
 export interface ChunkingOptions {
   targetChars: number;
@@ -2001,12 +1540,6 @@ export declare function stripFrontmatter(content: string): {
   bodyOffset: number;
 };
 //#endregion
-//#region src/citation-lint.d.ts
-/** Convert a chain-aware citation audit into the package lint vocabulary. */
-export declare function knowledgeCitationAuditFindings(report: KnowledgeCitationAuditReport): KnowledgeLintFinding[];
-/** Lint only current-run pages against their complete declared visibility chain. */
-export declare function lintCurrentRunCitations(stores: RunScopedStores, runId: string): Promise<KnowledgeLintFinding[]>;
-//#endregion
 //#region src/claim-evidence.d.ts
 /**
  * The evidence contract for claims that machines, not authors, get to grade.
@@ -2229,15 +1762,11 @@ export declare function verifyGradeableEvidence(evidence: ClaimEvidence, options
 //#endregion
 //#region src/claim-grounding.d.ts
 /**
- * Metadata key under which a proposal carries the specific claim it is cited
- * for. The worker sets `metadata[citedClaimKey] = '<the claim>'`; the
- * claim-grounding driver reads it and checks it against the fetched page text.
+ * Deterministic claim grounding: is a claim present in a text?
+ *
+ * The check is text presence, not a model call. RAG answer scoring uses it to
+ * test whether a generated claim is supported by the retrieved context.
  */
-export declare const citedClaimKey = "citedClaim";
-/** Read the cited claim a proposal carries, if any. */
-export declare function citedClaimOf(source: ResearchSourceProposal): string | undefined;
-/** Attach a cited claim to a proposal (immutably returns a new proposal). */
-export declare function withCitedClaim(source: ResearchSourceProposal, claim: string): ResearchSourceProposal;
 export interface GroundingResult {
   /** True when the claim is sufficiently present in the page text. */
   grounded: boolean;
@@ -2266,8 +1795,7 @@ export interface GroundClaimOptions {
   minWordLength?: number;
 }
 /**
- * THE ORACLE. Is `claim` grounded in `pageText` (the `htmlToText` output of the
- * page the worker fetched)? Deterministic, no model call:
+ * Is `claim` grounded in `pageText`? Deterministic, no model call:
  *
  *   1. verbatim — the claim string appears as-is (case-insensitive).
  *   2. normalized — the claim appears after collapsing punctuation/whitespace
@@ -2276,58 +1804,10 @@ export interface GroundClaimOptions {
  *      substantive content words appear in the page text. A misattributed page
  *      fails here because the SPECIFIC words the claim asserts are absent.
  *
- * Returns the match mode, the measured overlap, and the missing content words —
- * enough for the driver to give a precise rejection reason and for a test/doc to
- * audit WHY a claim grounded or didn't.
+ * Returns the match mode, the measured overlap, and the missing content words,
+ * so a caller can state why a claim grounded or did not.
  */
 export declare function groundClaimInText(claim: string, pageText: string, options?: GroundClaimOptions): GroundingResult;
-export interface ClaimGroundingDriverOptions extends GroundClaimOptions {
-  /**
-   * Optional second verifier to compose AFTER grounding passes. When set, a
-   * source must BOTH ground its claim AND pass this verifier (e.g. the LLM
-   * relevance driver's `verifySource`). Lets the loop reject off-topic AND
-   * misattributed sources in one driver. Omit for the pure, zero-inference
-   * grounding gate.
-   */
-  relevanceVerifier?: (source: ResearchSourceProposal, ctx: SourceVerificationContext) => Promise<SourceVerdict> | SourceVerdict;
-  /**
-   * What to do when a proposal carries NO cited claim. `'reject'` (default) is
-   * fail-closed: in claim-grounding mode every source must declare what it is
-   * cited for, so an un-annotated source is treated as ungrounded. `'accept'`
-   * lets unannotated sources through to the relevance verifier, if present.
-   */
-  onMissingClaim?: 'reject' | 'accept';
-}
-/**
- * A `ResearchDriver`-shaped verifier (just the `verifySource` arm) that gates on
- * CLAIM GROUNDING: it rejects a source whose cited claim is not present in its
- * fetched page text — a misattributed / fabricated citation — and (optionally)
- * composes a relevance verifier after grounding passes.
- *
- * The returned function matches `ResearchDriver['verifySource']`, so it drops
- * straight into `runVerifiedResearchLoop` as `{ verifySource: createClaimGroundingVerifier(...) }`.
- */
-export declare function createClaimGroundingVerifier(options?: ClaimGroundingDriverOptions): (source: ResearchSourceProposal, ctx: SourceVerificationContext) => Promise<SourceVerdict>;
-export interface WorkerClaimDecorationOptions {
-  router?: RouterClient;
-  router_options?: TangleRouterOptions;
-  /** Max output tokens for the claim-extraction call. Default 1200 (glm floor). */
-  maxTokens?: number;
-}
-/**
- * Ask an LLM to state, for one source, the single specific factual claim a
- * researcher would cite THIS page for toward the goal. Used to DECORATE the
- * sources a relevance-only worker produced with the claim a citation would make,
- * so the claim-grounding verifier has something executable to check. The model
- * is told to ground the claim in the provided excerpt; the verifier then checks
- * it against the FULL page text independently — the model does not get to mark
- * its own homework.
- *
- * Returns the proposal annotated via `withCitedClaim`, or the original proposal
- * unchanged if the model returns nothing parseable (the verifier's
- * `onMissingClaim` policy then decides).
- */
-export declare function createClaimDecorator(options?: WorkerClaimDecorationOptions): (source: ResearchSourceProposal, goal: string) => Promise<ResearchSourceProposal>;
 //#endregion
 //#region src/claim-ledger.d.ts
 /**
@@ -2418,9 +1898,8 @@ export declare function mergeClaimLedgers(base: ResearchClaimLedger, incoming: R
  * of it: the worker that found the refuting source records "X contradicts Y" and
  * knows nothing about Y's record. Left one-sided, Y reads as an uncontested
  * claim, and the completion oracle would settle a question two sources disagree
- * about. `createResearchDrivingDriver` does this pairwise as it records; this is
- * the same rule stated over a whole ledger, for writers that assemble one from
- * events rather than from a live loop.
+ * about. This rule applies over a whole ledger, for writers that assemble one
+ * from events.
  *
  * One-sided observations stay in `claimEvidence` until both claims are backed
  * by registered source versions. The materialized claim projection contains
@@ -2429,14 +1908,6 @@ export declare function mergeClaimLedgers(base: ResearchClaimLedger, incoming: R
  */
 export declare function linkClaimContradictions(ledger: ResearchClaimLedger): ResearchClaimLedger;
 //#endregion
-//#region src/collection-research-driver.d.ts
-/**
- * Build the single-agent collection driver. Accepts every source; never gates,
- * never researches, never steers beyond the loop's default open-gap list. The
- * worker is the only agent that thinks.
- */
-export declare function createCollectionResearchDriver(): ResearchDriver;
-//#endregion
 //#region src/discovery.d.ts
 export interface DiscoveryTask {
   id: string;
@@ -2634,108 +2105,6 @@ export declare class FileSystemSearchProvider {
 }
 export declare function createFileSystemSearchProvider(options: FileSystemSearchProviderOptions): FileSystemSearchProvider;
 //#endregion
-//#region src/freshness.d.ts
-/**
- * Knowledge freshness store: tracks when each `(workspaceId, sourceId)` pair
- * was last successfully refreshed, and reports staleness against a TTL.
- *
- * The contract is intentionally minimal and supports scheduled refresh loops:
- *
- *   ```ts
- *   const store = createFileSystemFreshnessStore({ root: '.agent-knowledge' })
- *   for (const source of sources) {
- *     if (await store.stale({ workspaceId, sourceId: source.id, ttlMs: DAY })) {
- *       const fragments = await source.fetch({ cacheDir })
- *       await persistFragments(fragments)
- *       await store.mark({ workspaceId, sourceId: source.id, when: new Date() })
- *     }
- *   }
- *   ```
- *
- * Per-tenant isolation is enforced by `workspaceId` keying. There is no
- * global mutable state across workspaces.
- *
- * Two adapters ship in-package:
- *
- *   - `createFileSystemFreshnessStore`: JSON file under the knowledge root,
- *     mirrors the layout convention already used by `sources.json`.
- *   - `createD1FreshnessStoreStub`: complete bridge from the `D1Adapter` port
- *     to this package's freshness interface. The port can be backed by D1,
- *     PostgreSQL, SQLite, or another application-owned store.
- */
-/** Identity for one freshness record. */
-export interface FreshnessKey {
-  workspaceId: string;
-  sourceId: string;
-}
-/** TTL bound for staleness checks. */
-export interface FreshnessTtl extends FreshnessKey {
-  /** Milliseconds; the record is stale when `Date.now() - last() > ttlMs`. */
-  ttlMs: number;
-  /** Injected clock for deterministic tests; defaults to system time. */
-  now?: Date;
-}
-/** Mark argument. */
-export interface FreshnessMark extends FreshnessKey {
-  when: Date;
-  /** Optional content hash captured at refresh time; aids debugging. */
-  contentHash?: string;
-}
-export interface KnowledgeFreshnessStore {
-  /** Last refresh time, or null if never refreshed. */
-  last(key: FreshnessKey): Promise<Date | null>;
-  /** Record a successful refresh. */
-  mark(input: FreshnessMark): Promise<void>;
-  /** True iff `last(key)` is null or older than `ttlMs`. */
-  stale(input: FreshnessTtl): Promise<boolean>;
-  /** All records for a workspace. */
-  list(workspaceId: string): Promise<FreshnessRecord[]>;
-}
-export interface FreshnessRecord {
-  workspaceId: string;
-  sourceId: string;
-  lastRefreshedAt: string;
-  contentHash?: string;
-}
-export interface FileSystemFreshnessStoreOptions {
-  /**
-   * Knowledge root. The store writes to `<root>/.agent-knowledge/freshness.json`,
-   * mirroring the convention used by `sources.json`.
-   */
-  root: string;
-}
-/**
- * Filesystem-backed implementation. Single JSON file per knowledge root,
- * indexed by `${workspaceId}::${sourceId}`. Reads parse on every call;
- * cron tick rate is well below the cost of one JSON parse.
- *
- * Writes share the package-wide filesystem lock, so multiple workers cannot
- * overwrite one another or run through an interrupted knowledge promotion.
- */
-export declare function createFileSystemFreshnessStore(options: FileSystemFreshnessStoreOptions): KnowledgeFreshnessStore;
-/**
- * Bridge an application-owned database adapter to `KnowledgeFreshnessStore`.
- * The adapter may use D1, PostgreSQL, SQLite, or another durable store.
- *
- * The expected schema:
- *
- * ```sql
- * CREATE TABLE knowledge_freshness (
- *   workspace_id     TEXT NOT NULL,
- *   source_id        TEXT NOT NULL,
- *   last_refreshed_at TEXT NOT NULL,
- *   content_hash     TEXT,
- *   PRIMARY KEY (workspace_id, source_id)
- * );
- * ```
- */
-export interface D1Adapter {
-  get(workspaceId: string, sourceId: string): Promise<FreshnessRecord | null>;
-  upsert(record: FreshnessRecord): Promise<void>;
-  listByWorkspace(workspaceId: string): Promise<FreshnessRecord[]>;
-}
-export declare function createD1FreshnessStoreStub(adapter: D1Adapter): KnowledgeFreshnessStore;
-//#endregion
 //#region src/frontmatter.d.ts
 export interface ParsedFrontmatter {
   frontmatter: Record<string, unknown>;
@@ -2838,250 +2207,6 @@ export interface KnowledgeExplanation {
 }
 export declare function explainKnowledgeTarget(index: KnowledgeIndex, target: string): KnowledgeExplanation;
 //#endregion
-//#region src/invalidation-propagation.d.ts
-/** Frontmatter field naming the cited pages whose evidence refuted them. */
-export declare const CITES_INVALIDATED_FIELD = "citesInvalidated";
-export interface KnowledgeInvalidationStamp {
-  readonly page: KnowledgePage;
-  /** The value the field must hold, sorted and deduplicated. Empty removes the field. */
-  readonly citesInvalidated: readonly KnowledgeId[];
-  /** The value the page holds now, in the order it is stored. */
-  readonly current: readonly KnowledgeId[];
-}
-export interface KnowledgeInvalidationPlan {
-  /** Every visible page carrying an invalidation, sorted by id. */
-  readonly invalidatedPageIds: readonly KnowledgeId[];
-  /** Only the pages whose stamp differs from what they hold, in path order. */
-  readonly stamps: readonly KnowledgeInvalidationStamp[];
-}
-/**
- * Plan the `citesInvalidated` stamp for every page authored in the target
- * store.
- *
- * Citations resolve over the whole chain, so a page here may be stamped for
- * citing a refuted inherited or shared page. Only `here` pages are stamped: a
- * run does not write the stores it inherits or shares.
- */
-export declare function planInvalidationPropagation(visiblePages: readonly OriginatedPage[]): KnowledgeInvalidationPlan;
-/**
- * Render one plan as a write-block proposal for `applyKnowledgeWriteBlocks`.
- *
- * Only the stamped field changes. The page is rendered through
- * `formatFrontmatter`, so its frontmatter is written in that writer's
- * normalized form.
- */
-export declare function formatKnowledgeInvalidationProposal(plan: KnowledgeInvalidationPlan): string;
-//#endregion
-//#region src/investment-thesis-set.d.ts
-/**
- * HELD-OUT INVESTMENT-RESEARCH EVAL SET.
- *
- * The point of this file is the same FIREWALL the deep-question exam uses
- * (`tests/loops/held-out-exam.ts`): the material facts and their checkable
- * fragments are NEVER shown to a research loop. A loop is told only the company
- * + ticker + a research-as-of CUTOFF date, and asked to write an investment
- * thesis. AFTER it finishes, we grade the thesis it produced against THESE
- * facts — facts it never saw — so a high score is thesis QUALITY (it surfaced
- * the buried, material, non-obvious drivers) and not teaching-to-the-test.
- *
- * Each fact is a DEPTH fact by construction: a single ticker / company-name web
- * search does NOT surface it. They are the things buried in the filings or
- * knowable from then-available primary sources that a thorough analyst flags and
- * a one-shot search misses — customer/revenue/deposit concentration, a debt
- * maturity wall, a margin-trend reversal, a governance / related-party item, a
- * specific competitive or regulatory risk, an off-balance-sheet loss.
- *
- * THREE HARD RULES, enforced by how the data was gathered (see
- * docs/eval/investment-material-facts.md for the per-item provenance + the
- * curation-bias disclosure):
- *
- *   1. SPECIFIC + CHECKABLE. Each fact carries `expected` keyword groups — the
- *      specific number / name / phrase — so a deterministic, model-free
- *      substring grader (`gradeFactAgainstText`) can score "did the thesis
- *      surface it". $0, reproducible, and it cannot leak the answer key into a
- *      model the loop could observe.
- *
- *   2. DERIVED FROM REAL FETCHED EVIDENCE. Every fact records the primary source
- *      it came from (`sourceUrl`, an SEC EDGAR 10-K) and the literal `evidence`
- *      value read out of that document. Nothing here is invented; an item that
- *      could not be independently sourced was DROPPED, not guessed (the drop log
- *      is in the doc).
- *
- *   3. KNOWABLE AT THE CUTOFF. Every fact was disclosed in, or computable from, a
- *      document available on or before the company's `cutoff` date. Post-cutoff
- *      hindsight (the eventual bankruptcy / collapse) is NOT a checklist item —
- *      it is recorded separately as `knownOutcome`, purely for the reader, and is
- *      never graded.
- *
- * Grading mirrors the deep-question exam exactly: a fact is SURFACED when the
- * thesis text contains at least `minGroups` of its expected groups; a group is
- * satisfied when ANY of its `anyOf` fragments appears (case-insensitive
- * substring), so a faithful thesis phrased in its own words still grades as a
- * hit. `anyOf` groups model synonyms; the load-bearing tokens are the specific
- * numbers / names.
- */
-/** A required answer component: satisfied when any synonym fragment is present. */
-export interface ExpectedGroup {
-  /** Human label for the component (for the doc / audit). */
-  label: string;
-  /** Case-insensitive substring fragments; any one present satisfies the group. */
-  anyOf: string[];
-}
-/** Lens the fact belongs to — so a set can be checked for category coverage. */
-export type MaterialFactLens = 'concentration' | 'leverage' | 'margin-trend' | 'liquidity' | 'capital-return' | 'governance' | 'off-balance-sheet' | 'regulatory';
-/** One held-out material fact with a checkable expected answer + its provenance. */
-export interface MaterialFact {
-  /** Stable id, `ticker/fN`. */
-  id: string;
-  /** Which analyst lens this fact exercises. For coverage + the doc. */
-  lens: MaterialFactLens;
-  /**
-   * The material fact, in plain words — for the doc/audit. NEVER shown to a loop.
-   * This is the thing a thorough analyst would flag and a ticker search misses.
-   */
-  fact: string;
-  /**
-   * The checkable answer as required keyword GROUPS. The thesis text must contain
-   * at least `minGroups` of these groups (default: all). A group is satisfied
-   * when ANY of its `anyOf` fragments appears (case-insensitive substring).
-   */
-  expected: ExpectedGroup[];
-  /**
-   * Minimum number of `expected` groups the thesis must contain to count the
-   * fact SURFACED. Default = all groups (the strict bar). Lowered (and documented
-   * inline) only when the fact is genuinely satisfiable by a subset.
-   */
-  minGroups?: number;
-  /**
-   * PROVENANCE. The primary source URL this fact was read from — an SEC EDGAR
-   * 10-K primary document, fetched live during curation.
-   */
-  sourceUrl: string;
-  /**
-   * The literal value / phrase read out of `sourceUrl` that grounds the fact.
-   * This is the "cite the actual filing + the value" requirement — verbatim or
-   * near-verbatim from the filing, with the figure.
-   */
-  evidence: string;
-}
-/** A company + the cutoff a loop researches as-of + its held-out material facts. */
-export interface CompanyEvalCase {
-  /** Ticker as of the cutoff. */
-  ticker: string;
-  /** Legal name as of the cutoff (what the loop is told to research). */
-  company: string;
-  /** SEC Central Index Key (CIK), zero-stripped — the EDGAR filer id. */
-  cik: string;
-  /**
-   * Research-as-of date (ISO). The loop must reason as if it is this date; every
-   * `evidence` value was knowable on or before it. >= 18 months before this set
-   * was curated, so the outcome is known but is NOT a checklist item.
-   */
-  cutoff: string;
-  /** Sector, for coverage / the curation-bias disclosure. */
-  sector: string;
-  /**
-   * The known POST-cutoff outcome — recorded for the reader ONLY, never graded.
-   * Keeping it out of `facts` is what makes the set hindsight-free.
-   */
-  knownOutcome: string;
-  /** The held-out material facts for this company. */
-  facts: MaterialFact[];
-}
-/**
- * The eval set. 5 public companies, 5-8 held-out material facts each, every fact
- * grounded in a primary SEC EDGAR 10-K filed on or before the cutoff.
- *
- * CURATION-BIAS DISCLOSURE (full version in the doc): all five are companies
- * whose buried risks later materialized, because that is where the material-vs-
- * surface distinction is sharpest AND where the figures are easy to verify after
- * the fact. This biases the set toward downside risks (two of the eight lenses,
- * concentration + leverage, dominate) and toward distressed names. A production
- * eval would balance these with companies whose buried facts were POSITIVE
- * drivers and with survivors. This set is honest about that and reports the lens
- * distribution so the bias is measurable, not hidden.
- */
-export declare const investmentThesisSet: CompanyEvalCase[];
-/**
- * Grade ONE material fact against an investment thesis's full text. Returns
- * whether the thesis SURFACED it plus which expected groups were found. The
- * check is a deterministic case-insensitive substring scan — $0, model-free,
- * reproducible — so the eval never leaks into a model the loop could observe.
- */
-export declare function gradeFactAgainstText(fact: MaterialFact, thesisText: string): {
-  surfaced: boolean;
-  groupsFound: number;
-  groupsTotal: number;
-  foundLabels: string[];
-};
-/** Grade a whole company's thesis text: how many of its held-out facts it surfaces. */
-export declare function gradeCompanyAgainstText(company: CompanyEvalCase, thesisText: string): {
-  surfaced: number;
-  total: number;
-  perFact: ReturnType<typeof gradeFactAgainstText>[];
-};
-/** Total held-out facts across the set (the denominator the doc reports). */
-export declare function totalMaterialFacts(set?: CompanyEvalCase[]): number;
-/** Count facts per lens across the set — used to report (and bound) curation bias. */
-export declare function lensDistribution(set?: CompanyEvalCase[]): Record<MaterialFactLens, number>;
-//#endregion
-//#region src/investment-thesis-task.d.ts
-/** The minimal brief a thesis run is given — the firewall boundary. */
-export interface ThesisTaskInput {
-  /** Legal name as of the cutoff — what the loop researches. */
-  company: string;
-  /** Ticker as of the cutoff. */
-  ticker: string;
-  /** SEC Central Index Key (CIK), zero-stripped — the EDGAR filer id. */
-  cik: string;
-  /** Research-as-of date (ISO). The loop must reason as if it is this date. */
-  cutoff: string;
-  /** Sector, for the readiness query context (NOT a checklist hint). */
-  sector?: string;
-}
-/**
- * The generic analyst-lens readiness specs every company gets. They are the ONLY
- * thing the loop is told about WHAT to look for, and they name the LENSES a
- * thorough analyst checks (balance-sheet risk, concentration, leverage, margins,
- * liquidity, governance, regulatory) and where they live (the latest SEC 10-K) —
- * NOT the answers. They steer the worker's web/EDGAR search toward the filing,
- * not toward the held-out facts (which the loop never sees).
- *
- * `minSources` is set above 1 so the readiness gate stays UNMET after a single
- * fetch and the loop runs multiple rounds — the depth-driving driver needs >1
- * round to steer, exactly as the ML-exam multi-round probe established.
- */
-export declare function thesisReadinessSpecs(input: ThesisTaskInput): KnowledgeReadinessSpec[];
-export interface ThesisRunOptions {
-  /** The KB root the loop writes into. */
-  root: string;
-  /** Shared router client (web search + chat). Defaults to env creds. */
-  router: RouterClient;
-  /** The driver — verify/dedup or research-driving. The loop's coordinator. */
-  driver: ResearchDriver;
-  /** Round budget. Default 3 (the depth-driving driver needs >1). */
-  maxRounds?: number;
-  /** Worker tuning forwarded to `createWebResearchWorker`. */
-  workerOptions?: Omit<WebResearchWorkerOptions, 'router'>;
-  /** Max tokens for the synthesis pass. Default 1600 (above glm-5.2's reasoning floor). */
-  synthesisMaxTokens?: number;
-  signal?: AbortSignal;
-}
-export interface ThesisRunResult {
-  loop: VerifiedResearchLoopResult;
-  /** The synthesized thesis text. */
-  thesis: string;
-  /** Path of the thesis page written into the KB. */
-  thesisPath: string;
-}
-/**
- * Run the full thesis task: drive the two-agent loop to research the company AS
- * OF the cutoff, then synthesize + write the thesis page. Returns the loop result
- * + the thesis text + the page path. The caller grades the KB with
- * `materialFactsSurfaced(root, checklist)` — the checklist is never passed here.
- */
-export declare function runInvestmentThesisTask(input: ThesisTaskInput, options: ThesisRunOptions): Promise<ThesisRunResult>;
-//#endregion
 //#region src/kb-store.d.ts
 /**
  * Where a filesystem knowledge base keeps its machine-written records, relative
@@ -3670,56 +2795,6 @@ export declare function createKnowledgeTools(options: CreateKnowledgeToolsOption
 //#region src/lint.d.ts
 export declare function lintKnowledgeIndex(index: KnowledgeIndex): KnowledgeLintFinding[];
 //#endregion
-//#region src/material-facts-metric.d.ts
-/** Per-fact grade plus the fact's id/lens, for the audit trail. */
-export interface FactResult {
-  id: string;
-  lens: CompanyEvalCase['facts'][number]['lens'];
-  surfaced: boolean;
-  groupsFound: number;
-  groupsTotal: number;
-  foundLabels: string[];
-}
-/** The metric's result for one company: the surfaced fraction + the per-fact trail. */
-export interface MaterialFactsResult {
-  ticker: string;
-  company: string;
-  /** Held-out facts the KB surfaced + grounded. */
-  surfaced: number;
-  /** Total held-out facts for this company (the denominator). */
-  total: number;
-  /** `surfaced / total` in [0, 1]. */
-  fraction: number;
-  /** Per-fact grade, in checklist order, for the doc / audit. */
-  perFact: FactResult[];
-}
-/**
- * Join a KB index into the single text blob the grader scans: every curated PAGE
- * (title + body) followed by every raw SOURCE (title + fetched text). This is the
- * text read AFTER the loop finished — it is never handed to the loop. Identical
- * in spirit to `kbText` in the research-quality A/B so both metrics read a KB the
- * same way.
- */
-export declare function kbIndexToText(index: KnowledgeIndex): string;
-/**
- * Grade one company's KB against its held-out material-fact checklist, given the
- * KB's already-joined text. The pure core — no I/O — so calibration can score a
- * hand-written shallow/deep thesis string directly and the live path can score a
- * real KB. Returns the surfaced FRACTION plus the per-fact audit trail.
- */
-export declare function materialFactsSurfacedInText(company: CompanyEvalCase, kbText: string): MaterialFactsResult;
-/**
- * `materialFactsSurfaced(kb, checklist)` — the metric in its KB-reading form.
- *
- * `kb` is EITHER a knowledge-base root directory (the loop wrote pages there) or
- * an already-built `KnowledgeIndex`. `checklist` is the company's held-out
- * `CompanyEvalCase`. Returns the surfaced fraction + per-fact trail.
- *
- * The checklist is HELD OUT by construction: it lives in the test eval set, is
- * never passed to the loop, and is read only here, after the loop finished.
- */
-export declare function materialFactsSurfaced(kb: string | KnowledgeIndex, checklist: CompanyEvalCase): Promise<MaterialFactsResult>;
-//#endregion
 //#region src/mutation-lock.d.ts
 interface KnowledgeMutationLock {
   readonly transactionRoot: string;
@@ -4045,71 +3120,6 @@ export interface KnowledgeBaseReadinessEvaluation {
 }
 export declare function evaluateKnowledgeBaseReadiness(options: EvaluateKnowledgeBaseReadinessOptions): Promise<KnowledgeBaseReadinessEvaluation>;
 //#endregion
-//#region src/relation-graph.d.ts
-export type KnowledgeRelationGraphErrorCode = 'invalid-node' | 'duplicate-node' | 'invalid-relation' | 'duplicate-relation' | 'undeclared-endpoint' | 'unknown-node' | 'invalid-query';
-/** A relation graph input or query that cannot be honored exactly. */
-export declare class KnowledgeRelationGraphError extends Error {
-  readonly code: KnowledgeRelationGraphErrorCode;
-  constructor(code: KnowledgeRelationGraphErrorCode, message: string);
-}
-export interface BuildKnowledgeRelationGraphInput {
-  /**
-   * Declared node inventory. When present, every relation endpoint must name
-   * one declared node; an undeclared endpoint is refused rather than added.
-   * When absent, the graph carries edges only and `nodes` is empty.
-   */
-  nodes?: readonly KnowledgeRelationNode[];
-  relations: readonly KnowledgeRelation[];
-}
-/**
- * `out` follows `sourceId -> targetId`, `in` follows `targetId -> sourceId`,
- * `both` follows a relation from either end.
- */
-export type KnowledgeRelationDirection = 'out' | 'in' | 'both';
-export interface KnowledgeRelationQuery {
-  /** Restrict to relations with this predicate. Every predicate when absent. */
-  predicate?: string;
-  direction: KnowledgeRelationDirection;
-}
-export interface KnowledgeRelationWalkOptions extends KnowledgeRelationQuery {
-  /** Most relations between the start node and a reported node. Unbounded when absent. */
-  maxDepth?: number;
-}
-export interface KnowledgeRelationNeighbor {
-  nodeId: KnowledgeId;
-  relation: KnowledgeRelation;
-}
-export interface KnowledgeRelationWalkStep {
-  nodeId: KnowledgeId;
-  /** Number of relations between the start node and this node. */
-  depth: number;
-  /** The node the search came from when it first reached this node. */
-  from: KnowledgeId;
-  relation: KnowledgeRelation;
-}
-/**
- * Build a labeled multi-edge graph from caller relations.
- *
- * The graph keeps one edge per `(sourceId, targetId, predicate)`, in first-seen
- * order. A repeated triple is accepted only when its weight and metadata are
- * identical in canonical JSON; any other repeat is a conflict and is refused.
- * Node and relation metadata must be finite, acyclic JSON so the graph
- * round-trips through `KnowledgeRelationGraphSchema` unchanged.
- */
-export declare function buildKnowledgeRelationGraph(input: BuildKnowledgeRelationGraphInput): KnowledgeRelationGraph;
-/** Relations touching `id`, each with the node at the other end, in graph order. */
-export declare function neighbors(graph: KnowledgeRelationGraph, id: KnowledgeId, query: KnowledgeRelationQuery): KnowledgeRelationNeighbor[];
-/**
- * Breadth-first traversal from `id` over matching relations. Each reachable
- * node is reported once, at the depth where the search first reached it; the
- * start node is never reported, so a cycle back to it adds no step.
- */
-export declare function walk(graph: KnowledgeRelationGraph, id: KnowledgeId, options: KnowledgeRelationWalkOptions): KnowledgeRelationWalkStep[];
-/**
- * Whether `to` is `from` or lies on a path of matching relations out of `from`.
- */
-export declare function isReachable(graph: KnowledgeRelationGraph, from: KnowledgeId, to: KnowledgeId, query: KnowledgeRelationQuery): boolean;
-//#endregion
 //#region src/release.d.ts
 export interface KnowledgeReleaseReport {
   release: KnowledgeRelease;
@@ -4142,130 +3152,6 @@ export interface KnowledgeReleaseInput {
 }
 export declare function knowledgeReleaseReport(input: KnowledgeReleaseInput): KnowledgeReleaseReport;
 //#endregion
-//#region src/research-driving-driver.d.ts
-/** The driver's accumulated research state — the completion oracle reads this. */
-export interface ResearchDrivingState {
-  /** Every extracted claim backed by a registered source, by id. */
-  claims: TrackedClaim[];
-  /** Every deep sub-question raised, by id. */
-  questions: DeepQuestion[];
-  /** Claims with exactly one independent source AND not contested. */
-  weaklySupported: TrackedClaim[];
-  /** Claims supported by >= 2 independent sources. */
-  corroborated: TrackedClaim[];
-  /** Claims marked contested (a surfaced, unresolved contradiction). */
-  contested: TrackedClaim[];
-  /** Deep questions still unaddressed. */
-  openQuestions: DeepQuestion[];
-  /** How many rounds the driver has folded steer for. */
-  rounds: number;
-}
-export interface ResearchDrivingDriverOptions {
-  /** Router client for claim extraction + deep-question generation. */
-  router?: RouterClient;
-  router_options?: TangleRouterOptions;
-  /**
-   * A claim is CORROBORATED at this many INDEPENDENT supporting sources (distinct
-   * canonical hosts). Default 2 — the task's ">= 2 independent sources" bar.
-   */
-  minIndependentSources?: number;
-  /** Max deep sub-questions to fold into one round's steer. Default 6. */
-  maxQuestionsPerRound?: number;
-  /** Max claims to extract from a single source. Default 3. */
-  maxClaimsPerSource?: number;
-  /**
-   * When the extractor LLM is unavailable, fall back to a deterministic claim
-   * pull (the source's leading sentences) so the driver still drives. Default
-   * true. Set false to require the model (claims will be empty without it).
-   */
-  deterministicFallback?: boolean;
-  /** Observe each round's generated steer (for instrumentation / the script). */
-  onSteer?: (steer: ResearchDrivingSteer) => void;
-}
-/**
- * Options for the durable driver: the same driver plus a store to keep its
- * belief state in.
- */
-export interface PersistentResearchDrivingDriverOptions extends ResearchDrivingDriverOptions {
-  /** Where the claim ledger is read from and written to. */
-  store: ClaimLedgerStore;
-  /**
-   * Names this run's ledger. Stable across resumes (that is what makes a resume
-   * a resume) and distinct per run against one knowledge base. Must be a single
-   * safe path segment — see `assertClaimLedgerId`.
-   */
-  ledgerId: string;
-}
-/** What the driver folded into one round's worker prompt, surfaced for audit. */
-export interface ResearchDrivingSteer {
-  round: number;
-  deepQuestions: DeepQuestion[];
-  /** Claims it demanded corroborating/refuting evidence for this round. */
-  invalidationTargets: TrackedClaim[];
-  /** The readiness gaps it interleaved (passed through from the loop). */
-  gaps: KnowledgeGap[];
-  /** The full steer text handed to the worker. */
-  text: string;
-}
-/**
- * The research-driving driver. It is a `ResearchDriver` (drops straight into
- * `runVerifiedResearchLoop`) PLUS a completion oracle and live state, mirroring
- * how `createAdaptiveResearchDriver` exposes `stats()`.
- */
-export interface ResearchDrivingDriver extends ResearchDriver {
-  /** Live snapshot of the claim ledger + deep questions. */
-  researchState(): ResearchDrivingState;
-  /**
-   * The completion oracle — gate `done` on THIS, not on source count. True when
-   * every deep sub-question is addressed AND every claim is corroborated
-   * (>= `minIndependentSources` independent sources) or explicitly contested.
-   * False while any claim is weakly-supported or any deep question is open.
-   * Returns false before any claim has been seen (nothing researched yet).
-   */
-  isComplete(): boolean;
-  /**
-   * The last round's generated steer, or undefined before the first fold. Useful
-   * to assert the driver produced deeper questions / invalidation challenges.
-   */
-  lastSteer(): ResearchDrivingSteer | undefined;
-  /**
-   * Write the current belief state to the store. `verifySource` already persists
-   * each pending observation; this exists for the state `foldGaps` produces —
-   * the deep questions — which is raised by a synchronous hook and would
-   * otherwise be lost if the process died before the next source arrived.
-   *
-   * `runVerifiedResearchLoop` calls this at the end of every round. A driver
-   * built without a store has nothing to write and resolves immediately.
-   */
-  checkpoint(): Promise<void>;
-  /** Durably announce the next synchronous fold before it begins. */
-  prepareFold(): Promise<void>;
-  /**
-   * Confirm exact registered source records.
-   * URI equality alone is insufficient: pending evidence is authorized only
-   * when its expected content hash matches the registered record.
-   */
-  commitSources(sources: readonly SourceRecord[]): Promise<void>;
-  /** The ledger record as it would be written right now. */
-  toLedger(): ResearchClaimLedger;
-}
-/**
- * The in-memory driver. Its belief state lives for exactly as long as the
- * process does — use `createPersistentResearchDrivingDriver` when the run must
- * survive a crash or resume.
- */
-export declare function createResearchDrivingDriver(options?: ResearchDrivingDriverOptions): ResearchDrivingDriver;
-/**
- * The durable driver: same behaviour, plus its claim ledger is read from the
- * store at construction and written back after every claim and every round.
- *
- * Construction is asynchronous because loading is I/O, and loading has to happen
- * before the caller can read `researchState()` or `isComplete()` — a driver that
- * loaded lazily would answer "nothing researched, not complete" for a run that
- * had already corroborated everything.
- */
-export declare function createPersistentResearchDrivingDriver(options: PersistentResearchDrivingDriverOptions): Promise<ResearchDrivingDriver>;
-//#endregion
 //#region src/schemas.d.ts
 export declare const SourceAnchorSchema: z.ZodObject<{
   id: z.ZodString;
@@ -4353,27 +3239,6 @@ export declare const KnowledgeRelationSchema: z.ZodObject<{
   weight: z.ZodOptional<z.ZodNumber>;
   metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
-export declare const KnowledgeRelationNodeSchema: z.ZodObject<{
-  id: z.ZodString;
-  kind: z.ZodString;
-  label: z.ZodOptional<z.ZodString>;
-  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strip>;
-export declare const KnowledgeRelationGraphSchema: z.ZodObject<{
-  nodes: z.ZodArray<z.ZodObject<{
-    id: z.ZodString;
-    kind: z.ZodString;
-    label: z.ZodOptional<z.ZodString>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-  }, z.core.$strip>>;
-  edges: z.ZodArray<z.ZodObject<{
-    sourceId: z.ZodString;
-    targetId: z.ZodString;
-    predicate: z.ZodString;
-    weight: z.ZodOptional<z.ZodNumber>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-  }, z.core.$strip>>;
-}, z.core.$strip>;
 export declare const KnowledgeIndexSchema: z.ZodObject<{
   root: z.ZodString;
   generatedAt: z.ZodString;
@@ -4589,5 +3454,5 @@ export declare function normalizeLinkTarget(target: string): string;
 export declare function isSafeKnowledgePath(path: string, allowedPrefixes?: string[]): boolean;
 export declare function parseKnowledgeWriteBlocks(text: string, allowedPrefixes?: string[]): KnowledgeWriteParseResult;
 //#endregion
-export { AgentMemoryAcquireRunLease, type AgentMemoryActivation, type AgentMemoryActivationDriver, AgentMemoryAdapter, type AgentMemoryAttemptEvent, AgentMemoryBranch, AgentMemoryBranchIsolation, AgentMemoryBranchLifetime, AgentMemoryBranchSnapshot, AgentMemoryContext, AgentMemoryControllerMode, type AgentMemoryDimensionComparison, type AgentMemoryEvidenceRef, type AgentMemoryExecutionContext, type AgentMemoryExecutionCostMeter, type AgentMemoryExecutionCostReceipt, type AgentMemoryExecutionPaidCallInput, type AgentMemoryExecutionPaidCallResult, type AgentMemoryExecutionStep, type AgentMemoryExperimentCandidate, type AgentMemoryExperimentCandidateRef, type AgentMemoryExperimentComparisonRef, type AgentMemoryExperimentRankingRow, type AgentMemoryExperimentRunLease, type AgentMemoryFinalEvaluation, type AgentMemoryFinalPair, type AgentMemoryForgettingComparison, AgentMemoryHit, AgentMemoryHitSchema, type AgentMemoryImprovementRunLease, AgentMemoryJournalEntry, AgentMemoryKind, AgentMemoryKindSchema, type AgentMemoryLearningArmOrder, type AgentMemoryLearningCandidateSummary, type AgentMemoryLearningCellComparison, type AgentMemoryLearningComparison, AgentMemoryLifecycleTimeoutError, AgentMemoryLifecycleUnsafeError, type AgentMemoryMode, type AgentMemoryPromotionDecision, AgentMemoryRunLease, AgentMemoryScope, AgentMemoryScopeSchema, AgentMemorySearchOptions, type AgentMemorySequence, type AgentMemorySequenceArtifact, type AgentMemorySequenceProbe, type AgentMemorySequenceProbeResult, type AgentMemorySequenceScenario, type AgentMemorySequenceStep, AgentMemorySharingPolicy, type AgentMemoryTransferCellComparison, type AgentMemoryTransferStepSummary, AgentMemoryVisibility, AgentMemoryWriteInput, AgentMemoryWriteInputSchema, AgentMemoryWriteResult, type BuildAgentMemorySequencesFromBenchmarkCasesOptions, type BuildRetrievalBenchmarkCasesFromQrelsOptions, BuildRetrievalEvalDispatchOptions, ClaimRef, type CompareAgentMemoryLearningOptions, CornellLiiSelector, CornellLiiSourceOptions, CreateAgentMemoryBranchOptions, CreatePlayMemoryToolsOptions, DEFAULT_MEMORY_CLEANUP_TIMEOUT_MS, DeepQuestion, DeepQuestionKind, type ExternalRagEvalScore, FetchOpts, ForkAgentMemoryBranchSnapshotOptions, FragmentProvenance, GraphitiMcpClientLike, GraphitiMemoryAdapterOptions, GraphitiToolNames, HindsightClientLike, HindsightMemoryAdapterOptions, HindsightOperationUnknownError, INDUSTRY_MEMORY_BENCHMARKS, INDUSTRY_RAG_BENCHMARKS, IRS_DIMENSION_HINTS, type ImproveSelectedKnowledgeCandidateOptions, type ImproveSelectedKnowledgeCandidateResult, IrsPublicationsSourceOptions, KNOWLEDGE_EVENT_TYPES, type KnowledgeAnswerBenchmarkCase, type KnowledgeAnswerBenchmarkTaskKind, KnowledgeBaseCandidate, type KnowledgeBaseQualityOptions, type KnowledgeBaseQualityReport, type KnowledgeBenchmarkArtifact, type KnowledgeBenchmarkCase, type KnowledgeBenchmarkCaseBase, type KnowledgeBenchmarkDistribution, type KnowledgeBenchmarkEvaluation, type KnowledgeBenchmarkFamily, type KnowledgeBenchmarkReport, type KnowledgeBenchmarkResponder, type KnowledgeBenchmarkScenario, type KnowledgeBenchmarkSliceSummary, type KnowledgeBenchmarkSource, type KnowledgeBenchmarkSpec, type KnowledgeBenchmarkSplit, type KnowledgeBenchmarkTaskKind, type KnowledgeBrief, type KnowledgeBriefOptions, KnowledgeClaim, type KnowledgeClaimMatcher, type KnowledgeEvaluationPhase, KnowledgeEvent, KnowledgeEventType, KnowledgeFragment, KnowledgeGraph, KnowledgeGraphEdge, KnowledgeGraphNode, KnowledgeId, type KnowledgeImprovementActivationPersistence, type KnowledgeImprovementCandidateRecord, type KnowledgeImprovementCandidateRef, type KnowledgeImprovementEvaluationInput, type KnowledgeImprovementEvaluator, type KnowledgeImprovementEvent, type KnowledgeImprovementEvidence, type KnowledgeImprovementMetric, type KnowledgeImprovementMetricProvenance, type KnowledgeImprovementMutationReceipt, type KnowledgeImprovementMutationResult, type KnowledgeImprovementOptions, type KnowledgeImprovementRagOptimizationOptions, type KnowledgeImprovementRagOptimizationRunInput, type KnowledgeImprovementResult, type KnowledgeImprovementRetrievalOptions, type KnowledgeImprovementRunState, type KnowledgeImprovementStatus, type KnowledgeImprovementTarget, type KnowledgeImprovementUpdate, type KnowledgeImprovementUpdateInput, KnowledgeIndex, KnowledgeLintFinding, type KnowledgeMemoryBenchmarkCase, type KnowledgeMemoryBenchmarkTaskKind, type KnowledgeMemoryEvent, type KnowledgeMemoryFactMatcher, type KnowledgeMutationHold, type KnowledgeMutationLock, type KnowledgeMutationOptions, KnowledgePage, KnowledgePageInvalidation, KnowledgePolicy, type KnowledgePolicyDispatch, type KnowledgeReadOptions, KnowledgeRelation, KnowledgeRelationGraph, KnowledgeRelationNode, KnowledgeRelease, type KnowledgeRetrievalBenchmarkCase, type KnowledgeRetrievalBenchmarkQrel, type KnowledgeRetrievalBenchmarkQuery, KnowledgeSearchResult, KnowledgeSource, type KnowledgeStateScope, KnowledgeUnit, KnowledgeWriteBlock, KnowledgeWriteParseResult, type LoadKnowledgeImprovementActivationResultOptions, MAX_RESPONSE_BYTES, MIN_REQUEST_GAP_MS, type MeasuredKnowledgeSelectionReceipt, Mem0ClientMode, Mem0HostedClient, Mem0HostedMemoryAdapterOptions, Mem0MemoryAdapterOptions, Mem0OssClient, Mem0OssMemoryAdapterOptions, type MemoryAdapterBenchmarkCandidate, type MemoryAdapterBenchmarkRankingRow, type MemoryConfigScenario, type NearDuplicateDetectionOptions, type NearDuplicatePair, type NearDuplicateReport, Neo4jAgentMemoryAdapterOptions, type OptimizeKnowledgeBasePolicyOptions, type OptimizeKnowledgeBasePolicyResult, type OriginatedPage, OwnedAgentMemoryRunLease, POLITE_USER_AGENT, type PageOrigin, PartitionRetrievalScenariosOptions, type PendingKnowledgeMutation, PlayMemoryRetrievalReceipt, PoliteFetchOptions, PoliteFetchResult, type PromoteKnowledgeCandidateOptions, type RagAnswerEvalArtifact, type RagAnswerEvalCase, type RagAnswerEvalScenario, type RagAnswerMetricSummary, type RagAnswerQualityHookOptions, type RagAnswerQualityJudgeOptions, type RagCalibrationOptions, type RagCalibrationResult, type RagEvalCitation, type RagEvalClaim, type RagEvalContext, type RagEvalMetricKey, type RagEvalProvider, type RagEvalSlice, type RagRequiredContext, type RecoverPendingKnowledgeMutationOptions, type RegularFileSnapshot, ResearchClaimEvidence, ResearchClaimLedger, ResearchClaimRecord, ResearchSourceVersion, type ResolvedKnowledgeImprovementCandidate, type ResolvedKnowledgeImprovementComparison, type ResolvedKnowledgeImprovementComparisonSnapshot, type RestoreKnowledgeCandidateBaselineOptions, RetrievalConfig, RetrievalEvalArtifact, RetrievalEvalRetriever, RetrievalEvalRetrieverInput, RetrievalEvalRetrieverResult, RetrievalEvalScenario, RetrievalGoldTarget, RetrievalHoldoutBypassReason, RetrievalHoldoutCallContext, RetrievalHoldoutConfig, RetrievalHoldoutEligibleItem, RetrievalHoldoutEvent, RetrievalHoldoutOffPolicyOptions, RetrievalHoldoutOffPolicyResult, RetrievalHoldoutResult, RetrievalHoldoutSessionState, RetrievalHoldoutSessionSummary, RetrievalMetricSummary, RetrievalMetricWeights, RetrievalRecallJudgeOptions, RetrievalScenarioPartitions, RetrievedKnowledgeHit, RetrievedSourceSpan, type RunAgentMemoryExperimentOptions, type RunAgentMemoryExperimentResult, type RunAgentMemoryImprovementOptions, type RunAgentMemoryImprovementResult, type RunAgentMemoryLearningExperimentOptions, type RunAgentMemoryLearningExperimentResult, type RunKnowledgeBenchmarkSuiteOptions, type RunKnowledgeBenchmarkSuiteResult, type RunLineageAuthority, type RunLineageRecord, type RunMemoryAdapterBenchmarkOptions, type RunMemoryAdapterBenchmarkResult, type RunScopedStores, type RunScopedStoresOptions, RunSerializedKnowledgeOptimizationOptions, RunSerializedKnowledgeOptimizationResult, SerializedCandidate, SerializedCandidateCodec, SourceAnchor, SourceRecord, SourceRegistry, StateSosEntity, StateSosSourceConfig, TrackedClaim, type UseKnowledgeImprovementCandidateOptions, __resetHttpThrottle, acquireAgentMemoryRunLease, agentMemorySequenceJudge, applyRetrievalHoldout, applySessionStickyRetrievalHoldout, buildAgentMemorySequenceScenarios, buildAgentMemorySequencesFromBenchmarkCases, buildFirstPartyMemoryLifecycleBenchmarkCases, buildIndustryMemoryBenchmarkSmokeCases, buildIndustryRagBenchmarkSmokeCases, buildKnowledgeBenchmarkScenarios, buildRetrievalBenchmarkCasesFromQrels, buildRetrievalEvalDispatch, compareAgentMemoryLearning, createAgentMemoryBranch, createCornellLiiSource, createGraphitiMemoryAdapter, createHindsightMemoryAdapter, createInMemoryBenchmarkAdapter, createIrsPublicationsSource, createMem0MemoryAdapter, createMemoryExecutionPool, createNeo4jAgentMemoryAdapter, createNoopMemoryBenchmarkAdapter, createPlayMemoryTools, createStateSosSource, defaultGetMemoryContext, deterministicRng, emitRetrievalHoldoutBypass, extractLinks, firstMatch, forkAgentMemoryBranchSnapshot, graphitiMemoryAdapterIdentity, hindsightMemoryBankId, htmlToText, innerHtmlById, isKnowledgeMemoryBenchmarkCase, jsonCandidateCodec, jsonObjectCandidateCodec, knowledgeBenchmarkJudge, looksLikeBlockPage, mem0MemoryAdapterIdentity, memoryHitToSourceRecord, memoryRecoveryDelayMs, memoryWriteResultToSourceRecord, parseKnowledgeBenchmarkJsonl, parseKnowledgeBenchmarkQrels, partitionRetrievalScenarios, politeFetch, renderKnowledgeBenchmarkReportMarkdown, renderMemoryContext, resetRetrievalHoldoutRegistry, resolveMemoryCleanupTimeoutMs, respondToIndustryMemoryBenchmarkSmokeCase, respondToIndustryRagBenchmarkSmokeCase, retrievalConfigFromSurface, retrievalConfigSurface, retrievalHoldoutConfigHash, retrievalRecallJudge, runAgentMemoryExperiment, runAgentMemoryImprovement, runAgentMemoryLearningExperiment, runBoundedMemoryLifecycle, runKnowledgeBenchmarkSuite, runMemoryAdapterBenchmark, runSerializedKnowledgeOptimization, scenarioContentFingerprint, scoreKnowledgeBenchmarkArtifact, scoreMemoryBenchmarkArtifact, scoreRetrievalArtifact, sleepForMemoryRecovery, summarizeKnowledgeBenchmarkCampaign, toOffPolicyTrajectory };
+export { AgentMemoryAdapter, AgentMemoryBranch, AgentMemoryBranchIsolation, AgentMemoryBranchLifetime, AgentMemoryBranchSnapshot, AgentMemoryContext, AgentMemoryHit, AgentMemoryHitSchema, AgentMemoryJournalEntry, AgentMemoryKind, AgentMemoryKindSchema, AgentMemoryLifecycleTimeoutError, AgentMemoryLifecycleUnsafeError, AgentMemoryScope, AgentMemoryScopeSchema, AgentMemorySearchOptions, AgentMemorySharingPolicy, AgentMemoryVisibility, AgentMemoryWriteInput, AgentMemoryWriteInputSchema, AgentMemoryWriteResult, ClaimRef, CreateAgentMemoryBranchOptions, CreatePlayMemoryToolsOptions, DEFAULT_MEMORY_CLEANUP_TIMEOUT_MS, DeepQuestion, DeepQuestionKind, type ExternalRagEvalScore, ForkAgentMemoryBranchSnapshotOptions, GraphitiMcpClientLike, GraphitiMemoryAdapterOptions, GraphitiToolNames, HindsightClientLike, HindsightMemoryAdapterOptions, HindsightOperationUnknownError, KNOWLEDGE_EVENT_TYPES, KnowledgeBaseCandidate, type KnowledgeBaseQualityOptions, type KnowledgeBaseQualityReport, type KnowledgeBrief, type KnowledgeBriefOptions, KnowledgeClaim, KnowledgeEvent, KnowledgeEventType, KnowledgeGraph, KnowledgeGraphEdge, KnowledgeGraphNode, KnowledgeId, type KnowledgeImprovementActivationPersistence, type KnowledgeImprovementCandidateRecord, type KnowledgeImprovementCandidateRef, type KnowledgeImprovementEvaluationInput, type KnowledgeImprovementEvaluator, type KnowledgeImprovementEvent, type KnowledgeImprovementEvidence, type KnowledgeImprovementMetric, type KnowledgeImprovementMetricProvenance, type KnowledgeImprovementMutationReceipt, type KnowledgeImprovementMutationResult, type KnowledgeImprovementOptions, type KnowledgeImprovementRagOptimizationOptions, type KnowledgeImprovementRagOptimizationRunInput, type KnowledgeImprovementResult, type KnowledgeImprovementRetrievalOptions, type KnowledgeImprovementRunState, type KnowledgeImprovementStatus, type KnowledgeImprovementTarget, type KnowledgeImprovementUpdate, type KnowledgeImprovementUpdateInput, KnowledgeIndex, KnowledgeLintFinding, type KnowledgeMutationHold, type KnowledgeMutationLock, type KnowledgeMutationOptions, KnowledgePage, KnowledgePageInvalidation, KnowledgePolicy, type KnowledgeReadOptions, KnowledgeRelation, KnowledgeRelease, KnowledgeSearchResult, type KnowledgeStateScope, KnowledgeUnit, KnowledgeWriteBlock, KnowledgeWriteParseResult, type LoadKnowledgeImprovementActivationResultOptions, Mem0ClientMode, Mem0HostedClient, Mem0HostedMemoryAdapterOptions, Mem0MemoryAdapterOptions, Mem0OssClient, Mem0OssMemoryAdapterOptions, type NearDuplicateDetectionOptions, type NearDuplicatePair, type NearDuplicateReport, Neo4jAgentMemoryAdapterOptions, type OriginatedPage, type PageOrigin, type PendingKnowledgeMutation, PlayMemoryRetrievalReceipt, type PromoteKnowledgeCandidateOptions, type RagAnswerEvalArtifact, type RagAnswerEvalCase, type RagAnswerEvalScenario, type RagAnswerMetricSummary, type RagAnswerQualityHookOptions, type RagAnswerQualityJudgeOptions, type RagCalibrationOptions, type RagCalibrationResult, type RagEvalCitation, type RagEvalClaim, type RagEvalContext, type RagEvalMetricKey, type RagEvalProvider, type RagEvalSlice, type RagRequiredContext, type RecoverPendingKnowledgeMutationOptions, type RegularFileSnapshot, ResearchClaimEvidence, ResearchClaimLedger, ResearchClaimRecord, ResearchSourceVersion, type ResolvedKnowledgeImprovementCandidate, type ResolvedKnowledgeImprovementComparison, type ResolvedKnowledgeImprovementComparisonSnapshot, type RestoreKnowledgeCandidateBaselineOptions, RetrievalHoldoutBypassReason, RetrievalHoldoutCallContext, RetrievalHoldoutConfig, RetrievalHoldoutEligibleItem, RetrievalHoldoutEvent, RetrievalHoldoutOffPolicyOptions, RetrievalHoldoutOffPolicyResult, RetrievalHoldoutResult, RetrievalHoldoutSessionState, RetrievalHoldoutSessionSummary, type RunLineageAuthority, type RunLineageRecord, type RunScopedStores, type RunScopedStoresOptions, SourceAnchor, SourceRecord, SourceRegistry, TrackedClaim, type UseKnowledgeImprovementCandidateOptions, applyRetrievalHoldout, applySessionStickyRetrievalHoldout, createAgentMemoryBranch, createGraphitiMemoryAdapter, createHindsightMemoryAdapter, createInMemoryBenchmarkAdapter, createMem0MemoryAdapter, createMemoryExecutionPool, createNeo4jAgentMemoryAdapter, createNoopMemoryBenchmarkAdapter, createPlayMemoryTools, defaultGetMemoryContext, deterministicRng, emitRetrievalHoldoutBypass, forkAgentMemoryBranchSnapshot, graphitiMemoryAdapterIdentity, hindsightMemoryBankId, mem0MemoryAdapterIdentity, memoryHitToSourceRecord, memoryRecoveryDelayMs, memoryWriteResultToSourceRecord, renderMemoryContext, resetRetrievalHoldoutRegistry, resolveMemoryCleanupTimeoutMs, retrievalHoldoutConfigHash, runBoundedMemoryLifecycle, sleepForMemoryRecovery, toOffPolicyTrajectory };
 //# sourceMappingURL=index.d.ts.map