@tangle-network/agent-knowledge 5.0.4 → 6.1.0

package/dist/index.d.ts

@@ -1,54 +1,50 @@
-import { S as SourceRecord, c as KnowledgeIndex, d as KnowledgeSearchResult, e as SourceRegistry, f as KnowledgeEvent, g as KnowledgeLintFinding, h as KnowledgeEventType, i as KnowledgePage, b as KnowledgeGraph, j as KnowledgeWriteBlock, k as KnowledgeClaim, l as KnowledgeRelease, m as KnowledgeWriteParseResult } from './types-6x0OpfW6.js';
-export { C as ClaimRef, n as KnowledgeBaseCandidate, K as KnowledgeGraphEdge, a as KnowledgeGraphNode, o as KnowledgeId, p as KnowledgePolicy, q as KnowledgeRelation, r as KnowledgeUnit, s as SourceAnchor } from './types-6x0OpfW6.js';
-import { KnowledgeRequirementCategory, KnowledgeAcquisitionMode, KnowledgeImportance, KnowledgeFreshness, KnowledgeSensitivity, KnowledgeRequirement, KnowledgeBundle, KnowledgeReadinessReport, UserQuestion, DataAcquisitionPlan, ControlRuntimeConfig, ControlEvalResult, RunRecord, AnalystSeverity, AnalystFinding, ReleaseTraceEvidence, GateDecision, DatasetScenario, ReleaseConfidenceScorecard } from '@tangle-network/agent-eval';
-import { AgentCandidateJsonValue, AgentImprovementActivation, AgentImprovementActivationResult, AgentCandidateKnowledgeRef } from '@tangle-network/agent-interface';
-import { z } from 'zod';
-import { OptimizationMethod, DispatchContext, JudgeConfig, ComparisonCost, Scenario } from '@tangle-network/agent-eval/campaign';
-import { R as RunSerializedKnowledgeOptimizationResult, a as RunSerializedKnowledgeOptimizationOptions } from './index-Cf7txrYP.js';
-export { A as AgentMemoryActivation, b as AgentMemoryActivationDriver, c as AgentMemoryAttemptEvent, d as AgentMemoryBranch, e as AgentMemoryBranchLifetime, f as AgentMemoryBranchSnapshot, g as AgentMemoryDimensionComparison, h as AgentMemoryExecutionContext, i as AgentMemoryExecutionCostMeter, j as AgentMemoryExecutionCostReceipt, k as AgentMemoryExecutionPaidCallInput, l as AgentMemoryExecutionPaidCallResult, m as AgentMemoryExecutionStep, n as AgentMemoryExperimentCandidate, o as AgentMemoryExperimentRankingRow, p as AgentMemoryExperimentRunLease, q as AgentMemoryFinalEvaluation, r as AgentMemoryFinalPair, s as AgentMemoryHitSchema, t as AgentMemoryImprovementRunLease, u as AgentMemoryJournalEntry, v as AgentMemoryKindSchema, w as AgentMemoryLifecycleTimeoutError, x as AgentMemoryLifecycleUnsafeError, y as AgentMemoryPromotionDecision, z as AgentMemoryScopeSchema, B as AgentMemorySequence, C as AgentMemorySequenceArtifact, D as AgentMemorySequenceProbe, E as AgentMemorySequenceProbeResult, F as AgentMemorySequenceScenario, G as AgentMemorySequenceStep, H as AgentMemorySharingPolicy, I as AgentMemoryVisibility, J as AgentMemoryWriteInputSchema, K as BuildAgentMemorySequencesFromBenchmarkCasesOptions, L as CreateAgentMemoryBranchOptions, M as DEFAULT_MEMORY_CLEANUP_TIMEOUT_MS, N as ForkAgentMemoryBranchSnapshotOptions, O as GraphitiMcpClientLike, P as GraphitiMemoryAdapterOptions, Q as GraphitiToolNames, S as Mem0ClientLike, T as Mem0ClientMode, U as Mem0MemoryAdapterOptions, V as MemoryConfigScenario, W as Neo4jAgentMemoryAdapterOptions, X as RetrievalHoldoutOffPolicyOptions, Y as RetrievalHoldoutOffPolicyResult, Z as RetrievalHoldoutSessionSummary, _ as RunAgentMemoryExperimentOptions, $ as RunAgentMemoryExperimentResult, a0 as RunAgentMemoryImprovementOptions, a1 as RunAgentMemoryImprovementResult, a2 as SerializedCandidate, a3 as SerializedCandidateCodec, a4 as agentMemorySequenceJudge, a5 as applyRetrievalHoldout, a6 as applySessionStickyRetrievalHoldout, a7 as buildAgentMemorySequenceScenarios, a8 as buildAgentMemorySequencesFromBenchmarkCases, a9 as createAgentMemoryBranch, aa as createGraphitiMemoryAdapter, ab as createMem0MemoryAdapter, ac as createMemoryExecutionPool, ad as createNeo4jAgentMemoryAdapter, ae as defaultGetMemoryContext, af as deterministicRng, ag as emitRetrievalHoldoutBypass, ah as forkAgentMemoryBranchSnapshot, ai as graphitiMemoryAdapterIdentity, aj as jsonCandidateCodec, ak as jsonObjectCandidateCodec, al as mem0MemoryAdapterIdentity, am as memoryHitToSourceRecord, an as memoryRecoveryDelayMs, ao as memoryWriteResultToSourceRecord, ap as renderMemoryContext, aq as resetRetrievalHoldoutRegistry, ar as resolveMemoryCleanupTimeoutMs, as as retrievalHoldoutConfigHash, at as runAgentMemoryExperiment, au as runAgentMemoryImprovement, av as runBoundedMemoryLifecycle, aw as runSerializedKnowledgeOptimization, ax as scenarioContentFingerprint, ay as sleepForMemoryRecovery, az as toOffPolicyTrajectory } from './index-Cf7txrYP.js';
-import { R as RetrievalConfig, a as RetrievalEvalScenario, b as RetrievalEvalArtifact, c as RetrievalEvalRetriever, d as RetrievalMetricWeights, e as RetrievedKnowledgeHit } from './types-BY-xLVw-.js';
-export { A as AgentMemoryAcquireRunLease, f as AgentMemoryAdapter, g as AgentMemoryBranchIsolation, h as AgentMemoryContext, i as AgentMemoryControllerMode, j as AgentMemoryHit, k as AgentMemoryKind, l as AgentMemoryRunLease, m as AgentMemoryScope, n as AgentMemorySearchOptions, o as AgentMemoryWriteInput, p as AgentMemoryWriteResult, B as BuildRetrievalBenchmarkCasesFromQrelsOptions, q as BuildRetrievalEvalDispatchOptions, K as KnowledgeAnswerBenchmarkCase, r as KnowledgeAnswerBenchmarkTaskKind, s as KnowledgeBenchmarkArtifact, t as KnowledgeBenchmarkCase, u as KnowledgeBenchmarkCaseBase, v as KnowledgeBenchmarkDistribution, w as KnowledgeBenchmarkEvaluation, x as KnowledgeBenchmarkFamily, y as KnowledgeBenchmarkReport, z as KnowledgeBenchmarkResponder, C as KnowledgeBenchmarkScenario, D as KnowledgeBenchmarkSliceSummary, E as KnowledgeBenchmarkSource, F as KnowledgeBenchmarkSpec, G as KnowledgeBenchmarkSplit, H as KnowledgeBenchmarkTaskKind, I as KnowledgeClaimMatcher, J as KnowledgeMemoryBenchmarkCase, L as KnowledgeMemoryBenchmarkTaskKind, M as KnowledgeMemoryEvent, N as KnowledgeMemoryFactMatcher, O as KnowledgeRetrievalBenchmarkCase, P as KnowledgeRetrievalBenchmarkQrel, Q as KnowledgeRetrievalBenchmarkQuery, S as MemoryAdapterBenchmarkCandidate, T as MemoryAdapterBenchmarkRankingRow, U as OwnedAgentMemoryRunLease, V as PartitionRetrievalScenariosOptions, W as RetrievalEvalRetrieverInput, X as RetrievalEvalRetrieverResult, Y as RetrievalGoldTarget, Z as RetrievalHoldoutBypassReason, _ as RetrievalHoldoutCallContext, $ as RetrievalHoldoutConfig, a0 as RetrievalHoldoutEligibleItem, a1 as RetrievalHoldoutEvent, a2 as RetrievalHoldoutResult, a3 as RetrievalHoldoutSessionState, a4 as RetrievalMetricSummary, a5 as RetrievalRecallJudgeOptions, a6 as RetrievalScenarioPartitions, a7 as RetrievedSourceSpan, a8 as RunKnowledgeBenchmarkSuiteOptions, a9 as RunKnowledgeBenchmarkSuiteResult, aa as RunMemoryAdapterBenchmarkOptions, ab as RunMemoryAdapterBenchmarkResult, ac as acquireAgentMemoryRunLease, ad as buildRetrievalEvalDispatch, ae as partitionRetrievalScenarios, af as retrievalConfigFromSurface, ag as retrievalConfigSurface, ah as retrievalRecallJudge, ai as scoreRetrievalArtifact } from './types-BY-xLVw-.js';
-export { INDUSTRY_MEMORY_BENCHMARKS, INDUSTRY_RAG_BENCHMARKS, buildFirstPartyMemoryLifecycleBenchmarkCases, buildIndustryMemoryBenchmarkSmokeCases, buildIndustryRagBenchmarkSmokeCases, buildKnowledgeBenchmarkScenarios, buildRetrievalBenchmarkCasesFromQrels, createInMemoryBenchmarkAdapter, createNoopMemoryBenchmarkAdapter, isKnowledgeMemoryBenchmarkCase, knowledgeBenchmarkJudge, parseKnowledgeBenchmarkJsonl, parseKnowledgeBenchmarkQrels, renderKnowledgeBenchmarkReportMarkdown, respondToIndustryMemoryBenchmarkSmokeCase, respondToIndustryRagBenchmarkSmokeCase, runKnowledgeBenchmarkSuite, runMemoryAdapterBenchmark, scoreKnowledgeBenchmarkArtifact, scoreMemoryBenchmarkArtifact, summarizeKnowledgeBenchmarkCampaign } from './benchmarks/index.js';
-import { KnowledgeFragment } from './sources/index.js';
-export { CornellLiiSelector, CornellLiiSourceOptions, FetchOpts, FragmentProvenance, IRS_DIMENSION_HINTS, IrsPublicationsSourceOptions, 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 '@tangle-network/agent-eval/rl';
-
+import { S as SourceRegistry, _ as KnowledgeUnit, a as KnowledgeEventType, b as SourceAnchor, c as KnowledgeGraphNode, d as KnowledgeLintFinding, f as KnowledgePage, g as KnowledgeSearchResult, h as KnowledgeRelease, i as KnowledgeEvent, l as KnowledgeId, m as KnowledgeRelation, n as KnowledgeBaseCandidate, o as KnowledgeGraph, p as KnowledgePolicy, r as KnowledgeClaim, s as KnowledgeGraphEdge, t as ClaimRef, u as KnowledgeIndex, v as KnowledgeWriteBlock, x as SourceRecord, y as KnowledgeWriteParseResult } from "./types-DcCCzreS.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-CIW3G4s_.js";
+import { $ as buildAgentMemorySequenceScenarios, A as AgentMemoryFinalPair, At as defaultGetMemoryContext, B as applySessionStickyRetrievalHoldout, C as runBoundedMemoryLifecycle, Ct as AgentMemoryJournalEntry, D as AgentMemoryActivationDriver, Dt as ForkAgentMemoryBranchSnapshotOptions, E as AgentMemoryActivation, Et as CreateAgentMemoryBranchOptions, F as RunAgentMemoryImprovementResult, Ft as SerializedCandidateCodec, G as toOffPolicyTrajectory, H as emitRetrievalHoldoutBypass, I as RetrievalHoldoutOffPolicyOptions, It as jsonCandidateCodec, J as GraphitiToolNames, K as GraphitiMcpClientLike, L as RetrievalHoldoutOffPolicyResult, Lt as jsonObjectCandidateCodec, M as AgentMemoryPromotionDecision, Mt as RunSerializedKnowledgeOptimizationOptions, N as MemoryConfigScenario, Nt as RunSerializedKnowledgeOptimizationResult, O as AgentMemoryDimensionComparison, Ot as createAgentMemoryBranch, P as RunAgentMemoryImprovementOptions, Pt as SerializedCandidate, Q as agentMemorySequenceJudge, R as RetrievalHoldoutSessionSummary, Rt as runSerializedKnowledgeOptimization, S as resolveMemoryCleanupTimeoutMs, St as AgentMemoryBranchSnapshot, T as runAgentMemoryImprovement, Tt as AgentMemoryVisibility, U as resetRetrievalHoldoutRegistry, V as deterministicRng, W as retrievalHoldoutConfigHash, X as graphitiMemoryAdapterIdentity, Y as createGraphitiMemoryAdapter, Z as runAgentMemoryExperiment, _ as AgentMemoryLifecycleTimeoutError, _t as BuildAgentMemorySequencesFromBenchmarkCasesOptions, a as AgentMemoryScopeSchema, at as AgentMemoryExecutionPaidCallInput, b as createMemoryExecutionPool, bt as AgentMemoryBranch, c as createNeo4jAgentMemoryAdapter, ct as AgentMemoryExperimentCandidate, d as Mem0HostedMemoryAdapterOptions, dt as AgentMemorySequence, et as buildAgentMemorySequencesFromBenchmarkCases, f as Mem0MemoryAdapterOptions, ft as AgentMemorySequenceArtifact, g as mem0MemoryAdapterIdentity, gt as AgentMemorySequenceStep, h as createMem0MemoryAdapter, ht as AgentMemorySequenceScenario, i as AgentMemoryKindSchema, it as AgentMemoryExecutionCostReceipt, j as AgentMemoryImprovementRunLease, jt as renderMemoryContext, k as AgentMemoryFinalEvaluation, kt as forkAgentMemoryBranchSnapshot, l as Mem0ClientMode, lt as AgentMemoryExperimentRankingRow, m as Mem0OssMemoryAdapterOptions, mt as AgentMemorySequenceProbeResult, n as memoryWriteResultToSourceRecord, nt as AgentMemoryExecutionContext, o as AgentMemoryWriteInputSchema, ot as AgentMemoryExecutionPaidCallResult, p as Mem0OssClient, pt as AgentMemorySequenceProbe, q as GraphitiMemoryAdapterOptions, r as AgentMemoryHitSchema, rt as AgentMemoryExecutionCostMeter, s as Neo4jAgentMemoryAdapterOptions, st as AgentMemoryExecutionStep, t as memoryHitToSourceRecord, tt as AgentMemoryAttemptEvent, u as Mem0HostedClient, ut as AgentMemoryExperimentRunLease, v as AgentMemoryLifecycleUnsafeError, vt as RunAgentMemoryExperimentOptions, w as sleepForMemoryRecovery, wt as AgentMemorySharingPolicy, x as memoryRecoveryDelayMs, xt as AgentMemoryBranchLifetime, y as DEFAULT_MEMORY_CLEANUP_TIMEOUT_MS, yt as RunAgentMemoryExperimentResult, z as applyRetrievalHoldout, zt as scenarioContentFingerprint } from "./index-CGBctbit.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 { AgentCandidateJsonValue, AgentCandidateKnowledgeRef, AgentImprovementActivation, AgentImprovementActivationResult } from "@tangle-network/agent-interface";
+import { AnalystFinding, AnalystSeverity, ControlEvalResult, ControlRuntimeConfig, DataAcquisitionPlan, DatasetScenario, GateDecision, KnowledgeAcquisitionMode, KnowledgeBundle, KnowledgeFreshness, KnowledgeImportance, KnowledgeReadinessReport, KnowledgeRequirement, KnowledgeRequirementCategory, KnowledgeSensitivity, ReleaseConfidenceScorecard, ReleaseTraceEvidence, RunRecord, UserQuestion } from "@tangle-network/agent-eval";
+import { z } from "zod";
+import "proper-lockfile";
+import { ComparisonCost, DispatchContext, JudgeConfig, OptimizationMethod, Scenario } from "@tangle-network/agent-eval/campaign";
+//#region src/adapters.d.ts
 interface SourceAdapterInput {
-    uri: string;
-    bytes?: Uint8Array;
-    text?: string;
-    metadata?: Record<string, unknown>;
+  uri: string;
+  bytes?: Uint8Array;
+  text?: string;
+  metadata?: Record<string, unknown>;
 }
 interface SourceAdapterOutput {
-    title?: string;
-    mediaType?: string;
-    text?: string;
-    anchors?: SourceRecord['anchors'];
-    metadata?: Record<string, unknown>;
+  title?: string;
+  mediaType?: string;
+  text?: string;
+  anchors?: SourceRecord['anchors'];
+  metadata?: Record<string, unknown>;
 }
 interface SourceAdapter {
-    id: string;
-    canLoad(input: SourceAdapterInput): boolean;
-    load(input: SourceAdapterInput): Promise<SourceAdapterOutput> | SourceAdapterOutput;
+  id: string;
+  canLoad(input: SourceAdapterInput): boolean;
+  load(input: SourceAdapterInput): Promise<SourceAdapterOutput> | SourceAdapterOutput;
 }
 declare const textSourceAdapter: SourceAdapter;
 declare function mediaTypeFor(uri: string): string;
-
+//#endregion
+//#region src/eval-readiness.d.ts
 interface KnowledgeReadinessSpec {
-    id: string;
-    description: string;
-    query: string;
-    requiredFor: string[];
-    category: KnowledgeRequirementCategory;
-    acquisitionMode: KnowledgeAcquisitionMode;
-    importance: KnowledgeImportance;
-    freshness: KnowledgeFreshness;
-    sensitivity: KnowledgeSensitivity;
-    confidenceNeeded: number;
-    fallbackPolicy?: KnowledgeRequirement['fallbackPolicy'];
-    minSources?: number;
-    minHits?: number;
-    metadata?: Record<string, unknown>;
+  id: string;
+  description: string;
+  query: string;
+  requiredFor: string[];
+  category: KnowledgeRequirementCategory;
+  acquisitionMode: KnowledgeAcquisitionMode;
+  importance: KnowledgeImportance;
+  freshness: KnowledgeFreshness;
+  sensitivity: KnowledgeSensitivity;
+  confidenceNeeded: number;
+  fallbackPolicy?: KnowledgeRequirement['fallbackPolicy'];
+  minSources?: number;
+  minHits?: number;
+  metadata?: Record<string, unknown>;
 }
 /**
  * Defaults applied by `defineReadinessSpec` when the caller omits the field.
@@ -59,14 +55,14 @@ interface KnowledgeReadinessSpec {
  * topic that must reflect today's regulatory state).
  */
 declare const READINESS_SPEC_DEFAULTS: {
-    readonly category: "domain_specific";
-    readonly acquisitionMode: "search_web";
-    readonly importance: "high";
-    readonly freshness: "monthly";
-    readonly sensitivity: "public";
-    readonly confidenceNeeded: 0.7;
-    readonly minSources: 1;
-    readonly minHits: 2;
+  readonly category: 'domain_specific';
+  readonly acquisitionMode: 'search_web';
+  readonly importance: 'high';
+  readonly freshness: 'monthly';
+  readonly sensitivity: 'public';
+  readonly confidenceNeeded: 0.7;
+  readonly minSources: 1;
+  readonly minHits: 2;
 };
 /**
  * Inputs accepted by `defineReadinessSpec`. The four fields the caller cannot
@@ -106,58 +102,60 @@ type DefineReadinessSpecInput = Pick<KnowledgeReadinessSpec, 'id' | 'description
  */
 declare function defineReadinessSpec(input: DefineReadinessSpecInput): KnowledgeReadinessSpec;
 interface BuildEvalKnowledgeBundleOptions {
-    taskId: string;
-    index: KnowledgeIndex;
-    specs: KnowledgeReadinessSpec[];
-    userAnswers?: Record<string, string>;
-    searchLimit?: number;
-    metadata?: Record<string, unknown>;
-    now?: Date;
+  taskId: string;
+  index: KnowledgeIndex;
+  specs: KnowledgeReadinessSpec[];
+  userAnswers?: Record<string, string>;
+  searchLimit?: number;
+  metadata?: Record<string, unknown>;
+  now?: Date;
 }
 interface EvalKnowledgeBundleBuildResult {
-    bundle: KnowledgeBundle;
-    report: KnowledgeReadinessReport;
-    requirements: KnowledgeRequirement[];
-    searchResultsByRequirement: Record<string, KnowledgeSearchResult[]>;
-    questions: UserQuestion[];
-    acquisitionPlans: DataAcquisitionPlan[];
+  bundle: KnowledgeBundle;
+  report: KnowledgeReadinessReport;
+  requirements: KnowledgeRequirement[];
+  searchResultsByRequirement: Record<string, KnowledgeSearchResult[]>;
+  questions: UserQuestion[];
+  acquisitionPlans: DataAcquisitionPlan[];
 }
 declare function buildEvalKnowledgeBundle(options: BuildEvalKnowledgeBundleOptions): EvalKnowledgeBundleBuildResult;
-
+//#endregion
+//#region src/sources.d.ts
 interface AddSourceOptions {
-    copyIntoRaw?: boolean;
-    adapters?: SourceAdapter[];
-    now?: () => Date;
+  copyIntoRaw?: boolean;
+  adapters?: SourceAdapter[];
+  now?: () => Date;
 }
 interface AddSourceTextInput {
-    uri: string;
-    text: string;
-    title?: string;
-    mediaType?: string;
-    validUntil?: string;
-    lastVerifiedAt?: string;
-    metadata?: Record<string, unknown>;
+  uri: string;
+  text: string;
+  title?: string;
+  mediaType?: string;
+  validUntil?: string;
+  lastVerifiedAt?: string;
+  metadata?: Record<string, unknown>;
 }
 declare function loadSourceRegistry(root: string): Promise<SourceRegistry>;
 declare function writeSourceRegistry(root: string, registry: SourceRegistry): Promise<void>;
 declare function addSourcePath(root: string, sourcePath: string, options?: AddSourceOptions): Promise<SourceRecord[]>;
 declare function addSourceText(root: string, input: AddSourceTextInput, options?: Pick<AddSourceOptions, 'adapters' | 'now'>): Promise<SourceRecord>;
 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.
  */
 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;
+  /** 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. */
 type ResearchSourceProposal = AddSourceTextInput;
@@ -171,62 +169,62 @@ type ResearchSourceProposal = AddSourceTextInput;
  * sources, so a rejected source never reaches the curated pages.
  */
 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>;
+  /** 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. */
 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;
+  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. */
 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;
+  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. */
 interface RejectedSource {
-    source: ResearchSourceProposal;
-    reason: string;
+  source: ResearchSourceProposal;
+  reason: string;
 }
 /** Context handed to the driver's gap-fill pass (only when `driverResearches`). */
 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;
+  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.
@@ -242,69 +240,69 @@ interface DriverResearchContext {
  *   next prompt. Defaults to a compact bulleted list when omitted.
  */
 interface ResearchDriver {
-    verifySource(source: ResearchSourceProposal, ctx: SourceVerificationContext): Promise<SourceVerdict> | SourceVerdict;
-    research?(ctx: DriverResearchContext): Promise<ResearchContribution> | ResearchContribution;
-    foldGaps?(gaps: KnowledgeGap[]): string;
+  verifySource(source: ResearchSourceProposal, ctx: SourceVerificationContext): Promise<SourceVerdict> | SourceVerdict;
+  research?(ctx: DriverResearchContext): Promise<ResearchContribution> | ResearchContribution;
+  foldGaps?(gaps: KnowledgeGap[]): string;
 }
 type SourceVerdict = {
-    accept: true;
+  accept: true;
 } | {
-    accept: false;
-    reason: string;
+  accept: false;
+  reason: string;
 };
 /** The worker: primary research targeting the round's gaps. */
 type ResearchWorker = (ctx: WorkerResearchContext) => Promise<ResearchContribution> | ResearchContribution;
 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;
+  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;
 }
 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 the readiness gate reports no blocking gaps. */
-    ready: boolean;
-    event: KnowledgeEvent;
-    notes: {
-        worker?: string;
-        driver?: string;
-    };
+  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 the readiness gate reports no blocking gaps. */
+  ready: boolean;
+  event: KnowledgeEvent;
+  notes: {
+    worker?: string;
+    driver?: string;
+  };
 }
 interface VerifiedResearchLoopResult {
-    root: string;
-    goal: string;
-    rounds: number;
-    ready: boolean;
-    index: KnowledgeIndex;
-    readiness?: EvalKnowledgeBundleBuildResult;
-    steps: VerifiedResearchRound[];
+  root: string;
+  goal: string;
+  rounds: number;
+  ready: boolean;
+  index: KnowledgeIndex;
+  readiness?: EvalKnowledgeBundleBuildResult;
+  steps: VerifiedResearchRound[];
 }
 /**
  * Two-agent (driver + worker) sibling of `runKnowledgeResearchLoop`.
@@ -335,67 +333,30 @@ declare function runVerifiedResearchLoop(options: VerifiedResearchLoopOptions):
  * driver can compose into `verifySource` (real verifiers can do more).
  */
 declare function sourceMatchesGaps(source: ResearchSourceProposal, index: KnowledgeIndex, gaps: KnowledgeGap[]): KnowledgeSearchResult[];
-/** @deprecated Renamed to {@link runVerifiedResearchLoop}. */
-declare const runTwoAgentResearchLoop: typeof runVerifiedResearchLoop;
-/** @deprecated Renamed to {@link VerifiedResearchLoopOptions}. */
-type TwoAgentResearchLoopOptions = VerifiedResearchLoopOptions;
-/** @deprecated Renamed to {@link VerifiedResearchLoopResult}. */
-type TwoAgentResearchLoopResult = VerifiedResearchLoopResult;
-/** @deprecated Renamed to {@link VerifiedResearchRound}. */
-type TwoAgentResearchRound = VerifiedResearchRound;
-
-/**
- * Real web-research worker + verifying driver for `runVerifiedResearchLoop`.
- *
- * This is the GENERAL, any-topic implementation behind the two-agent research
- * loop's live arm. Given the open knowledge gaps the readiness gate surfaces,
- * the worker:
- *
- *   1. asks an LLM (glm-5.2 by default) to turn each gap into focused web
- *      search queries,
- *   2. runs a REAL web search over the Tangle router (`POST /v1/search` — the
- *      same endpoint `tcloud mcp`'s `web_search` tool forwards to), so there is
- *      no hardcoded corpus,
- *   3. fetches the top results with the repo's polite, cached `politeFetch` and
- *      reduces each page to text with `htmlToText`,
- *   4. proposes the readable, verifiable pages as `ResearchSourceProposal`s plus
- *      a `buildPages` that writes citing `knowledge/*.md` pages from the sources
- *      the driver accepts.
- *
- * The verifying DRIVER is the differentiated role from the two-agent loop: a
- * second LLM pass that judges each fetched source's on-topic relevance to the
- * goal + open gaps and rejects off-topic / spam / already-covered material. The
- * worker ADDS; the driver GATES. Together they build a cleaner knowledge base
- * than a single agent at the same compute budget.
- *
- * Dependency-free on purpose: it talks to the router over `fetch` directly with
- * the published OpenAI-compatible chat shape and the `/v1/search` shape, so it
- * works whether or not the `tcloud` CLI is installed. Point it at any router by
- * passing `baseUrl`; supply the key via `apiKey` or `TANGLE_API_KEY`.
- */
-
+//#endregion
+//#region src/web-research-worker.d.ts
 /** One live web result, as the router's `/v1/search` returns it. */
 interface WebSearchHit {
-    title: string;
-    url: string;
-    snippet?: string;
+  title: string;
+  url: string;
+  snippet?: string;
 }
 /**
  * The two router capabilities the worker/driver need. Injectable so tests can
  * stub the network; the default talks to the live Tangle router over `fetch`.
  */
 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;
+  /** 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,
@@ -405,38 +366,38 @@ interface RouterClient {
  * than its "equal passes" budget implies.
  */
 interface RouterUsage {
-    chatCalls: number;
-    searchCalls: number;
-    promptTokens: number;
-    completionTokens: number;
-    usd: number;
-    wallMs: number;
+  chatCalls: number;
+  searchCalls: number;
+  promptTokens: number;
+  completionTokens: number;
+  usd: number;
+  wallMs: number;
 }
 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;
-    /**
-     * Retries on a TRANSIENT upstream status (502/503/504/429) with exponential
-     * backoff. Default 4. A 4xx that isn't 429, and a 401, are NOT retried — those
-     * are not transient. After the budget is exhausted the call still fails loud
-     * with the original `RouterError`, so the fail-closed contract holds; this only
-     * stops a single upstream-capacity blip from voiding a whole multi-topic run.
-     */
-    maxRetries?: number;
-    /** Base backoff in ms (doubled each retry, ±25% jitter). Default 1500. */
-    retryBaseMs?: number;
-    signal?: AbortSignal;
+  /** 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;
+  /**
+   * Retries on a TRANSIENT upstream status (502/503/504/429) with exponential
+   * backoff. Default 4. A 4xx that isn't 429, and a 401, are NOT retried — those
+   * are not transient. After the budget is exhausted the call still fails loud
+   * with the original `RouterError`, so the fail-closed contract holds; this only
+   * stops a single upstream-capacity blip from voiding a whole multi-topic run.
+   */
+  maxRetries?: number;
+  /** Base backoff in ms (doubled each retry, ±25% jitter). Default 1500. */
+  retryBaseMs?: number;
+  signal?: AbortSignal;
 }
 /** A small error so a failed router call fails loud rather than returning junk. */
 declare class RouterError extends Error {
-    readonly status: number;
-    constructor(status: number, message: string);
+  readonly status: number;
+  constructor(status: number, message: string);
 }
 /**
  * Build a dependency-free Tangle router client over `fetch`. This is the same
@@ -445,21 +406,21 @@ declare class RouterError extends Error {
  */
 declare function createTangleRouterClient(options?: TangleRouterOptions): RouterClient;
 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;
+  /** 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`
@@ -468,14 +429,14 @@ interface WebResearchWorkerOptions {
  */
 declare function createWebResearchWorker(options?: WebResearchWorkerOptions): ResearchWorker;
 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;
+  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
@@ -488,44 +449,8 @@ interface VerifyingDriverOptions {
  * judgement, not bookkeeping.
  */
 declare function createVerifyingResearchDriver(options?: VerifyingDriverOptions): ResearchDriver;
-
-/**
- * Adaptive verifier mode for `runVerifiedResearchLoop`.
- *
- * The cost/quality A/B (`docs/results/cost-quality.md`) found the LLM relevance
- * verifier's cleanliness win is dominated by DE-DUPLICATION — which a
- * deterministic content-hash / canonical-URL check captures at ~none of the LLM
- * premium — and that an LLM check only earns its dollar on the off-scope tail.
- * The honest production move it names is: do the cheap deterministic work first,
- * spend the LLM only where it pays. This module is that driver.
- *
- * Per candidate source the adaptive driver runs THREE stages, cheapest first,
- * and stops at the first that decides:
- *
- *   1. DEDUP ($0, no LLM). Reject a source whose CONTENT (normalized-text hash)
- *      or whose CANONICAL URL matches one already accepted this round or already
- *      in the knowledge base. This is the de-dup the relevance judge was being
- *      paid to do; doing it deterministically is free and exact.
- *
- *   2. HEURISTIC TRIAGE ($0, no LLM). For a unique survivor, a cheap host /
- *      title / length signal classifies it as clearly-keep, clearly-drop, or
- *      AMBIGUOUS. Clear cases are resolved without a model: an authoritative host
- *      (arxiv, *.edu, *.gov, official docs) with a substantial readable body is
- *      kept; an obvious spam/listicle/marketing title or a too-thin body is
- *      dropped. Only genuinely ambiguous survivors fall through.
- *
- *   3. LLM ESCALATION ($, one call). ONLY the ambiguous survivors reach the LLM
- *      `verifySource` — the shipped `createVerifyingResearchDriver` relevance
- *      judge. This is where the verifier earns its premium: the off-scope tail a
- *      cheap rule can't adjudicate.
- *
- * The result is the cost/quality frontier point the doc predicted: most of the
- * cleanliness (dedup + clear drops) at a fraction of the LLM $/calls (only the
- * ambiguous tail pays). It is a real `ResearchDriver` — same contract the
- * two-agent loop already gates on — and reuses `sha256`, the relevance verifier,
- * and the index; it reinvents none of them.
- */
-
+//#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
@@ -548,59 +473,59 @@ type DedupReason = 'duplicate-url' | 'duplicate-content';
 type TriageClass = 'keep' | 'drop' | 'ambiguous';
 /** One source's adaptive routing decision, for instrumentation and the doc. */
 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;
+  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. */
 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[];
+  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[];
 }
 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;
+  /** 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
@@ -609,18 +534,18 @@ interface AdaptiveDriverOptions {
  * with a plausible body, which a host/title rule cannot adjudicate.
  */
 declare function triageSource(source: ResearchSourceProposal, options: {
-    authoritativeHosts: string[];
-    spamPatterns: RegExp[];
-    minBodyChars: number;
-    substantialBodyChars: number;
+  authoritativeHosts: string[];
+  spamPatterns: RegExp[];
+  minBodyChars: number;
+  substantialBodyChars: number;
 }): {
-    triage: TriageClass;
-    reason: string;
+  triage: TriageClass;
+  reason: string;
 };
 interface AdaptiveResearchDriver {
-    verifySource(source: ResearchSourceProposal, ctx: SourceVerificationContext): Promise<SourceVerdict>;
-    /** Live tally of where decisions were spent — the cost/quality instrumentation. */
-    stats(): AdaptiveStats;
+  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
@@ -633,137 +558,141 @@ interface AdaptiveResearchDriver {
  * context's `acceptedThisRound` and the KB index. Use one driver per loop run.
  */
 declare function createAdaptiveResearchDriver(options?: AdaptiveDriverOptions): AdaptiveResearchDriver;
-
+//#endregion
+//#region src/rag-optimization.d.ts
 type RagOptimizationConfig = Record<string, AgentCandidateJsonValue>;
 type RagOptimizationBaseOptions = Omit<RunSerializedKnowledgeOptimizationOptions<RagOptimizationConfig, RagAnswerEvalScenario, RagAnswerEvalArtifact>, 'baseline' | 'method' | 'trainScenarios' | 'selectionScenarios' | 'finalScenarios' | 'dispatchCandidate' | 'judges' | 'codec' | 'scenarioFingerprint'>;
 interface RunRagOptimizationOptions extends RagOptimizationBaseOptions {
-    baseline: RagOptimizationConfig;
-    method: OptimizationMethod<RagAnswerEvalScenario, RagAnswerEvalArtifact>;
-    trainScenarios: readonly RagAnswerEvalScenario[];
-    selectionScenarios: readonly RagAnswerEvalScenario[];
-    finalScenarios: readonly RagAnswerEvalScenario[];
-    run(input: {
-        config: RagOptimizationConfig;
-        configSurface: string;
-        configSurfaceHash: string;
-        scenario: RagAnswerEvalScenario;
-        context: DispatchContext;
-    }): Promise<RagAnswerEvalArtifact>;
-    judges?: readonly JudgeConfig<RagAnswerEvalArtifact, RagAnswerEvalScenario>[];
+  baseline: RagOptimizationConfig;
+  method: OptimizationMethod<RagAnswerEvalScenario, RagAnswerEvalArtifact>;
+  trainScenarios: readonly RagAnswerEvalScenario[];
+  selectionScenarios: readonly RagAnswerEvalScenario[];
+  finalScenarios: readonly RagAnswerEvalScenario[];
+  run(input: {
+    config: RagOptimizationConfig;
+    configSurface: string;
+    configSurfaceHash: string;
+    scenario: RagAnswerEvalScenario;
+    context: DispatchContext;
+  }): Promise<RagAnswerEvalArtifact>;
+  judges?: readonly JudgeConfig<RagAnswerEvalArtifact, RagAnswerEvalScenario>[];
 }
 interface RunRagOptimizationResult extends RunSerializedKnowledgeOptimizationResult<RagOptimizationConfig> {
-    baselineConfig: RagOptimizationConfig;
-    winnerConfig: RagOptimizationConfig;
-    trainScenarios: readonly RagAnswerEvalScenario[];
-    selectionScenarios: readonly RagAnswerEvalScenario[];
-    finalScenarios: readonly RagAnswerEvalScenario[];
+  baselineConfig: RagOptimizationConfig;
+  winnerConfig: RagOptimizationConfig;
+  trainScenarios: readonly RagAnswerEvalScenario[];
+  selectionScenarios: readonly RagAnswerEvalScenario[];
+  finalScenarios: readonly RagAnswerEvalScenario[];
 }
 /** Optimizes retrieval and answer behavior together as one serialized RAG configuration. */
 declare function runRagOptimization(options: RunRagOptimizationOptions): Promise<RunRagOptimizationResult>;
-
+//#endregion
+//#region src/proposals.d.ts
 interface ApplyWriteBlocksResult {
-    written: string[];
-    warnings: string[];
+  written: string[];
+  warnings: string[];
 }
 declare function applyKnowledgeWriteBlocks(root: string, proposalText: string): Promise<ApplyWriteBlocksResult>;
 declare function applyKnowledgeWriteBlocksFile(root: string, proposalPath: string): Promise<ApplyWriteBlocksResult>;
-
+//#endregion
+//#region src/validate.d.ts
 interface ValidateKnowledgeOptions {
-    strict?: boolean;
+  strict?: boolean;
 }
 interface ValidateKnowledgeResult {
-    ok: boolean;
-    findings: KnowledgeLintFinding[];
+  ok: boolean;
+  findings: KnowledgeLintFinding[];
 }
 declare function validateKnowledgeIndex(index: KnowledgeIndex, options?: ValidateKnowledgeOptions): ValidateKnowledgeResult;
-
+//#endregion
+//#region src/research-loop.d.ts
 interface KnowledgeResearchLoopContext {
-    root: string;
-    goal: string;
-    iteration: number;
-    index: KnowledgeIndex;
-    lintFindings: KnowledgeLintFinding[];
-    validation: ValidateKnowledgeResult;
-    readiness?: EvalKnowledgeBundleBuildResult;
-    previousSteps: KnowledgeResearchLoopStep[];
-    signal?: AbortSignal;
+  root: string;
+  goal: string;
+  iteration: number;
+  index: KnowledgeIndex;
+  lintFindings: KnowledgeLintFinding[];
+  validation: ValidateKnowledgeResult;
+  readiness?: EvalKnowledgeBundleBuildResult;
+  previousSteps: KnowledgeResearchLoopStep[];
+  signal?: AbortSignal;
 }
 interface KnowledgeResearchLoopDecision {
-    /**
-     * Free-form notes from the researcher. Keep this human-readable; products can
-     * store it as the research transcript.
-     */
-    notes?: string;
-    /**
-     * Local files to register as immutable sources before applying proposals.
-     */
-    sourcePaths?: string[];
-    /**
-     * Textual source artifacts discovered by an agent, browser worker, connector,
-     * or deep-research process.
-     */
-    sourceTexts?: AddSourceTextInput[];
-    /**
-     * Safe write protocol text. The loop parses and applies only accepted
-     * `---FILE: knowledge/...---` blocks.
-     */
-    proposalText?: string;
-    /**
-     * The researcher decides when the wiki is good enough. The loop deliberately
-     * does not encode a domain-specific definition of "done".
-     */
-    done?: boolean;
-    metadata?: Record<string, unknown>;
+  /**
+   * Free-form notes from the researcher. Keep this human-readable; products can
+   * store it as the research transcript.
+   */
+  notes?: string;
+  /**
+   * Local files to register as immutable sources before applying proposals.
+   */
+  sourcePaths?: string[];
+  /**
+   * Textual source artifacts discovered by an agent, browser worker, connector,
+   * or deep-research process.
+   */
+  sourceTexts?: AddSourceTextInput[];
+  /**
+   * Safe write protocol text. The loop parses and applies only accepted
+   * `---FILE: knowledge/...---` blocks.
+   */
+  proposalText?: string;
+  /**
+   * The researcher decides when the wiki is good enough. The loop deliberately
+   * does not encode a domain-specific definition of "done".
+   */
+  done?: boolean;
+  metadata?: Record<string, unknown>;
 }
 interface KnowledgeResearchLoopStep {
-    iteration: number;
-    notes?: string;
-    addedSources: SourceRecord[];
-    applied?: ApplyWriteBlocksResult;
-    lintFindings: KnowledgeLintFinding[];
-    validation: ValidateKnowledgeResult;
-    readiness?: EvalKnowledgeBundleBuildResult;
-    event: KnowledgeEvent;
-    done: boolean;
-    metadata?: Record<string, unknown>;
+  iteration: number;
+  notes?: string;
+  addedSources: SourceRecord[];
+  applied?: ApplyWriteBlocksResult;
+  lintFindings: KnowledgeLintFinding[];
+  validation: ValidateKnowledgeResult;
+  readiness?: EvalKnowledgeBundleBuildResult;
+  event: KnowledgeEvent;
+  done: boolean;
+  metadata?: Record<string, unknown>;
 }
 interface RunKnowledgeResearchLoopOptions {
-    root: string;
-    goal: string;
-    maxIterations?: number;
-    actor?: string;
-    strict?: ValidateKnowledgeOptions['strict'];
-    readinessSpecs?: KnowledgeReadinessSpec[];
-    readinessTaskId?: string;
-    readiness?: Omit<BuildEvalKnowledgeBundleOptions, 'taskId' | 'index' | 'specs'>;
-    sourceOptions?: Pick<AddSourceOptions, 'adapters' | 'now'>;
-    signal?: AbortSignal;
-    step(context: KnowledgeResearchLoopContext): Promise<KnowledgeResearchLoopDecision> | KnowledgeResearchLoopDecision;
-    onStep?: (step: KnowledgeResearchLoopStep) => Promise<void> | void;
+  root: string;
+  goal: string;
+  maxIterations?: number;
+  actor?: string;
+  strict?: ValidateKnowledgeOptions['strict'];
+  readinessSpecs?: KnowledgeReadinessSpec[];
+  readinessTaskId?: string;
+  readiness?: Omit<BuildEvalKnowledgeBundleOptions, 'taskId' | 'index' | 'specs'>;
+  sourceOptions?: Pick<AddSourceOptions, 'adapters' | 'now'>;
+  signal?: AbortSignal;
+  step(context: KnowledgeResearchLoopContext): Promise<KnowledgeResearchLoopDecision> | KnowledgeResearchLoopDecision;
+  onStep?: (step: KnowledgeResearchLoopStep) => Promise<void> | void;
 }
 interface KnowledgeResearchLoopResult {
-    root: string;
-    goal: string;
-    iterations: number;
-    done: boolean;
-    index: KnowledgeIndex;
-    lintFindings: KnowledgeLintFinding[];
-    validation: ValidateKnowledgeResult;
-    readiness?: EvalKnowledgeBundleBuildResult;
-    steps: KnowledgeResearchLoopStep[];
+  root: string;
+  goal: string;
+  iterations: number;
+  done: boolean;
+  index: KnowledgeIndex;
+  lintFindings: KnowledgeLintFinding[];
+  validation: ValidateKnowledgeResult;
+  readiness?: EvalKnowledgeBundleBuildResult;
+  steps: KnowledgeResearchLoopStep[];
 }
 type KnowledgeControlLoopState = KnowledgeResearchLoopContext;
 type KnowledgeControlLoopAction = KnowledgeResearchLoopDecision;
 type KnowledgeControlLoopActionResult = KnowledgeResearchLoopStep;
 interface KnowledgeControlLoopAdapterOptions {
-    root: string;
-    goal: string;
-    actor?: string;
-    strict?: ValidateKnowledgeOptions['strict'];
-    readinessSpecs?: KnowledgeReadinessSpec[];
-    readinessTaskId?: string;
-    readiness?: Omit<BuildEvalKnowledgeBundleOptions, 'taskId' | 'index' | 'specs'>;
-    sourceOptions?: Pick<AddSourceOptions, 'adapters' | 'now'>;
+  root: string;
+  goal: string;
+  actor?: string;
+  strict?: ValidateKnowledgeOptions['strict'];
+  readinessSpecs?: KnowledgeReadinessSpec[];
+  readinessTaskId?: string;
+  readiness?: Omit<BuildEvalKnowledgeBundleOptions, 'taskId' | 'index' | 'specs'>;
+  sourceOptions?: Pick<AddSourceOptions, 'adapters' | 'now'>;
 }
 type KnowledgeControlLoopAdapter = Pick<ControlRuntimeConfig<KnowledgeControlLoopState, KnowledgeControlLoopAction, KnowledgeControlLoopActionResult, ControlEvalResult>, 'intent' | 'observe' | 'validate' | 'act' | 'shouldStop'>;
 /**
@@ -773,650 +702,660 @@ type KnowledgeControlLoopAdapter = Pick<ControlRuntimeConfig<KnowledgeControlLoo
  */
 declare function createKnowledgeControlLoopAdapter(options: KnowledgeControlLoopAdapterOptions): KnowledgeControlLoopAdapter;
 declare function runKnowledgeResearchLoop(options: RunKnowledgeResearchLoopOptions): Promise<KnowledgeResearchLoopResult>;
-
+//#endregion
+//#region src/retrieval-optimization.d.ts
 type RetrievalOptimizationBaseOptions = Omit<RunSerializedKnowledgeOptimizationOptions<RetrievalConfig, RetrievalEvalScenario, RetrievalEvalArtifact>, 'baseline' | 'method' | 'trainScenarios' | 'selectionScenarios' | 'finalScenarios' | 'dispatchCandidate' | 'judges' | 'codec' | 'scenarioFingerprint'>;
 interface RunRetrievalImprovementLoopOptions extends RetrievalOptimizationBaseOptions {
-    baseline: RetrievalConfig;
-    trainScenarios: readonly RetrievalEvalScenario[];
-    selectionScenarios: readonly RetrievalEvalScenario[];
-    finalScenarios: readonly RetrievalEvalScenario[];
-    method: OptimizationMethod<RetrievalEvalScenario, RetrievalEvalArtifact>;
-    index?: KnowledgeIndex;
-    defaultK?: number;
-    retrieve?: RetrievalEvalRetriever;
-    judges?: readonly JudgeConfig<RetrievalEvalArtifact, RetrievalEvalScenario>[];
-    metricWeights?: RetrievalMetricWeights;
+  baseline: RetrievalConfig;
+  trainScenarios: readonly RetrievalEvalScenario[];
+  selectionScenarios: readonly RetrievalEvalScenario[];
+  finalScenarios: readonly RetrievalEvalScenario[];
+  method: OptimizationMethod<RetrievalEvalScenario, RetrievalEvalArtifact>;
+  index?: KnowledgeIndex;
+  defaultK?: number;
+  retrieve?: RetrievalEvalRetriever;
+  judges?: readonly JudgeConfig<RetrievalEvalArtifact, RetrievalEvalScenario>[];
+  metricWeights?: RetrievalMetricWeights;
 }
 interface RunRetrievalImprovementLoopResult extends RunSerializedKnowledgeOptimizationResult<RetrievalConfig> {
-    baselineConfig: RetrievalConfig;
-    winnerConfig: RetrievalConfig;
-    trainScenarios: readonly RetrievalEvalScenario[];
-    selectionScenarios: readonly RetrievalEvalScenario[];
-    finalScenarios: readonly RetrievalEvalScenario[];
+  baselineConfig: RetrievalConfig;
+  winnerConfig: RetrievalConfig;
+  trainScenarios: readonly RetrievalEvalScenario[];
+  selectionScenarios: readonly RetrievalEvalScenario[];
+  finalScenarios: readonly RetrievalEvalScenario[];
 }
 declare function runRetrievalImprovementLoop(options: RunRetrievalImprovementLoopOptions): Promise<RunRetrievalImprovementLoopResult>;
-
+//#endregion
+//#region src/rag-improvement-loop.d.ts
 type RagKnowledgeImprovementPhase = 'rag-optimization' | 'retrieval-tuning' | 'gap-diagnosis' | 'knowledge-acquisition' | 'knowledge-update' | 'answer-quality' | 'promotion';
 type RagKnowledgeImprovementPhaseStatus = 'completed' | 'skipped' | 'failed';
 type RagGapKind = 'missing-source' | 'stale-source' | 'retrieval-miss' | 'retrieval-noise' | 'chunking-mismatch' | 'missing-multihop-evidence' | 'generator-unsupported-claim' | 'citation-mismatch' | 'incorrect-abstention' | 'unknown';
 type RagGapSeverity = 'info' | 'warning' | 'error' | 'critical';
 interface RagGapFinding {
-    id: string;
-    kind: RagGapKind;
-    severity: RagGapSeverity;
-    message: string;
-    scenarioId?: string;
-    evidence?: Record<string, AgentCandidateJsonValue>;
+  id: string;
+  kind: RagGapKind;
+  severity: RagGapSeverity;
+  message: string;
+  scenarioId?: string;
+  evidence?: Record<string, AgentCandidateJsonValue>;
 }
 interface RagKnowledgeImprovementPhaseResult {
-    phase: RagKnowledgeImprovementPhase;
-    status: RagKnowledgeImprovementPhaseStatus;
-    summary: string;
-    startedAt: string;
-    finishedAt: string;
-    metadata?: Record<string, AgentCandidateJsonValue>;
+  phase: RagKnowledgeImprovementPhase;
+  status: RagKnowledgeImprovementPhaseStatus;
+  summary: string;
+  startedAt: string;
+  finishedAt: string;
+  metadata?: Record<string, AgentCandidateJsonValue>;
 }
 type RagOptimizationSelection = Pick<RunRagOptimizationResult, 'methodName' | 'baseline' | 'winner' | 'baselineConfig' | 'winnerConfig'>;
 type RetrievalOptimizationSelection = Pick<RunRetrievalImprovementLoopResult, 'methodName' | 'baseline' | 'winner' | 'baselineConfig' | 'winnerConfig'>;
 interface RagPhaseInputBase {
-    goal: string;
-    phases: readonly RagKnowledgeImprovementPhaseResult[];
-    /** Selected candidate only. Adaptive update callbacks run before final scoring starts. */
-    optimization?: RagOptimizationSelection;
-    signal?: AbortSignal;
+  goal: string;
+  phases: readonly RagKnowledgeImprovementPhaseResult[];
+  /** Selected candidate only. Adaptive update callbacks run before final scoring starts. */
+  optimization?: RagOptimizationSelection;
+  signal?: AbortSignal;
 }
 interface RagDiagnosisInput extends RagPhaseInputBase {
-    retrieval?: RetrievalOptimizationSelection;
+  retrieval?: RetrievalOptimizationSelection;
 }
 interface RagKnowledgeAcquisitionInput extends RagPhaseInputBase {
-    retrieval?: RetrievalOptimizationSelection;
-    findings: readonly RagGapFinding[];
+  retrieval?: RetrievalOptimizationSelection;
+  findings: readonly RagGapFinding[];
 }
 interface RagKnowledgeUpdateInput extends RagPhaseInputBase {
-    retrieval?: RetrievalOptimizationSelection;
-    findings: readonly RagGapFinding[];
-    acquisition?: KnowledgeResearchLoopDecision;
+  retrieval?: RetrievalOptimizationSelection;
+  findings: readonly RagGapFinding[];
+  acquisition?: KnowledgeResearchLoopDecision;
 }
 interface RagKnowledgeUpdateResult {
-    applied: boolean;
-    summary: string;
-    research?: KnowledgeResearchLoopResult;
-    metadata?: Record<string, AgentCandidateJsonValue>;
+  applied: boolean;
+  summary: string;
+  research?: KnowledgeResearchLoopResult;
+  metadata?: Record<string, AgentCandidateJsonValue>;
 }
 interface RagAnswerQualityInput extends RagPhaseInputBase {
-    retrieval?: RetrievalOptimizationSelection;
-    findings: readonly RagGapFinding[];
-    acquisition?: KnowledgeResearchLoopDecision;
-    knowledgeUpdate?: RagKnowledgeUpdateResult;
+  retrieval?: RetrievalOptimizationSelection;
+  findings: readonly RagGapFinding[];
+  acquisition?: KnowledgeResearchLoopDecision;
+  knowledgeUpdate?: RagKnowledgeUpdateResult;
 }
 interface RagAnswerQualityResult {
-    passed: boolean;
-    metrics: Record<string, number>;
-    finalScenarioIds: readonly string[];
-    datasetRef: string;
-    evaluatorRef: string;
-    cost: ComparisonCost;
-    findings?: readonly RagGapFinding[];
-    metadata?: Record<string, AgentCandidateJsonValue>;
+  passed: boolean;
+  metrics: Record<string, number>;
+  finalScenarioIds: readonly string[];
+  datasetRef: string;
+  evaluatorRef: string;
+  cost: ComparisonCost;
+  findings?: readonly RagGapFinding[];
+  metadata?: Record<string, AgentCandidateJsonValue>;
 }
 interface RagPromotionInput extends RagPhaseInputBase {
-    retrieval?: RetrievalOptimizationSelection;
-    /** Full final-case result available only to the terminal promotion decision. */
-    optimizationComparison?: RunRagOptimizationResult['comparison'];
-    /** Full final-case result available only to the terminal promotion decision. */
-    retrievalComparison?: RunRetrievalImprovementLoopResult['comparison'];
-    findings: readonly RagGapFinding[];
-    acquisition?: KnowledgeResearchLoopDecision;
-    knowledgeUpdate?: RagKnowledgeUpdateResult;
-    answerQuality?: RagAnswerQualityResult;
+  retrieval?: RetrievalOptimizationSelection;
+  /** Full final-case result available only to the terminal promotion decision. */
+  optimizationComparison?: RunRagOptimizationResult['comparison'];
+  /** Full final-case result available only to the terminal promotion decision. */
+  retrievalComparison?: RunRetrievalImprovementLoopResult['comparison'];
+  findings: readonly RagGapFinding[];
+  acquisition?: KnowledgeResearchLoopDecision;
+  knowledgeUpdate?: RagKnowledgeUpdateResult;
+  answerQuality?: RagAnswerQualityResult;
 }
 interface RagPromotionResult {
-    promoted: boolean;
-    reason: string;
-    metadata?: Record<string, AgentCandidateJsonValue>;
+  promoted: boolean;
+  reason: string;
+  metadata?: Record<string, AgentCandidateJsonValue>;
 }
 interface RagKnowledgeResearchOptions extends Omit<RunKnowledgeResearchLoopOptions, 'goal' | 'signal' | 'step'> {
-    goal?: string;
-    step?: RunKnowledgeResearchLoopOptions['step'];
+  goal?: string;
+  step?: RunKnowledgeResearchLoopOptions['step'];
 }
 interface RunRagKnowledgeImprovementLoopOptions {
-    goal: string;
-    optimization?: RunRagOptimizationOptions;
-    retrieval?: RunRetrievalImprovementLoopOptions;
-    diagnose?: (input: RagDiagnosisInput) => MaybePromise$1<readonly RagGapFinding[]>;
-    acquireKnowledge?: (input: RagKnowledgeAcquisitionInput) => MaybePromise$1<KnowledgeResearchLoopDecision>;
-    knowledgeResearch?: RagKnowledgeResearchOptions;
-    updateKnowledge?: (input: RagKnowledgeUpdateInput) => MaybePromise$1<RagKnowledgeUpdateResult>;
-    evaluateAnswers?: (input: RagAnswerQualityInput) => MaybePromise$1<RagAnswerQualityResult>;
-    /** Maximum total answer-evaluation spend accepted for promotion. */
-    answerQualityCostCeiling?: number;
-    /**
-     * Makes a side-effect-free promotion decision after the library has rejected
-     * missing, regressing, unaccounted, or over-budget final evidence.
-     */
-    decidePromotion?: (input: RagPromotionInput) => MaybePromise$1<RagPromotionResult>;
-    enabledPhases?: readonly RagKnowledgeImprovementPhase[];
-    requiredPhases?: readonly RagKnowledgeImprovementPhase[];
-    signal?: AbortSignal;
-    now?: () => Date;
+  goal: string;
+  optimization?: RunRagOptimizationOptions;
+  retrieval?: RunRetrievalImprovementLoopOptions;
+  diagnose?: (input: RagDiagnosisInput) => MaybePromise$1<readonly RagGapFinding[]>;
+  acquireKnowledge?: (input: RagKnowledgeAcquisitionInput) => MaybePromise$1<KnowledgeResearchLoopDecision>;
+  knowledgeResearch?: RagKnowledgeResearchOptions;
+  updateKnowledge?: (input: RagKnowledgeUpdateInput) => MaybePromise$1<RagKnowledgeUpdateResult>;
+  evaluateAnswers?: (input: RagAnswerQualityInput) => MaybePromise$1<RagAnswerQualityResult>;
+  /** Maximum total answer-evaluation spend accepted for promotion. */
+  answerQualityCostCeiling?: number;
+  /**
+   * Makes a side-effect-free promotion decision after the library has rejected
+   * missing, regressing, unaccounted, or over-budget final evidence.
+   */
+  decidePromotion?: (input: RagPromotionInput) => MaybePromise$1<RagPromotionResult>;
+  enabledPhases?: readonly RagKnowledgeImprovementPhase[];
+  requiredPhases?: readonly RagKnowledgeImprovementPhase[];
+  signal?: AbortSignal;
+  now?: () => Date;
 }
 interface RunRagKnowledgeImprovementLoopResult {
-    goal: string;
-    phases: readonly RagKnowledgeImprovementPhaseResult[];
-    optimization?: RunRagOptimizationResult;
-    retrieval?: RunRetrievalImprovementLoopResult;
-    findings: readonly RagGapFinding[];
-    acquisition?: KnowledgeResearchLoopDecision;
-    knowledgeUpdate?: RagKnowledgeUpdateResult;
-    answerQuality?: RagAnswerQualityResult;
-    promotion?: RagPromotionResult;
+  goal: string;
+  phases: readonly RagKnowledgeImprovementPhaseResult[];
+  optimization?: RunRagOptimizationResult;
+  retrieval?: RunRetrievalImprovementLoopResult;
+  findings: readonly RagGapFinding[];
+  acquisition?: KnowledgeResearchLoopDecision;
+  knowledgeUpdate?: RagKnowledgeUpdateResult;
+  answerQuality?: RagAnswerQualityResult;
+  promotion?: RagPromotionResult;
 }
 type MaybePromise$1<T> = T | Promise<T>;
 declare function runRagKnowledgeImprovementLoop(options: RunRagKnowledgeImprovementLoopOptions): Promise<RunRagKnowledgeImprovementLoopResult>;
-
+//#endregion
+//#region src/rag-eval/contracts.d.ts
 type RagEvalProvider = 'agent-knowledge' | 'ragas' | 'deepeval' | 'trulens' | 'ragchecker' | 'custom';
 type RagEvalMetricKey = 'context_precision' | 'context_recall' | 'context_relevance' | 'context_sufficiency' | 'faithfulness' | 'groundedness' | 'answer_relevance' | 'answer_correctness' | 'citation_support' | 'abstention' | 'unsupported_answer_rate';
 type RagEvalSlice = 'known-answer' | 'paraphrase' | 'distractor' | 'freshness' | 'multi-source' | 'unanswerable' | 'long-tail' | 'custom';
 interface RagEvalContext {
-    id: string;
-    text: string;
-    rank?: number;
-    pageId?: string;
-    sourceId?: string;
-    anchorId?: string;
-    stale?: boolean;
-    metadata?: Record<string, AgentCandidateJsonValue>;
+  id: string;
+  text: string;
+  rank?: number;
+  pageId?: string;
+  sourceId?: string;
+  anchorId?: string;
+  stale?: boolean;
+  metadata?: Record<string, AgentCandidateJsonValue>;
 }
 interface RagEvalCitation {
-    id: string;
-    claimId?: string;
-    contextId?: string;
-    pageId?: string;
-    sourceId?: string;
-    anchorId?: string;
-    quote?: string;
-    metadata?: Record<string, AgentCandidateJsonValue>;
+  id: string;
+  claimId?: string;
+  contextId?: string;
+  pageId?: string;
+  sourceId?: string;
+  anchorId?: string;
+  quote?: string;
+  metadata?: Record<string, AgentCandidateJsonValue>;
 }
 interface RagEvalClaim {
-    id: string;
-    text: string;
-    citationIds?: readonly string[];
-    metadata?: Record<string, AgentCandidateJsonValue>;
+  id: string;
+  text: string;
+  citationIds?: readonly string[];
+  metadata?: Record<string, AgentCandidateJsonValue>;
 }
 interface RagRequiredContext {
-    id?: string;
-    text?: string;
-    pageId?: string;
-    sourceId?: string;
-    anchorId?: string;
+  id?: string;
+  text?: string;
+  pageId?: string;
+  sourceId?: string;
+  anchorId?: string;
 }
 interface RagAnswerEvalScenario extends Scenario {
-    kind: 'rag-answer-eval';
-    query: string;
-    referenceAnswer?: string;
-    expectedClaims?: readonly string[];
-    forbiddenClaims?: readonly string[];
-    requiredContext?: readonly RagRequiredContext[];
-    unanswerable?: boolean;
-    requireCitations?: boolean;
-    slices?: readonly RagEvalSlice[];
-    thresholds?: Partial<Record<RagEvalMetricKey, number>>;
+  kind: 'rag-answer-eval';
+  query: string;
+  referenceAnswer?: string;
+  expectedClaims?: readonly string[];
+  forbiddenClaims?: readonly string[];
+  requiredContext?: readonly RagRequiredContext[];
+  unanswerable?: boolean;
+  requireCitations?: boolean;
+  slices?: readonly RagEvalSlice[];
+  thresholds?: Partial<Record<RagEvalMetricKey, number>>;
 }
 interface ExternalRagEvalScore {
-    provider: RagEvalProvider | string;
-    scores: Record<string, number>;
-    reasons?: Record<string, string>;
-    metadata?: Record<string, AgentCandidateJsonValue>;
+  provider: RagEvalProvider | string;
+  scores: Record<string, number>;
+  reasons?: Record<string, string>;
+  metadata?: Record<string, AgentCandidateJsonValue>;
 }
 interface RagAnswerEvalArtifact {
-    query: string;
-    answer: string;
-    contexts: readonly RagEvalContext[];
-    claims?: readonly RagEvalClaim[];
-    citations?: readonly RagEvalCitation[];
-    abstained?: boolean;
-    durationMs?: number;
-    costUsd?: number;
-    externalScores?: readonly ExternalRagEvalScore[];
-    metadata?: Record<string, AgentCandidateJsonValue>;
+  query: string;
+  answer: string;
+  contexts: readonly RagEvalContext[];
+  claims?: readonly RagEvalClaim[];
+  citations?: readonly RagEvalCitation[];
+  abstained?: boolean;
+  durationMs?: number;
+  costUsd?: number;
+  externalScores?: readonly ExternalRagEvalScore[];
+  metadata?: Record<string, AgentCandidateJsonValue>;
 }
 interface RagAnswerMetricSummary {
-    metrics: Record<RagEvalMetricKey, number>;
-    composite: number;
-    passed: boolean;
-    findings: readonly RagGapFinding[];
-    claimCount: number;
-    supportedClaimCount: number;
-    citedClaimCount: number;
-    supportedCitationCount: number;
-    matchedRequiredContextCount: number;
-    requiredContextCount: number;
-    providerScores: Record<string, Record<RagEvalMetricKey, number>>;
+  metrics: Record<RagEvalMetricKey, number>;
+  composite: number;
+  passed: boolean;
+  findings: readonly RagGapFinding[];
+  claimCount: number;
+  supportedClaimCount: number;
+  citedClaimCount: number;
+  supportedCitationCount: number;
+  matchedRequiredContextCount: number;
+  requiredContextCount: number;
+  providerScores: Record<string, Record<RagEvalMetricKey, number>>;
 }
 interface RagAnswerQualityJudgeOptions {
-    name?: string;
-    thresholds?: Partial<Record<RagEvalMetricKey, number>>;
-    weights?: Partial<Record<RagEvalMetricKey, number>>;
-    externalScorePolicy?: 'prefer-external' | 'deterministic-first';
-    minClaimSupport?: number;
+  name?: string;
+  thresholds?: Partial<Record<RagEvalMetricKey, number>>;
+  weights?: Partial<Record<RagEvalMetricKey, number>>;
+  externalScorePolicy?: 'prefer-external' | 'deterministic-first';
+  minClaimSupport?: number;
 }
 interface RagAnswerEvalCase {
-    scenario: RagAnswerEvalScenario;
-    artifact: RagAnswerEvalArtifact;
+  scenario: RagAnswerEvalScenario;
+  artifact: RagAnswerEvalArtifact;
 }
 interface RagAnswerQualityHookOptions {
-    scenarios: readonly RagAnswerEvalScenario[];
-    /** Immutable identity of generation, scoring, models, and external evaluator behavior. */
-    evaluatorRef: string;
-    /** Return observed spend after all generation and evaluation calls finish. */
-    cost: ComparisonCost | (() => MaybePromise<ComparisonCost>);
-    run: (scenario: RagAnswerEvalScenario) => MaybePromise<RagAnswerEvalArtifact>;
-    externalEvaluator?: (item: RagAnswerEvalCase) => MaybePromise<ExternalRagEvalScore | readonly ExternalRagEvalScore[] | undefined>;
-    thresholds?: Partial<Record<RagEvalMetricKey, number>>;
-    weights?: Partial<Record<RagEvalMetricKey, number>>;
+  scenarios: readonly RagAnswerEvalScenario[];
+  /** Immutable identity of generation, scoring, models, and external evaluator behavior. */
+  evaluatorRef: string;
+  /** Return observed spend after all generation and evaluation calls finish. */
+  cost: ComparisonCost | (() => MaybePromise<ComparisonCost>);
+  run: (scenario: RagAnswerEvalScenario) => MaybePromise<RagAnswerEvalArtifact>;
+  externalEvaluator?: (item: RagAnswerEvalCase) => MaybePromise<ExternalRagEvalScore | readonly ExternalRagEvalScore[] | undefined>;
+  thresholds?: Partial<Record<RagEvalMetricKey, number>>;
+  weights?: Partial<Record<RagEvalMetricKey, number>>;
 }
 interface RagCalibrationOptions {
-    scenario: RagAnswerEvalScenario;
-    strong: RagAnswerEvalArtifact;
-    weak: RagAnswerEvalArtifact;
-    judge?: JudgeConfig<RagAnswerEvalArtifact, RagAnswerEvalScenario>;
-    minStrongScore?: number;
-    maxWeakScore?: number;
-    signal?: AbortSignal;
+  scenario: RagAnswerEvalScenario;
+  strong: RagAnswerEvalArtifact;
+  weak: RagAnswerEvalArtifact;
+  judge?: JudgeConfig<RagAnswerEvalArtifact, RagAnswerEvalScenario>;
+  minStrongScore?: number;
+  maxWeakScore?: number;
+  signal?: AbortSignal;
 }
 interface RagCalibrationResult {
-    passed: boolean;
-    strongScore: number;
-    weakScore: number;
-    gap: number;
+  passed: boolean;
+  strongScore: number;
+  weakScore: number;
+  gap: number;
 }
 interface KnowledgeBaseQualityOptions {
-    now?: Date;
-    strict?: boolean;
-    minCitationRate?: number;
-    maxStaleSourceRate?: number;
+  now?: Date;
+  strict?: boolean;
+  minCitationRate?: number;
+  maxStaleSourceRate?: number;
 }
 interface KnowledgeBaseQualityReport {
-    ok: boolean;
-    metrics: {
-        page_count: number;
-        source_count: number;
-        citation_rate: number;
-        source_backed_page_rate: number;
-        stale_source_rate: number;
-        duplicate_source_hash_rate: number;
-        lint_error_count: number;
-        lint_warning_count: number;
-    };
-    findings: readonly RagGapFinding[];
+  ok: boolean;
+  metrics: {
+    page_count: number;
+    source_count: number;
+    citation_rate: number;
+    source_backed_page_rate: number;
+    stale_source_rate: number;
+    duplicate_source_hash_rate: number;
+    lint_error_count: number;
+    lint_warning_count: number;
+  };
+  findings: readonly RagGapFinding[];
 }
 type MaybePromise<T> = T | Promise<T>;
-
+//#endregion
+//#region src/rag-eval/calibration.d.ts
 declare function createRagAnswerQualityHook(options: RagAnswerQualityHookOptions): () => Promise<RagAnswerQualityResult>;
 declare function calibrateRagAnswerJudge(options: RagCalibrationOptions): Promise<RagCalibrationResult>;
-
+//#endregion
+//#region src/rag-eval/knowledge-base.d.ts
 declare function scoreKnowledgeBaseIndex(index: KnowledgeIndex, options?: KnowledgeBaseQualityOptions): KnowledgeBaseQualityReport;
-
+//#endregion
+//#region src/rag-eval/providers.d.ts
 declare function normalizeExternalRagScores(scores: readonly ExternalRagEvalScore[]): Record<string, Record<RagEvalMetricKey, number>>;
 declare function toRagasEvaluationRows(cases: readonly RagAnswerEvalCase[]): {
-    user_input: string;
-    response: string;
-    retrieved_contexts: string[];
-    reference: string | undefined;
-    reference_contexts: string[];
+  user_input: string;
+  response: string;
+  retrieved_contexts: string[];
+  reference: string | undefined;
+  reference_contexts: string[];
 }[];
 declare function toDeepEvalTestCases(cases: readonly RagAnswerEvalCase[]): {
-    input: string;
-    actual_output: string;
-    expected_output: string | undefined;
-    retrieval_context: string[];
-    context: string[];
+  input: string;
+  actual_output: string;
+  expected_output: string | undefined;
+  retrieval_context: string[];
+  context: string[];
 }[];
 declare function toTruLensRecords(cases: readonly RagAnswerEvalCase[]): {
-    input: string;
-    output: string;
-    context: string;
+  input: string;
+  output: string;
+  context: string;
 }[];
 declare function toRagCheckerRecords(cases: readonly RagAnswerEvalCase[]): {
-    query_id: string;
-    query: string;
-    gt_answer: string | undefined;
-    response: string;
-    retrieved_context: {
-        doc_id: string;
-        text: string;
-    }[];
-    claims: string[];
+  query_id: string;
+  query: string;
+  gt_answer: string | undefined;
+  response: string;
+  retrieved_context: {
+    doc_id: string;
+    text: string;
+  }[];
+  claims: string[];
 }[];
-
+//#endregion
+//#region src/rag-eval/scoring.d.ts
 declare function ragAnswerQualityJudge(options?: RagAnswerQualityJudgeOptions): JudgeConfig<RagAnswerEvalArtifact, RagAnswerEvalScenario>;
 declare function scoreRagAnswerArtifact(artifact: RagAnswerEvalArtifact, scenario: RagAnswerEvalScenario, options?: RagAnswerQualityJudgeOptions): RagAnswerMetricSummary;
 declare function diagnoseRagAnswerFailure(metrics: Record<RagEvalMetricKey, number>, scenario: RagAnswerEvalScenario, thresholds?: Partial<Record<RagEvalMetricKey, number>>): RagGapFinding[];
-
+//#endregion
+//#region src/kb-improvement/contracts.d.ts
 type KnowledgeImprovementStatus = 'running' | 'candidate-ready' | 'promoted' | 'rejected' | 'blocked';
 interface KnowledgeImprovementMetricProvenanceBase {
-    evaluator: string;
-    version: string;
+  evaluator: string;
+  version: string;
 }
 type KnowledgeImprovementMetricProvenance = (KnowledgeImprovementMetricProvenanceBase & {
-    method: 'deterministic';
+  method: 'deterministic';
 }) | (KnowledgeImprovementMetricProvenanceBase & {
-    method: 'sampled' | 'composite';
-    corpusHash: string;
-    runRecords: RunRecord[];
+  method: 'sampled' | 'composite';
+  corpusHash: string;
+  runRecords: RunRecord[];
 }) | (KnowledgeImprovementMetricProvenanceBase & {
-    method: 'model';
-    model: string;
-    corpusHash: string;
-    runRecords: RunRecord[];
+  method: 'model';
+  model: string;
+  corpusHash: string;
+  runRecords: RunRecord[];
 });
 interface KnowledgeImprovementMetric {
-    score: number;
-    passed: boolean;
-    dimensions?: Record<string, number>;
-    notes?: string;
-    provenance: KnowledgeImprovementMetricProvenance;
+  score: number;
+  passed: boolean;
+  dimensions?: Record<string, number>;
+  notes?: string;
+  provenance: KnowledgeImprovementMetricProvenance;
 }
 interface KnowledgeImprovementEvaluationInput {
-    runId: string;
-    iteration: number;
-    root: string;
-    baselineRoot: string;
-    candidateRoot: string;
-    baselineIndex: KnowledgeIndex;
-    candidateIndex: KnowledgeIndex;
-    baseHash: string;
-    candidateHash: string;
-    validation: ValidateKnowledgeResult;
-    readiness?: EvalKnowledgeBundleBuildResult;
-    kbQuality: KnowledgeBaseQualityReport;
-    lifecycle?: RunRagKnowledgeImprovementLoopResult;
-    signal?: AbortSignal;
+  runId: string;
+  iteration: number;
+  root: string;
+  baselineRoot: string;
+  candidateRoot: string;
+  baselineIndex: KnowledgeIndex;
+  candidateIndex: KnowledgeIndex;
+  baseHash: string;
+  candidateHash: string;
+  validation: ValidateKnowledgeResult;
+  readiness?: EvalKnowledgeBundleBuildResult;
+  kbQuality: KnowledgeBaseQualityReport;
+  lifecycle?: RunRagKnowledgeImprovementLoopResult;
+  signal?: AbortSignal;
 }
 type KnowledgeImprovementEvaluator = (input: KnowledgeImprovementEvaluationInput) => Promise<KnowledgeImprovementMetric> | KnowledgeImprovementMetric;
 interface KnowledgeImprovementCandidateRecord {
-    iteration: number;
-    candidateId: string;
-    baseHash: string;
-    candidateHash?: string;
-    evidenceHash?: string;
-    promotionPlanHash?: string;
-    /** Durable one-way boundary preventing final-case reuse after interruption. */
-    finalEvaluationStartedAt?: string;
-    status: KnowledgeImprovementStatus;
-    createdAt: string;
-    updatedAt: string;
+  iteration: number;
+  candidateId: string;
+  baseHash: string;
+  candidateHash?: string;
+  evidenceHash?: string;
+  promotionPlanHash?: string;
+  /** Durable one-way boundary preventing final-case reuse after interruption. */
+  finalEvaluationStartedAt?: string;
+  status: KnowledgeImprovementStatus;
+  createdAt: string;
+  updatedAt: string;
 }
 interface KnowledgeImprovementRunState {
-    runId: string;
-    root: string;
-    goal: string;
-    implementationRef: string;
-    status: KnowledgeImprovementStatus;
-    baseHash: string;
-    createdAt: string;
-    updatedAt: string;
-    ownerId?: string;
-    candidates: KnowledgeImprovementCandidateRecord[];
-    promotedCandidateId?: string;
-    blockedReason?: string;
+  runId: string;
+  root: string;
+  goal: string;
+  implementationRef: string;
+  status: KnowledgeImprovementStatus;
+  baseHash: string;
+  createdAt: string;
+  updatedAt: string;
+  ownerId?: string;
+  candidates: KnowledgeImprovementCandidateRecord[];
+  promotedCandidateId?: string;
+  blockedReason?: string;
 }
 interface KnowledgeImprovementResult {
-    runId: string;
-    state: KnowledgeImprovementRunState;
-    candidate?: KnowledgeImprovementCandidateRecord;
-    evaluation?: KnowledgeImprovementMetric;
-    lifecycle?: RunRagKnowledgeImprovementLoopResult;
-    promoted: boolean;
-    blocked: boolean;
+  runId: string;
+  state: KnowledgeImprovementRunState;
+  candidate?: KnowledgeImprovementCandidateRecord;
+  evaluation?: KnowledgeImprovementMetric;
+  lifecycle?: RunRagKnowledgeImprovementLoopResult;
+  promoted: boolean;
+  blocked: boolean;
 }
 type KnowledgeImprovementTarget = 'candidate' | 'baseline';
 interface KnowledgeImprovementMutationReceipt {
-    target: KnowledgeImprovementTarget;
-    beforeHash: string;
-    afterHash: string;
-    changed: boolean;
-    transactionId: string | null;
-    recovered: boolean;
+  target: KnowledgeImprovementTarget;
+  beforeHash: string;
+  afterHash: string;
+  changed: boolean;
+  transactionId: string | null;
+  recovered: boolean;
 }
 interface KnowledgeImprovementMutationResult extends KnowledgeImprovementResult {
-    candidate: KnowledgeImprovementCandidateRecord;
-    mutation: KnowledgeImprovementMutationReceipt;
-    activationResult?: AgentImprovementActivationResult;
+  candidate: KnowledgeImprovementCandidateRecord;
+  mutation: KnowledgeImprovementMutationReceipt;
+  activationResult?: AgentImprovementActivationResult;
 }
 interface KnowledgeImprovementActivationPersistence {
-    activation: AgentImprovementActivation;
-    attemptedAt: string;
-    identity: string;
-    /** May run again after interruption; keep this deterministic and free of external side effects. */
-    createResult(mutation: KnowledgeImprovementMutationReceipt): Promise<AgentImprovementActivationResult> | AgentImprovementActivationResult;
+  activation: AgentImprovementActivation;
+  attemptedAt: string;
+  identity: string;
+  /** May run again after interruption; keep this deterministic and free of external side effects. */
+  createResult(mutation: KnowledgeImprovementMutationReceipt): Promise<AgentImprovementActivationResult> | AgentImprovementActivationResult;
 }
 declare const KnowledgeImprovementRunStateSchema: z.ZodObject<{
-    runId: z.ZodString;
-    root: z.ZodString;
-    goal: z.ZodString;
-    implementationRef: z.ZodString;
+  runId: z.ZodString;
+  root: z.ZodString;
+  goal: z.ZodString;
+  implementationRef: z.ZodString;
+  status: z.ZodEnum<{
+    blocked: "blocked";
+    "candidate-ready": "candidate-ready";
+    promoted: "promoted";
+    rejected: "rejected";
+    running: "running";
+  }>;
+  baseHash: z.ZodString;
+  createdAt: z.ZodISODateTime;
+  updatedAt: z.ZodISODateTime;
+  ownerId: z.ZodOptional<z.ZodString>;
+  candidates: z.ZodArray<z.ZodObject<{
+    iteration: z.ZodNumber;
+    candidateId: z.ZodString;
+    baseHash: z.ZodString;
+    candidateHash: z.ZodOptional<z.ZodString>;
+    evidenceHash: z.ZodOptional<z.ZodString>;
+    promotionPlanHash: z.ZodOptional<z.ZodString>;
+    finalEvaluationStartedAt: z.ZodOptional<z.ZodISODateTime>;
     status: z.ZodEnum<{
-        rejected: "rejected";
-        promoted: "promoted";
-        running: "running";
-        "candidate-ready": "candidate-ready";
-        blocked: "blocked";
+      blocked: "blocked";
+      "candidate-ready": "candidate-ready";
+      promoted: "promoted";
+      rejected: "rejected";
+      running: "running";
     }>;
-    baseHash: z.ZodString;
     createdAt: z.ZodISODateTime;
     updatedAt: z.ZodISODateTime;
-    ownerId: z.ZodOptional<z.ZodString>;
-    candidates: z.ZodArray<z.ZodObject<{
-        iteration: z.ZodNumber;
-        candidateId: z.ZodString;
-        baseHash: z.ZodString;
-        candidateHash: z.ZodOptional<z.ZodString>;
-        evidenceHash: z.ZodOptional<z.ZodString>;
-        promotionPlanHash: z.ZodOptional<z.ZodString>;
-        finalEvaluationStartedAt: z.ZodOptional<z.ZodISODateTime>;
-        status: z.ZodEnum<{
-            rejected: "rejected";
-            promoted: "promoted";
-            running: "running";
-            "candidate-ready": "candidate-ready";
-            blocked: "blocked";
-        }>;
-        createdAt: z.ZodISODateTime;
-        updatedAt: z.ZodISODateTime;
-    }, z.core.$strict>>;
-    promotedCandidateId: z.ZodOptional<z.ZodString>;
-    blockedReason: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  promotedCandidateId: z.ZodOptional<z.ZodString>;
+  blockedReason: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 declare const KnowledgeImprovementEvidenceSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"knowledge-improvement-evidence">;
-    runId: z.ZodString;
-    candidateId: z.ZodString;
-    iteration: z.ZodNumber;
-    goalHash: z.ZodString;
-    implementationRef: z.ZodString;
-    baseHash: z.ZodString;
-    candidateHash: z.ZodString;
-    promotionPlanHash: z.ZodString;
-    validation: z.ZodUnknown;
-    readiness: z.ZodNullable<z.ZodUnknown>;
-    kbQuality: z.ZodUnknown;
-    evaluation: z.ZodObject<{
-        score: z.ZodNumber;
-        passed: z.ZodBoolean;
-        dimensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
-        notes: z.ZodOptional<z.ZodString>;
-        provenance: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            evaluator: z.ZodString;
-            version: z.ZodString;
-            method: z.ZodLiteral<"deterministic">;
-        }, z.core.$strict>, z.ZodObject<{
-            evaluator: z.ZodString;
-            version: z.ZodString;
-            method: z.ZodEnum<{
-                composite: "composite";
-                sampled: "sampled";
-            }>;
-            corpusHash: z.ZodString;
-            runRecords: z.ZodArray<z.ZodCustom<RunRecord, RunRecord>>;
-        }, z.core.$strict>, z.ZodObject<{
-            evaluator: z.ZodString;
-            version: z.ZodString;
-            method: z.ZodLiteral<"model">;
-            model: z.ZodString;
-            corpusHash: z.ZodString;
-            runRecords: z.ZodArray<z.ZodCustom<RunRecord, RunRecord>>;
-        }, z.core.$strict>], "method">;
-    }, z.core.$strict>;
-    lifecycle: z.ZodNullable<z.ZodUnknown>;
+  kind: z.ZodLiteral<"knowledge-improvement-evidence">;
+  runId: z.ZodString;
+  candidateId: z.ZodString;
+  iteration: z.ZodNumber;
+  goalHash: z.ZodString;
+  implementationRef: z.ZodString;
+  baseHash: z.ZodString;
+  candidateHash: z.ZodString;
+  promotionPlanHash: z.ZodString;
+  validation: z.ZodUnknown;
+  readiness: z.ZodNullable<z.ZodUnknown>;
+  kbQuality: z.ZodUnknown;
+  evaluation: z.ZodObject<{
+    score: z.ZodNumber;
+    passed: z.ZodBoolean;
+    dimensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    notes: z.ZodOptional<z.ZodString>;
+    provenance: z.ZodDiscriminatedUnion<[z.ZodObject<{
+      evaluator: z.ZodString;
+      version: z.ZodString;
+      method: z.ZodLiteral<"deterministic">;
+    }, z.core.$strict>, z.ZodObject<{
+      evaluator: z.ZodString;
+      version: z.ZodString;
+      method: z.ZodEnum<{
+        composite: "composite";
+        sampled: "sampled";
+      }>;
+      corpusHash: z.ZodString;
+      runRecords: z.ZodArray<z.ZodCustom<RunRecord, RunRecord>>;
+    }, z.core.$strict>, z.ZodObject<{
+      evaluator: z.ZodString;
+      version: z.ZodString;
+      method: z.ZodLiteral<"model">;
+      model: z.ZodString;
+      corpusHash: z.ZodString;
+      runRecords: z.ZodArray<z.ZodCustom<RunRecord, RunRecord>>;
+    }, z.core.$strict>], "method">;
+  }, z.core.$strict>;
+  lifecycle: z.ZodNullable<z.ZodUnknown>;
 }, z.core.$strict>;
 type KnowledgeImprovementEvidence = z.infer<typeof KnowledgeImprovementEvidenceSchema>;
 /** Portable identity of one measured candidate. Paths and mutable run state are deliberately excluded. */
 declare const KnowledgeImprovementCandidateRefSchema: 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;
+  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>;
 type KnowledgeImprovementCandidateRef = z.infer<typeof KnowledgeImprovementCandidateRefSchema>;
 interface PromoteKnowledgeCandidateOptions {
-    root: string;
-    candidate: KnowledgeImprovementCandidateRef;
-    activation?: KnowledgeImprovementActivationPersistence;
-    ownerId?: string;
-    leaseTtlMs?: number;
-    now?: () => Date;
-    onState?: (state: KnowledgeImprovementRunState) => Promise<void> | void;
+  root: string;
+  candidate: KnowledgeImprovementCandidateRef;
+  activation?: KnowledgeImprovementActivationPersistence;
+  ownerId?: string;
+  leaseTtlMs?: number;
+  now?: () => Date;
+  onState?: (state: KnowledgeImprovementRunState) => Promise<void> | void;
 }
 type RestoreKnowledgeCandidateBaselineOptions = PromoteKnowledgeCandidateOptions;
 interface LoadKnowledgeImprovementActivationResultOptions {
-    root: string;
-    candidate: KnowledgeImprovementCandidateRef;
-    activation: AgentImprovementActivation;
-    identity: string;
+  root: string;
+  candidate: KnowledgeImprovementCandidateRef;
+  activation: AgentImprovementActivation;
+  identity: string;
 }
 interface UseKnowledgeImprovementCandidateOptions {
-    root: string;
-    candidate: KnowledgeImprovementCandidateRef;
+  root: string;
+  candidate: KnowledgeImprovementCandidateRef;
 }
 interface ResolvedKnowledgeImprovementComparisonSnapshot {
-    root: string;
-    hash: string;
+  root: string;
+  hash: string;
 }
 interface ResolvedKnowledgeImprovementComparison {
-    reference: KnowledgeImprovementCandidateRef;
-    evaluation: KnowledgeImprovementMetric;
-    baseline: ResolvedKnowledgeImprovementComparisonSnapshot;
-    candidate: ResolvedKnowledgeImprovementComparisonSnapshot;
+  reference: KnowledgeImprovementCandidateRef;
+  evaluation: KnowledgeImprovementMetric;
+  baseline: ResolvedKnowledgeImprovementComparisonSnapshot;
+  candidate: ResolvedKnowledgeImprovementComparisonSnapshot;
 }
 interface ResolvedKnowledgeImprovementCandidate {
-    root: string;
-    candidate: KnowledgeImprovementCandidateRef;
-    evaluation: KnowledgeImprovementMetric;
+  root: string;
+  candidate: KnowledgeImprovementCandidateRef;
+  evaluation: KnowledgeImprovementMetric;
 }
 interface KnowledgeImprovementRetrievalOptions extends Omit<RunRetrievalImprovementLoopOptions, 'index' | 'runDir'> {
-    runDir?: RunRetrievalImprovementLoopOptions['runDir'];
+  runDir?: RunRetrievalImprovementLoopOptions['runDir'];
 }
 type KnowledgeImprovementRagOptimizationRunInput = Parameters<RunRagOptimizationOptions['run']>[0] & {
-    runId: string;
-    iteration: number;
-    candidateId: string;
-    root: string;
-    baselineRoot: string;
-    candidateRoot: string;
-    candidateIndex: KnowledgeIndex;
-    baseHash: string;
+  runId: string;
+  iteration: number;
+  candidateId: string;
+  root: string;
+  baselineRoot: string;
+  candidateRoot: string;
+  candidateIndex: KnowledgeIndex;
+  baseHash: string;
 };
 interface KnowledgeImprovementRagOptimizationOptions extends Omit<RunRagOptimizationOptions, 'run' | 'runDir'> {
-    runDir?: RunRagOptimizationOptions['runDir'];
-    run(input: KnowledgeImprovementRagOptimizationRunInput): Promise<RagAnswerEvalArtifact>;
+  runDir?: RunRagOptimizationOptions['runDir'];
+  run(input: KnowledgeImprovementRagOptimizationRunInput): Promise<RagAnswerEvalArtifact>;
 }
 interface KnowledgeImprovementUpdateInput extends RagKnowledgeUpdateInput {
-    runId: string;
-    iteration: number;
-    candidateId: string;
-    root: string;
-    baselineRoot: string;
-    candidateRoot: string;
-    baseHash: string;
+  runId: string;
+  iteration: number;
+  candidateId: string;
+  root: string;
+  baselineRoot: string;
+  candidateRoot: string;
+  baseHash: string;
 }
 type KnowledgeImprovementUpdate = (input: KnowledgeImprovementUpdateInput) => Promise<RagKnowledgeUpdateResult> | RagKnowledgeUpdateResult;
 interface KnowledgeImprovementOptions {
-    root: string;
-    goal: string;
-    /**
-     * Immutable identity covering callbacks, evaluation policy, models, indexes,
-     * external services, and all other behavior that can affect this run.
-     */
-    implementationRef: string;
-    runId?: string;
-    ownerId?: string;
-    leaseTtlMs?: number;
-    resume?: boolean;
-    maxCandidates?: number;
-    candidateResearchIterations?: number;
-    strict?: ValidateKnowledgeOptions['strict'];
-    readinessSpecs?: KnowledgeReadinessSpec[];
-    readinessTaskId?: string;
-    readiness?: Omit<BuildEvalKnowledgeBundleOptions, 'taskId' | 'index' | 'specs'>;
-    kbQuality?: KnowledgeBaseQualityOptions;
-    step?: RunKnowledgeResearchLoopOptions['step'];
-    knowledgeResearch?: Omit<RagKnowledgeResearchOptions, 'root'>;
-    ragOptimization?: KnowledgeImprovementRagOptimizationOptions;
-    retrieval?: KnowledgeImprovementRetrievalOptions;
-    diagnose?: NonNullable<RunRagKnowledgeImprovementLoopOptions['diagnose']>;
-    acquireKnowledge?: NonNullable<RunRagKnowledgeImprovementLoopOptions['acquireKnowledge']>;
-    updateKnowledge?: KnowledgeImprovementUpdate;
-    evaluateAnswers?: NonNullable<RunRagKnowledgeImprovementLoopOptions['evaluateAnswers']>;
-    answerQualityCostCeiling?: RunRagKnowledgeImprovementLoopOptions['answerQualityCostCeiling'];
-    decidePromotion?: NonNullable<RunRagKnowledgeImprovementLoopOptions['decidePromotion']>;
-    enabledPhases?: readonly RagKnowledgeImprovementPhase[];
-    requiredPhases?: readonly RagKnowledgeImprovementPhase[];
-    /** Repeatable candidate screening that must not use final cases. */
-    evaluateDevelopment?: KnowledgeImprovementEvaluator;
-    /** Single-use final evaluator. A failure ends the run. */
-    evaluate?: KnowledgeImprovementEvaluator;
-    signal?: AbortSignal;
-    now?: () => Date;
-    onState?: (state: KnowledgeImprovementRunState) => Promise<void> | void;
-}
-
+  root: string;
+  goal: string;
+  /**
+   * Immutable identity covering callbacks, evaluation policy, models, indexes,
+   * external services, and all other behavior that can affect this run.
+   */
+  implementationRef: string;
+  runId?: string;
+  ownerId?: string;
+  leaseTtlMs?: number;
+  resume?: boolean;
+  maxCandidates?: number;
+  candidateResearchIterations?: number;
+  strict?: ValidateKnowledgeOptions['strict'];
+  readinessSpecs?: KnowledgeReadinessSpec[];
+  readinessTaskId?: string;
+  readiness?: Omit<BuildEvalKnowledgeBundleOptions, 'taskId' | 'index' | 'specs'>;
+  kbQuality?: KnowledgeBaseQualityOptions;
+  step?: RunKnowledgeResearchLoopOptions['step'];
+  knowledgeResearch?: Omit<RagKnowledgeResearchOptions, 'root'>;
+  ragOptimization?: KnowledgeImprovementRagOptimizationOptions;
+  retrieval?: KnowledgeImprovementRetrievalOptions;
+  diagnose?: NonNullable<RunRagKnowledgeImprovementLoopOptions['diagnose']>;
+  acquireKnowledge?: NonNullable<RunRagKnowledgeImprovementLoopOptions['acquireKnowledge']>;
+  updateKnowledge?: KnowledgeImprovementUpdate;
+  evaluateAnswers?: NonNullable<RunRagKnowledgeImprovementLoopOptions['evaluateAnswers']>;
+  answerQualityCostCeiling?: RunRagKnowledgeImprovementLoopOptions['answerQualityCostCeiling'];
+  decidePromotion?: NonNullable<RunRagKnowledgeImprovementLoopOptions['decidePromotion']>;
+  enabledPhases?: readonly RagKnowledgeImprovementPhase[];
+  requiredPhases?: readonly RagKnowledgeImprovementPhase[];
+  /** Repeatable candidate screening that must not use final cases. */
+  evaluateDevelopment?: KnowledgeImprovementEvaluator;
+  /** Single-use final evaluator. A failure ends the run. */
+  evaluate?: KnowledgeImprovementEvaluator;
+  signal?: AbortSignal;
+  now?: () => Date;
+  onState?: (state: KnowledgeImprovementRunState) => Promise<void> | void;
+}
+//#endregion
+//#region src/kb-improvement/activation.d.ts
 /** Load the durable result for one exact activation without changing knowledge or run state. */
 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>;
-    }>;
+  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;
+  optimization: RunSerializedKnowledgeOptimizationResult<TPolicy>;
+  improvement: KnowledgeImprovementResult;
 }
 /**
  * Optimizes a serialized KB-maintenance policy, then materializes the selected
@@ -1424,29 +1363,33 @@ interface OptimizeKnowledgeBasePolicyResult<TPolicy extends AgentCandidateJsonVa
  */
 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;
+  candidate: TPolicy;
+  candidateSurface: string;
+  candidateSurfaceHash: string;
+  scenario: TScenario;
+  context: DispatchContext;
 }) => Promise<TArtifact>;
-
+//#endregion
+//#region src/kb-improvement/run.d.ts
 declare function improveKnowledgeBase(options: KnowledgeImprovementOptions): Promise<KnowledgeImprovementResult>;
-
+//#endregion
+//#region src/kb-improvement/state.d.ts
 declare function knowledgeImprovementRunId(root: string, goal: string): string;
 declare function knowledgeImprovementRunDir(root: string, runId: string): string;
 declare function loadKnowledgeImprovementState(root: string, runId: string): Promise<KnowledgeImprovementRunState | null>;
 interface KnowledgeImprovementEvent extends Record<string, unknown> {
-    at: string;
-    type: string;
+  at: string;
+  type: string;
 }
 declare function loadKnowledgeImprovementEvents(root: string, runId: string): Promise<KnowledgeImprovementEvent[]>;
-
+//#endregion
+//#region src/kb-improvement/transition.d.ts
 /** Promote one previously measured candidate without rerunning research or evaluation. */
 declare function promoteKnowledgeCandidate(options: PromoteKnowledgeCandidateOptions): Promise<KnowledgeImprovementMutationResult>;
 /** Restore the frozen baseline paired with one previously measured candidate. */
 declare function restoreKnowledgeCandidateBaseline(options: RestoreKnowledgeCandidateBaselineOptions): Promise<KnowledgeImprovementMutationResult>;
-
+//#endregion
+//#region src/kb-improvement/workspace.d.ts
 /** Freeze the exact knowledge bytes and measured evidence a later approval may promote. */
 declare function knowledgeImprovementCandidateRef(result: Pick<KnowledgeImprovementResult, 'runId' | 'state' | 'candidate'>): KnowledgeImprovementCandidateRef;
 /** Use both frozen sides of one measured comparison in isolated, integrity-checked copies. */
@@ -1454,12 +1397,14 @@ declare function withKnowledgeImprovementComparison<T>(options: UseKnowledgeImpr
 /** Use the frozen candidate side of one measured comparison. */
 declare function withKnowledgeImprovementCandidate<T>(options: UseKnowledgeImprovementCandidateOptions, use: (candidate: ResolvedKnowledgeImprovementCandidate) => Promise<T> | T): Promise<T>;
 declare function hashKnowledgeBase(root: string): Promise<string>;
-
+//#endregion
+//#region src/agent-candidate.d.ts
 /** Convert a measured knowledge candidate into the shared review and execution identity. */
 declare function toAgentCandidateKnowledgeRef(candidate: KnowledgeImprovementCandidateRef): AgentCandidateKnowledgeRef;
 /** Recover agent-knowledge's candidate identity from the shared contract. */
 declare function fromAgentCandidateKnowledgeRef(candidate: AgentCandidateKnowledgeRef): KnowledgeImprovementCandidateRef;
-
+//#endregion
+//#region src/changes.d.ts
 /**
  * Change detection across snapshots of one source's fragments.
  *
@@ -1489,117 +1434,83 @@ declare function fromAgentCandidateKnowledgeRef(candidate: AgentCandidateKnowled
  */
 type KnowledgeChangeKind = 'added' | 'removed' | 'modified';
 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;
+  /** 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;
 }
 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[];
+  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[];
 }
 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[];
+  /**
+   * 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[];
 }
 declare function detectChanges(prev: KnowledgeFragment[], next: KnowledgeFragment[], options?: DetectChangesOptions): DetectChangesResult;
-
+//#endregion
+//#region src/chunking.d.ts
 interface ChunkingOptions {
-    targetChars: number;
-    maxChars: number;
-    minChars: number;
-    overlapChars: number;
+  targetChars: number;
+  maxChars: number;
+  minChars: number;
+  overlapChars: number;
 }
 interface KnowledgeChunk {
-    index: number;
-    text: string;
-    headingPath: string;
-    charStart: number;
-    charEnd: number;
-    oversized: boolean;
+  index: number;
+  text: string;
+  headingPath: string;
+  charStart: number;
+  charEnd: number;
+  oversized: boolean;
 }
 declare function chunkMarkdown(content: string, options?: Partial<ChunkingOptions>): KnowledgeChunk[];
 declare function stripFrontmatter(content: string): {
-    body: string;
-    bodyOffset: number;
+  body: string;
+  bodyOffset: number;
 };
-
-/**
- * Claim-grounding mode for `runVerifiedResearchLoop`.
- *
- * The two-agent loop's existing verifier judges a source's on-topic RELEVANCE
- * (is this page about the goal?). On the topic sets we have measured, its
- * cleanliness win is dominated by DE-DUPLICATION — which a deterministic
- * content-hash / canonical-URL check captures at ~none of the LLM premium (see
- * `docs/results/cost-quality.md`). That makes the LLM verifier look expensive
- * for what a cheap rule already does.
- *
- * Claim-grounding targets a DIFFERENT, harder error band: a citation that is
- * relevant and unique but **misattributed** — the page is on-topic, the URL is
- * real, yet the specific CLAIM the source is cited for does NOT actually appear
- * in the page. This is the citation-fabrication failure mode of LLM research:
- * the model writes a plausible sentence and hangs a real URL off it that never
- * says any such thing. Neither de-dup nor a relevance judge catches it (both can
- * pass a misattributed-but-on-topic page); only checking the claim against the
- * fetched text does.
- *
- * The check is EXECUTABLE GROUND TRUTH, not another LLM opinion: the worker
- * attaches the specific claim it is citing the source for, and the verifier
- * tests whether that claim is PRESENT (verbatim, normalized, or as a sufficient
- * content-word overlap / close paraphrase) in the `htmlToText` output of the
- * page the worker actually fetched. A claim that is not grounded is rejected as
- * misattributed. Because the oracle is deterministic text presence — not a model
- * call — it is a deployable, non-oracle verifier: it can run in production with
- * zero inference cost, OR be composed with the LLM relevance verifier so the
- * loop rejects BOTH off-topic AND misattributed sources.
- *
- * This module is content-free and any-topic: it adds (1) a way for a proposal to
- * carry the claim it is cited for, (2) the `groundClaimInText` oracle, and (3) a
- * `ResearchDriver` that gates on grounding. It composes the existing
- * `ResearchDriver` / `ResearchSourceProposal` contracts and the shipped
- * `htmlToText`; it reinvents none of them.
- */
-
+//#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
@@ -1611,31 +1522,31 @@ declare function citedClaimOf(source: ResearchSourceProposal): string | undefine
 /** Attach a cited claim to a proposal (immutably returns a new proposal). */
 declare function withCitedClaim(source: ResearchSourceProposal, claim: string): ResearchSourceProposal;
 interface GroundingResult {
-    /** True when the claim is sufficiently present in the page text. */
-    grounded: boolean;
-    /** How the claim matched (or why it didn't). For audit/notes. */
-    mode: 'verbatim' | 'normalized' | 'overlap' | 'absent' | 'empty-claim' | 'empty-text';
-    /**
-     * Fraction of the claim's content words found in the page text. 1 for a
-     * verbatim/normalized hit; the measured overlap otherwise.
-     */
-    overlap: number;
-    /** Content words present in the claim but NOT in the page text. */
-    missingWords: string[];
+  /** True when the claim is sufficiently present in the page text. */
+  grounded: boolean;
+  /** How the claim matched (or why it didn't). For audit/notes. */
+  mode: 'verbatim' | 'normalized' | 'overlap' | 'absent' | 'empty-claim' | 'empty-text';
+  /**
+   * Fraction of the claim's content words found in the page text. 1 for a
+   * verbatim/normalized hit; the measured overlap otherwise.
+   */
+  overlap: number;
+  /** Content words present in the claim but NOT in the page text. */
+  missingWords: string[];
 }
 interface GroundClaimOptions {
-    /**
-     * Minimum fraction of the claim's content words that must appear in the page
-     * text to count as a close paraphrase when there is no verbatim/normalized
-     * hit. Default 0.7 — a high bar, because a misattribution is exactly a claim
-     * whose specific words the page does not contain.
-     */
-    minOverlap?: number;
-    /**
-     * Content words shorter than this are ignored (drops "the", "of", "is", …)
-     * and never count toward overlap. Default 3.
-     */
-    minWordLength?: number;
+  /**
+   * Minimum fraction of the claim's content words that must appear in the page
+   * text to count as a close paraphrase when there is no verbatim/normalized
+   * hit. Default 0.7 — a high bar, because a misattribution is exactly a claim
+   * whose specific words the page does not contain.
+   */
+  minOverlap?: number;
+  /**
+   * Content words shorter than this are ignored (drops "the", "of", "is", …)
+   * and never count toward overlap. Default 3.
+   */
+  minWordLength?: number;
 }
 /**
  * THE ORACLE. Is `claim` grounded in `pageText` (the `htmlToText` output of the
@@ -1654,21 +1565,21 @@ interface GroundClaimOptions {
  */
 declare function groundClaimInText(claim: string, pageText: string, options?: GroundClaimOptions): GroundingResult;
 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';
+  /**
+   * 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
@@ -1681,10 +1592,10 @@ interface ClaimGroundingDriverOptions extends GroundClaimOptions {
  */
 declare function createClaimGroundingVerifier(options?: ClaimGroundingDriverOptions): (source: ResearchSourceProposal, ctx: SourceVerificationContext) => Promise<SourceVerdict>;
 interface WorkerClaimDecorationOptions {
-    router?: RouterClient;
-    router_options?: TangleRouterOptions;
-    /** Max output tokens for the claim-extraction call. Default 1200 (glm floor). */
-    maxTokens?: number;
+  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
@@ -1700,98 +1611,72 @@ interface WorkerClaimDecorationOptions {
  * `onMissingClaim` policy then decides).
  */
 declare function createClaimDecorator(options?: WorkerClaimDecorationOptions): (source: ResearchSourceProposal, goal: string) => Promise<ResearchSourceProposal>;
-
-/**
- * The SINGLE-AGENT COLLECTION driver — the blind-collection baseline (Arm A).
- *
- * This is the honest null the depth A/B is measured against. The other drivers
- * spend extra inference to do something differentiated:
- *   - `createVerifyingResearchDriver` runs an LLM gate per source (Arm B),
- *   - `createResearchDrivingDriver` extracts claims, tracks corroboration, and
- *     synthesizes deep follow-up questions to drive depth (Arm C).
- *
- * This driver does NONE of that. It is a pass-through: it accepts every source
- * the worker proposes and contributes no research, no gating, and no steering of
- * its own. The loop still dedups exact-uri duplicates before calling
- * `verifySource` (that is the loop's job, not the driver's), and the default
- * `foldGaps` (a plain bulleted list of the still-open readiness gaps) still folds
- * the gaps into the worker's next prompt — so the worker keeps researching, but
- * NOTHING intelligent sits between the worker and the knowledge base.
- *
- * In other words: ONE agent (the worker) collects sources round after round, and
- * the "driver" is an inert rubber stamp. That is exactly what "single-agent
- * collection" means — the topology with zero coordinator intelligence — so its
- * material-facts score is the floor every other arm must beat to justify its
- * extra inference cost.
- *
- * It adds NO router calls of its own: `verifySource` is a synchronous accept and
- * `foldGaps` is omitted so the loop uses its built-in gap list. So Arm A's cost
- * is the worker's cost alone — the cleanest possible blind-collection baseline.
- */
-
+//#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.
  */
 declare function createCollectionResearchDriver(): ResearchDriver;
-
+//#endregion
+//#region src/discovery.d.ts
 interface DiscoveryTask {
-    id: string;
-    goal: string;
-    query?: string;
-    sourceHints?: string[];
-    metadata?: Record<string, unknown>;
+  id: string;
+  goal: string;
+  query?: string;
+  sourceHints?: string[];
+  metadata?: Record<string, unknown>;
 }
 interface DiscoveryResult {
-    taskId: string;
-    summary: string;
-    sourceUris?: string[];
-    claims?: Array<{
-        text: string;
-        sourceUri?: string;
-        confidence?: number;
-    }>;
-    followUpTasks?: DiscoveryTask[];
-    metadata?: Record<string, unknown>;
+  taskId: string;
+  summary: string;
+  sourceUris?: string[];
+  claims?: Array<{
+    text: string;
+    sourceUri?: string;
+    confidence?: number;
+  }>;
+  followUpTasks?: DiscoveryTask[];
+  metadata?: Record<string, unknown>;
 }
 interface KnowledgeDiscoveryWorker {
-    run(task: DiscoveryTask, signal?: AbortSignal): Promise<DiscoveryResult> | DiscoveryResult;
+  run(task: DiscoveryTask, signal?: AbortSignal): Promise<DiscoveryResult> | DiscoveryResult;
 }
 interface KnowledgeDiscoveryDispatcher {
-    dispatch(tasks: DiscoveryTask[], options?: {
-        concurrency?: number;
-        signal?: AbortSignal;
-    }): Promise<DiscoveryResult[]>;
+  dispatch(tasks: DiscoveryTask[], options?: {
+    concurrency?: number;
+    signal?: AbortSignal;
+  }): Promise<DiscoveryResult[]>;
 }
 type DiscoveryLoopStopReason = 'complete' | 'max-rounds' | 'max-tasks' | 'aborted';
 interface DiscoveryLoopRound {
-    round: number;
-    tasks: DiscoveryTask[];
-    results: DiscoveryResult[];
-    queuedFollowUps: DiscoveryTask[];
+  round: number;
+  tasks: DiscoveryTask[];
+  results: DiscoveryResult[];
+  queuedFollowUps: DiscoveryTask[];
 }
 interface DiscoveryLoopResult {
-    stopReason: DiscoveryLoopStopReason;
-    tasksDispatched: number;
-    results: DiscoveryResult[];
-    rounds: DiscoveryLoopRound[];
-    /** Tasks retained, not dropped, when a configured limit stops the loop. */
-    pendingTasks: DiscoveryTask[];
-    /** Structurally identical task identities ignored to prevent cycles. */
-    duplicateTaskIds: string[];
+  stopReason: DiscoveryLoopStopReason;
+  tasksDispatched: number;
+  results: DiscoveryResult[];
+  rounds: DiscoveryLoopRound[];
+  /** Tasks retained, not dropped, when a configured limit stops the loop. */
+  pendingTasks: DiscoveryTask[];
+  /** Structurally identical task identities ignored to prevent cycles. */
+  duplicateTaskIds: string[];
 }
 interface RunDiscoveryLoopOptions {
-    dispatcher: KnowledgeDiscoveryDispatcher;
-    initialTasks: readonly DiscoveryTask[];
-    /** Maximum follow-up depth including the initial dispatch. Default 3. */
-    maxRounds?: number;
-    /** Maximum tasks dispatched across all rounds. Default 24. */
-    maxTasks?: number;
-    /** Forwarded to the dispatcher. Default 4. */
-    concurrency?: number;
-    signal?: AbortSignal;
-    onRound?: (round: DiscoveryLoopRound) => Promise<void> | void;
+  dispatcher: KnowledgeDiscoveryDispatcher;
+  initialTasks: readonly DiscoveryTask[];
+  /** Maximum follow-up depth including the initial dispatch. Default 3. */
+  maxRounds?: number;
+  /** Maximum tasks dispatched across all rounds. Default 24. */
+  maxTasks?: number;
+  /** Forwarded to the dispatcher. Default 4. */
+  concurrency?: number;
+  signal?: AbortSignal;
+  onRound?: (round: DiscoveryLoopRound) => Promise<void> | void;
 }
 /**
  * Dispatch discovery tasks and recursively pursue worker-proposed follow-ups.
@@ -1801,36 +1686,38 @@ interface RunDiscoveryLoopOptions {
  */
 declare function runDiscoveryLoop(options: RunDiscoveryLoopOptions): Promise<DiscoveryLoopResult>;
 declare function createLocalDiscoveryDispatcher(worker: KnowledgeDiscoveryWorker): KnowledgeDiscoveryDispatcher;
-
+//#endregion
+//#region src/events.d.ts
 interface KnowledgeEventQuery {
-    type?: KnowledgeEventType;
-    target?: string;
-    limit?: number;
+  type?: KnowledgeEventType;
+  target?: string;
+  limit?: number;
 }
 declare function createKnowledgeEvent(input: {
-    type: KnowledgeEventType;
-    actor?: string;
-    target?: string;
-    metadata?: Record<string, unknown>;
-    now?: () => Date;
+  type: KnowledgeEventType;
+  actor?: string;
+  target?: string;
+  metadata?: Record<string, unknown>;
+  now?: () => Date;
 }): KnowledgeEvent;
-
+//#endregion
+//#region src/filesystem-search-provider.d.ts
 interface FileSystemSearchProviderOptions {
-    /** Knowledge-base root containing `knowledge/` and `.agent-knowledge/`. */
-    root: string;
-    /** Optional warm index, useful when the caller already built one. */
-    index?: KnowledgeIndex;
-    /** Default result count for `search()`. Defaults to 10. */
-    defaultLimit?: number;
-    /**
-     * `manual` caches the index until `refresh: true` or `invalidate()`.
-     * `always` rebuilds from disk on every search.
-     */
-    refresh?: 'manual' | 'always';
+  /** Knowledge-base root containing `knowledge/` and `.agent-knowledge/`. */
+  root: string;
+  /** Optional warm index, useful when the caller already built one. */
+  index?: KnowledgeIndex;
+  /** Default result count for `search()`. Defaults to 10. */
+  defaultLimit?: number;
+  /**
+   * `manual` caches the index until `refresh: true` or `invalidate()`.
+   * `always` rebuilds from disk on every search.
+   */
+  refresh?: 'manual' | 'always';
 }
 interface FileSystemSearchOptions {
-    limit?: number;
-    refresh?: boolean;
+  limit?: number;
+  refresh?: boolean;
 }
 /**
  * File-first retrieval over an `agent-knowledge` KB.
@@ -1839,19 +1726,20 @@ interface FileSystemSearchOptions {
  * markdown knowledge files before adding embeddings, rerankers, or a vector DB.
  */
 declare class FileSystemSearchProvider {
-    readonly root: string;
-    private index;
-    private readonly defaultLimit;
-    private readonly refreshMode;
-    constructor(options: FileSystemSearchProviderOptions);
-    getIndex(options?: FileSystemSearchOptions): Promise<KnowledgeIndex>;
-    search(query: string, options?: FileSystemSearchOptions): Promise<KnowledgeSearchResult[]>;
-    retrieve(query: string, options?: FileSystemSearchOptions): Promise<RetrievedKnowledgeHit[]>;
-    asRetrievalEvalRetriever(): RetrievalEvalRetriever;
-    invalidate(): void;
+  readonly root: string;
+  private index;
+  private readonly defaultLimit;
+  private readonly refreshMode;
+  constructor(options: FileSystemSearchProviderOptions);
+  getIndex(options?: FileSystemSearchOptions): Promise<KnowledgeIndex>;
+  search(query: string, options?: FileSystemSearchOptions): Promise<KnowledgeSearchResult[]>;
+  retrieve(query: string, options?: FileSystemSearchOptions): Promise<RetrievedKnowledgeHit[]>;
+  asRetrievalEvalRetriever(): RetrievalEvalRetriever;
+  invalidate(): void;
 }
 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.
@@ -1882,44 +1770,44 @@ declare function createFileSystemSearchProvider(options: FileSystemSearchProvide
  */
 /** Identity for one freshness record. */
 interface FreshnessKey {
-    workspaceId: string;
-    sourceId: string;
+  workspaceId: string;
+  sourceId: string;
 }
 /** TTL bound for staleness checks. */
 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;
+  /** 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. */
 interface FreshnessMark extends FreshnessKey {
-    when: Date;
-    /** Optional content hash captured at refresh time; aids debugging. */
-    contentHash?: string;
+  when: Date;
+  /** Optional content hash captured at refresh time; aids debugging. */
+  contentHash?: string;
 }
 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[]>;
+  /** 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[]>;
 }
 interface FreshnessRecord {
-    workspaceId: string;
-    sourceId: string;
-    lastRefreshedAt: string;
-    contentHash?: string;
+  workspaceId: string;
+  sourceId: string;
+  lastRefreshedAt: string;
+  contentHash?: string;
 }
 interface FileSystemFreshnessStoreOptions {
-    /**
-     * Knowledge root. The store writes to `<root>/.agent-knowledge/freshness.json`,
-     * mirroring the convention used by `sources.json`.
-     */
-    root: string;
+  /**
+   * 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,
@@ -1947,74 +1835,80 @@ declare function createFileSystemFreshnessStore(options: FileSystemFreshnessStor
  * ```
  */
 interface D1Adapter {
-    get(workspaceId: string, sourceId: string): Promise<FreshnessRecord | null>;
-    upsert(record: FreshnessRecord): Promise<void>;
-    listByWorkspace(workspaceId: string): Promise<FreshnessRecord[]>;
+  get(workspaceId: string, sourceId: string): Promise<FreshnessRecord | null>;
+  upsert(record: FreshnessRecord): Promise<void>;
+  listByWorkspace(workspaceId: string): Promise<FreshnessRecord[]>;
 }
 declare function createD1FreshnessStoreStub(adapter: D1Adapter): KnowledgeFreshnessStore;
-
+//#endregion
+//#region src/frontmatter.d.ts
 interface ParsedFrontmatter {
-    frontmatter: Record<string, unknown>;
-    body: string;
+  frontmatter: Record<string, unknown>;
+  body: string;
 }
 declare function parseFrontmatter(content: string): ParsedFrontmatter;
 declare function formatFrontmatter(frontmatter: Record<string, unknown>, body: string): string;
-
+//#endregion
+//#region src/graph.d.ts
 declare function buildKnowledgeGraph(pages: KnowledgePage[]): KnowledgeGraph;
-
+//#endregion
+//#region src/ids.d.ts
 declare function sha256(text: string): string;
 declare function slugify(input: string): string;
 declare function stableId(prefix: string, content: string): string;
-
+//#endregion
+//#region src/indexer.d.ts
 declare function buildKnowledgeIndex(root: string): Promise<KnowledgeIndex>;
 declare function writeKnowledgeIndex(root: string): Promise<KnowledgeIndex>;
-
+//#endregion
+//#region src/inspect.d.ts
 interface KnowledgeInspection {
-    pageCount: number;
-    sourceCount: number;
-    expiredSourceCount: number;
-    staleSourceCount: number;
-    edgeCount: number;
-    findingCount: number;
-    blockingFindingCount: number;
-    topPages: Array<{
-        path: string;
-        title: string;
-        degree: number;
-        sources: number;
-    }>;
-    sourceFreshness: SourceFreshnessInspection[];
-    findings: KnowledgeLintFinding[];
+  pageCount: number;
+  sourceCount: number;
+  expiredSourceCount: number;
+  staleSourceCount: number;
+  edgeCount: number;
+  findingCount: number;
+  blockingFindingCount: number;
+  topPages: Array<{
+    path: string;
+    title: string;
+    degree: number;
+    sources: number;
+  }>;
+  sourceFreshness: SourceFreshnessInspection[];
+  findings: KnowledgeLintFinding[];
 }
 interface SourceFreshnessInspection {
-    id: string;
-    title?: string;
-    uri: string;
-    status: 'fresh' | 'expired' | 'unknown';
-    validUntil?: string;
-    lastVerifiedAt?: string;
+  id: string;
+  title?: string;
+  uri: string;
+  status: 'fresh' | 'expired' | 'unknown';
+  validUntil?: string;
+  lastVerifiedAt?: string;
 }
 declare function inspectKnowledgeIndex(index: KnowledgeIndex, options?: {
-    now?: Date;
+  now?: Date;
 }): KnowledgeInspection;
 interface KnowledgeExplanation {
-    target: string;
-    page?: KnowledgePage;
-    sources: Array<{
-        id: string;
-        title?: string;
-        uri: string;
-    }>;
-    links: string[];
-    inbound: string[];
-    related: Array<{
-        path: string;
-        title: string;
-        score: number;
-    }>;
+  target: string;
+  page?: KnowledgePage;
+  sources: Array<{
+    id: string;
+    title?: string;
+    uri: string;
+  }>;
+  links: string[];
+  inbound: string[];
+  related: Array<{
+    path: string;
+    title: string;
+    score: number;
+  }>;
 }
 declare function explainKnowledgeTarget(index: KnowledgeIndex, target: string): KnowledgeExplanation;
-
+//#endregion
+//#region src/investment-thesis-set.d.ts
 /**
  * HELD-OUT INVESTMENT-RESEARCH EVAL SET.
  *
@@ -2064,71 +1958,71 @@ declare function explainKnowledgeTarget(index: KnowledgeIndex, target: string):
  */
 /** A required answer component: satisfied when any synonym fragment is present. */
 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[];
+  /** 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. */
 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. */
 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;
+  /** 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. */
 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[];
+  /** 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
@@ -2151,54 +2045,35 @@ declare const investmentThesisSet: CompanyEvalCase[];
  * reproducible — so the eval never leaks into a model the loop could observe.
  */
 declare function gradeFactAgainstText(fact: MaterialFact, thesisText: string): {
-    surfaced: boolean;
-    groupsFound: number;
-    groupsTotal: number;
-    foundLabels: 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. */
 declare function gradeCompanyAgainstText(company: CompanyEvalCase, thesisText: string): {
-    surfaced: number;
-    total: number;
-    perFact: ReturnType<typeof gradeFactAgainstText>[];
+  surfaced: number;
+  total: number;
+  perFact: ReturnType<typeof gradeFactAgainstText>[];
 };
 /** Total held-out facts across the set (the denominator the doc reports). */
 declare function totalMaterialFacts(set?: CompanyEvalCase[]): number;
 /** Count facts per lens across the set — used to report (and bound) curation bias. */
 declare function lensDistribution(set?: CompanyEvalCase[]): Record<MaterialFactLens, number>;
-
-/**
- * The INVESTMENT-THESIS research task.
- *
- * Given `{ company, ticker, cik, cutoff }`, drive the SAME two-agent research
- * loop the ML deep-question A/B uses (`runVerifiedResearchLoop` + the real web
- * worker) to research the company AS OF the cutoff — web + SEC EDGAR, both public
- * — and produce an investment-thesis PAGE in the knowledge base: a judgment, the
- * drivers, and the risks, grounded in what it fetched.
- *
- * This file builds NOTHING new for the loop: it composes the existing worker +
- * driver + loop, supplies the readiness specs that steer the worker toward the
- * filing-level evidence (the analyst lenses), then writes a synthesis thesis page
- * the metric (`materialFactsSurfaced`) grades against the HELD-OUT checklist.
- *
- * THE FIREWALL: the task is told ONLY company + ticker + cutoff (+ the generic
- * analyst-lens readiness specs every company gets). It is NEVER shown the
- * checklist. The checklist is read only afterward, by the metric. So a high score
- * is research depth, not teaching-to-the-test.
- */
-
+//#endregion
+//#region src/investment-thesis-task.d.ts
 /** The minimal brief a thesis run is given — the firewall boundary. */
 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;
+  /** 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
@@ -2214,26 +2089,26 @@ interface ThesisTaskInput {
  */
 declare function thesisReadinessSpecs(input: ThesisTaskInput): KnowledgeReadinessSpec[];
 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;
+  /** 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;
 }
 interface ThesisRunResult {
-    loop: VerifiedResearchLoopResult;
-    /** The synthesized thesis text. */
-    thesis: string;
-    /** Path of the thesis page written into the KB. */
-    thesisPath: string;
+  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
@@ -2242,101 +2117,79 @@ interface ThesisRunResult {
  * `materialFactsSurfaced(root, checklist)` — the checklist is never passed here.
  */
 declare function runInvestmentThesisTask(input: ThesisTaskInput, options: ThesisRunOptions): Promise<ThesisRunResult>;
-
+//#endregion
+//#region src/kb-store.d.ts
 interface KbStore {
-    putSource(source: SourceRecord): Promise<void>;
-    getSource(id: string): Promise<SourceRecord | null>;
-    listSources(): Promise<SourceRecord[]>;
-    putPage(page: KnowledgePage): Promise<void>;
-    getPage(idOrPath: string): Promise<KnowledgePage | null>;
-    listPages(): Promise<KnowledgePage[]>;
-    putIndex(index: KnowledgeIndex): Promise<void>;
-    getIndex(): Promise<KnowledgeIndex | null>;
-    putEvent(event: KnowledgeEvent): Promise<void>;
-    listEvents(query?: KnowledgeEventQuery): Promise<KnowledgeEvent[]>;
+  putSource(source: SourceRecord): Promise<void>;
+  getSource(id: string): Promise<SourceRecord | null>;
+  listSources(): Promise<SourceRecord[]>;
+  putPage(page: KnowledgePage): Promise<void>;
+  getPage(idOrPath: string): Promise<KnowledgePage | null>;
+  listPages(): Promise<KnowledgePage[]>;
+  putIndex(index: KnowledgeIndex): Promise<void>;
+  getIndex(): Promise<KnowledgeIndex | null>;
+  putEvent(event: KnowledgeEvent): Promise<void>;
+  listEvents(query?: KnowledgeEventQuery): Promise<KnowledgeEvent[]>;
 }
 declare class MemoryKbStore implements KbStore {
-    private readonly sources;
-    private readonly pages;
-    private readonly events;
-    private index;
-    putSource(source: SourceRecord): Promise<void>;
-    getSource(id: string): Promise<SourceRecord | null>;
-    listSources(): Promise<SourceRecord[]>;
-    putPage(page: KnowledgePage): Promise<void>;
-    getPage(idOrPath: string): Promise<KnowledgePage | null>;
-    listPages(): Promise<KnowledgePage[]>;
-    putIndex(index: KnowledgeIndex): Promise<void>;
-    getIndex(): Promise<KnowledgeIndex | null>;
-    putEvent(event: KnowledgeEvent): Promise<void>;
-    listEvents(query?: KnowledgeEventQuery): Promise<KnowledgeEvent[]>;
+  private readonly sources;
+  private readonly pages;
+  private readonly events;
+  private index;
+  putSource(source: SourceRecord): Promise<void>;
+  getSource(id: string): Promise<SourceRecord | null>;
+  listSources(): Promise<SourceRecord[]>;
+  putPage(page: KnowledgePage): Promise<void>;
+  getPage(idOrPath: string): Promise<KnowledgePage | null>;
+  listPages(): Promise<KnowledgePage[]>;
+  putIndex(index: KnowledgeIndex): Promise<void>;
+  getIndex(): Promise<KnowledgeIndex | null>;
+  putEvent(event: KnowledgeEvent): Promise<void>;
+  listEvents(query?: KnowledgeEventQuery): Promise<KnowledgeEvent[]>;
 }
 declare class FileSystemKbStore implements KbStore {
-    private readonly dir;
-    constructor(dir: string);
-    putSource(source: SourceRecord): Promise<void>;
-    getSource(id: string): Promise<SourceRecord | null>;
-    listSources(): Promise<SourceRecord[]>;
-    putPage(page: KnowledgePage): Promise<void>;
-    getPage(idOrPath: string): Promise<KnowledgePage | null>;
-    listPages(): Promise<KnowledgePage[]>;
-    putIndex(index: KnowledgeIndex): Promise<void>;
-    getIndex(): Promise<KnowledgeIndex | null>;
-    putEvent(event: KnowledgeEvent): Promise<void>;
-    listEvents(query?: KnowledgeEventQuery): Promise<KnowledgeEvent[]>;
-    private updateIndex;
-    private readIndex;
-    private readEvents;
-}
-
+  private readonly dir;
+  constructor(dir: string);
+  putSource(source: SourceRecord): Promise<void>;
+  getSource(id: string): Promise<SourceRecord | null>;
+  listSources(): Promise<SourceRecord[]>;
+  putPage(page: KnowledgePage): Promise<void>;
+  getPage(idOrPath: string): Promise<KnowledgePage | null>;
+  listPages(): Promise<KnowledgePage[]>;
+  putIndex(index: KnowledgeIndex): Promise<void>;
+  getIndex(): Promise<KnowledgeIndex | null>;
+  putEvent(event: KnowledgeEvent): Promise<void>;
+  listEvents(query?: KnowledgeEventQuery): Promise<KnowledgeEvent[]>;
+  private updateIndex;
+  private readIndex;
+  private readEvents;
+}
+//#endregion
+//#region src/lint.d.ts
 declare function lintKnowledgeIndex(index: KnowledgeIndex): KnowledgeLintFinding[];
-
-/**
- * `materialFactsSurfaced` — the held-out investment-research METRIC.
- *
- * Given a knowledge base a research loop built for a company and the company's
- * HELD-OUT material-fact checklist (`tests/eval/investment-thesis-set.ts`, never
- * shown to the loop), this returns the FRACTION of checklist items the KB's
- * pages surface + ground. The check is the same `$0`, model-free, deterministic
- * substring grader the loop's checklist already ships (`gradeFactAgainstText` /
- * `gradeCompanyAgainstText`) — so the answer key never reaches a model the loop
- * could observe, exactly the firewall the ML deep-question exam uses.
- *
- * The ONLY thing this file adds over the raw grader is the KB→text join: it reads
- * the curated pages (and the raw source text) the loop wrote and hands their
- * concatenation to the grader. That join mirrors `kbText` in the research-quality
- * A/B (research-driving-ab.test.ts) so the thesis metric and the ML-exam metric
- * read a KB the same way.
- *
- * WHY pages AND source text: an honest thesis surfaces a buried fact in its
- * curated thesis PAGE (the judgment), but a loop whose page is thin while its
- * fetched filings are rich should still get credit for what it actually pulled.
- * Grading the union is the faithful, not the lenient, choice — it rewards the
- * loop that REACHED the filing even if its synthesis was terse, and it cannot
- * manufacture a hit the underlying evidence does not contain.
- */
-
+//#endregion
+//#region src/material-facts-metric.d.ts
 /** Per-fact grade plus the fact's id/lens, for the audit trail. */
 interface FactResult {
-    id: string;
-    lens: CompanyEvalCase['facts'][number]['lens'];
-    surfaced: boolean;
-    groupsFound: number;
-    groupsTotal: number;
-    foundLabels: string[];
+  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. */
 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[];
+  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
@@ -2364,82 +2217,59 @@ declare function materialFactsSurfacedInText(company: CompanyEvalCase, kbText: s
  * never passed to the loop, and is read only here, after the loop finished.
  */
 declare function materialFactsSurfaced(kb: string | KnowledgeIndex, checklist: CompanyEvalCase): Promise<MaterialFactsResult>;
-
+//#endregion
+//#region src/mutation-lock.d.ts
 interface PendingKnowledgeMutation {
-    transactionId: string;
-    purpose: string;
-    recoveryOwner?: string;
-    createdAt: string;
-    direction: 'apply' | 'rollback';
-    paths: string[];
+  transactionId: string;
+  purpose: string;
+  recoveryOwner?: string;
+  createdAt: string;
+  direction: 'apply' | 'rollback';
+  paths: string[];
 }
 interface RecoverPendingKnowledgeMutationOptions {
-    transactionId: string;
-    action: 'apply' | 'rollback';
+  transactionId: string;
+  action: 'apply' | 'rollback';
 }
 declare function inspectPendingKnowledgeMutation(root: string): Promise<PendingKnowledgeMutation | null>;
 declare function recoverPendingKnowledgeMutation(root: string, options: RecoverPendingKnowledgeMutationOptions): Promise<void>;
-
-/**
- * Bridge from `AnalystFinding` (agent-eval) to knowledge proposals.
- *
- * Closes the failure → wiki side of the recursive-self-improvement
- * loop: a knowledge-gap or knowledge-poisoning finding produced by an
- * analyst becomes a concrete proposal an operator (or auto-merge bot)
- * can review and apply. The bridge is intentionally lossless on the
- * fail-loud side — a finding the parser can't classify returns a
- * `KnowledgeProposalParseError` rather than a silent skip, so the
- * loop never accepts an underspecified edit.
- *
- * Subject grammar this bridge understands (analyst-side convention,
- * stamped in the kind prompts):
- *
- *   agent-knowledge:wiki:<page-slug>            create / update page
- *   agent-knowledge:wiki:<page-slug>#<heading>  insert section under page
- *   agent-knowledge:claim:<topic>               draft claim row
- *   agent-knowledge:raw:<source-id>             lift raw → curated
- *   agent-knowledge:stale:<page-slug>           mark page superseded
- *
- * Anything else (websearch:outdated:*, tool-doc:*, system-prompt:*,
- * memory:*) is NOT a knowledge-base concern and returns `null` so the
- * loop's improvement-applier handles it.
- */
-
+//#endregion
+//#region src/propose-from-finding.d.ts
 interface KnowledgeProposal {
-    /**
-     * Stable id derived from the finding so cross-run diffs share an
-     * identity. Re-proposing the same finding produces the same id.
-     */
-    id: string;
-    /** The finding that generated this proposal — useful for audit + revert. */
-    sourceFindingId: string;
-    /** What the proposal does. */
-    kind: 'create-page' | 'update-page' | 'append-section' | 'create-claim' | 'lift-raw' | 'mark-stale';
-    /** Locus on disk (page slug or claim topic). */
-    locus: string;
-    /**
-     * Page write blocks the standard `applyKnowledgeWriteBlocks` consumer
-     * accepts. Empty for proposals that don't change page text (e.g.
-     * `create-claim` produces a `claim` field instead).
-     */
-    writeBlocks: KnowledgeWriteBlock[];
-    /**
-     * Granular claim draft for proposals whose unit-of-change is a claim
-     * row rather than a whole page. `status: 'draft'` until reviewed.
-     */
-    claim?: KnowledgeClaim;
-    /** Per-proposal metadata: severity, confidence, source span. */
-    metadata: {
-        severity: AnalystSeverity;
-        confidence: number;
-        evidence_uri?: string;
-        analyst_id: string;
-    };
+  /**
+   * Stable id derived from the finding so cross-run diffs share an
+   * identity. Re-proposing the same finding produces the same id.
+   */
+  id: string;
+  /** The finding that generated this proposal — useful for audit + revert. */
+  sourceFindingId: string;
+  /** What the proposal does. */
+  kind: 'create-page' | 'update-page' | 'append-section' | 'create-claim' | 'lift-raw' | 'mark-stale';
+  /** Locus on disk (page slug or claim topic). */
+  locus: string;
+  /**
+   * Page write blocks the standard `applyKnowledgeWriteBlocks` consumer
+   * accepts. Empty for proposals that don't change page text (e.g.
+   * `create-claim` produces a `claim` field instead).
+   */
+  writeBlocks: KnowledgeWriteBlock[];
+  /**
+   * Granular claim draft for proposals whose unit-of-change is a claim
+   * row rather than a whole page. `status: 'draft'` until reviewed.
+   */
+  claim?: KnowledgeClaim;
+  /** Per-proposal metadata: severity, confidence, source span. */
+  metadata: {
+    severity: AnalystSeverity;
+    confidence: number;
+    evidence_uri?: string;
+    analyst_id: string;
+  };
 }
 declare class KnowledgeProposalParseError extends Error {
-    readonly findingId: string;
-    readonly subject: string;
-    constructor(findingId: string, subject: string, message: string);
+  readonly findingId: string;
+  readonly subject: string;
+  constructor(findingId: string, subject: string, message: string);
 }
 /**
  * Convert one `AnalystFinding` into a knowledge proposal. Returns
@@ -2460,194 +2290,153 @@ declare function proposeFromFinding(finding: AnalystFinding): KnowledgeProposal
  * decides per-error whether to abort or continue.
  */
 interface ProposeFromFindingsResult {
-    proposals: KnowledgeProposal[];
-    skipped: number;
-    errors: KnowledgeProposalParseError[];
+  proposals: KnowledgeProposal[];
+  skipped: number;
+  errors: KnowledgeProposalParseError[];
 }
 declare function proposeFromFindings(findings: ReadonlyArray<AnalystFinding>): ProposeFromFindingsResult;
-
+//#endregion
+//#region src/readiness-check.d.ts
 interface EvaluateKnowledgeBaseReadinessOptions {
-    root: string;
-    goal: string;
-    readinessSpecs?: readonly KnowledgeReadinessSpec[];
-    readinessTaskId?: string;
-    readiness?: Omit<BuildEvalKnowledgeBundleOptions, 'taskId' | 'index' | 'specs'>;
-    strict?: ValidateKnowledgeOptions['strict'];
-    kbQuality?: KnowledgeBaseQualityOptions;
+  root: string;
+  goal: string;
+  readinessSpecs?: readonly KnowledgeReadinessSpec[];
+  readinessTaskId?: string;
+  readiness?: Omit<BuildEvalKnowledgeBundleOptions, 'taskId' | 'index' | 'specs'>;
+  strict?: ValidateKnowledgeOptions['strict'];
+  kbQuality?: KnowledgeBaseQualityOptions;
 }
 interface KnowledgeBaseReadinessEvaluation {
-    ready: boolean;
-    summary: string;
-    index: KnowledgeIndex;
-    validation: ValidateKnowledgeResult;
-    readiness?: EvalKnowledgeBundleBuildResult;
-    kbQuality: KnowledgeBaseQualityReport;
-    dimensions: {
-        validation: number;
-        kb_quality: number;
-        blocking_readiness: number;
-    };
+  ready: boolean;
+  summary: string;
+  index: KnowledgeIndex;
+  validation: ValidateKnowledgeResult;
+  readiness?: EvalKnowledgeBundleBuildResult;
+  kbQuality: KnowledgeBaseQualityReport;
+  dimensions: {
+    validation: number;
+    kb_quality: number;
+    blocking_readiness: number;
+  };
 }
 declare function evaluateKnowledgeBaseReadiness(options: EvaluateKnowledgeBaseReadinessOptions): Promise<KnowledgeBaseReadinessEvaluation>;
-
+//#endregion
+//#region src/release.d.ts
 interface KnowledgeReleaseReport {
-    release: KnowledgeRelease;
-    scorecard: ReleaseConfidenceScorecard;
-    candidateRuns: RunRecord[];
-    baselineRuns: RunRecord[];
+  release: KnowledgeRelease;
+  scorecard: ReleaseConfidenceScorecard;
+  candidateRuns: RunRecord[];
+  baselineRuns: RunRecord[];
 }
 /**
  * Build a knowledge release report from candidate and baseline run records,
  * optional trace evidence, and an optional decision record.
  */
 interface KnowledgeReleaseInput {
-    candidateId: string;
-    baselineId?: string;
-    candidateRuns: RunRecord[];
-    baselineRuns?: RunRecord[];
-    traces?: ReleaseTraceEvidence[];
-    gateDecision?: GateDecision | null;
-    /** Scenario corpus used to prove train and holdout split coverage. */
-    scenarios?: readonly DatasetScenario[];
-    /**
-     * Require both a holdout scenario and a holdout run.
-     * Provide `scenarios` with at least one `split: 'holdout'` item when true.
-     */
-    hasHoldout?: boolean;
-    /** Candidate is the search-best variant — a promotion precondition. Default true. */
-    promotedIsBest?: boolean;
-    createdAt?: string;
-    minScore?: number;
+  candidateId: string;
+  baselineId?: string;
+  candidateRuns: RunRecord[];
+  baselineRuns?: RunRecord[];
+  traces?: ReleaseTraceEvidence[];
+  gateDecision?: GateDecision | null;
+  /** Scenario corpus used to prove train and holdout split coverage. */
+  scenarios?: readonly DatasetScenario[];
+  /**
+   * Require both a holdout scenario and a holdout run.
+   * Provide `scenarios` with at least one `split: 'holdout'` item when true.
+   */
+  hasHoldout?: boolean;
+  /** Candidate is the search-best variant — a promotion precondition. Default true. */
+  promotedIsBest?: boolean;
+  createdAt?: string;
+  minScore?: number;
 }
 declare function knowledgeReleaseReport(input: KnowledgeReleaseInput): KnowledgeReleaseReport;
-
-/**
- * Research-DRIVING driver for `runVerifiedResearchLoop`.
- *
- * The shipped drivers all FILTER the worker's sources:
- *   - `createVerifyingResearchDriver` judges on-topic relevance,
- *   - `createAdaptiveResearchDriver` dedups then triages then escalates,
- *   - `createClaimGroundingVerifier` rejects misattributed citations.
- *
- * This driver does the OPPOSITE job: instead of narrowing the worker's output,
- * it DRIVES the research DEEPER each round. Its value is not "fewer sources" —
- * it is "more answered, better-corroborated sub-questions". Concretely, each
- * round it:
- *
- *   1. EXTRACTS the key claims from the worker's new sources (one LLM pass per
- *      source, in `verifySource`; falls back to a deterministic sentence-pull
- *      when the model is unavailable so a round never silently extracts nothing).
- *   2. TRACKS each claim's support — the set of INDEPENDENT sources (by canonical
- *      host) that assert it — and detects CONTRADICTIONS between a new claim and
- *      one already on the ledger.
- *   3. GENERATES the next round's DEEP sub-questions from the accumulated claims,
- *      in four kinds — comparative ("how does X's tradeoff differ from Y's?"),
- *      mechanism ("under what precise condition does X fail?"), gap ("what
- *      specific result is missing?"), and contradiction ("does any source
- *      challenge claim Z?").
- *   4. FLAGS weakly-supported claims (only ONE independent source) and
- *      contradicted claims as INVALIDATION targets and demands the worker find
- *      corroborating / refuting evidence for them.
- *   5. FOLDS the deep sub-questions + invalidation challenges into the worker's
- *      next prompt via the loop's `foldGaps` → `steer` channel — that is the
- *      mechanism that drives DEPTH and VALIDATION rather than breadth.
- *
- * COMPLETION (`isComplete` / the `done` judgment the caller gates on) does NOT
- * look at source COUNT. It is done only when every deep sub-question it raised
- * has been addressed AND every key claim is either supported by >= 2 independent
- * sources OR explicitly marked CONTESTED (a contradiction the loop surfaced and
- * could not resolve). A KB with twenty sources all asserting one unchallenged
- * claim is NOT done; a KB whose handful of claims are each corroborated or
- * contested IS.
- *
- * It reuses `runVerifiedResearchLoop` (it is a plain `ResearchDriver`), the web
- * worker, `sha256` (claim identity), `canonicalizeUrl` (independent-source
- * identity), and the `RouterClient` chat surface; it reinvents none of them.
- */
-
+//#endregion
+//#region src/research-driving-driver.d.ts
 /** The four deep sub-question kinds the driver generates to drive depth. */
 type DeepQuestionKind = 'comparative' | 'mechanism' | 'gap' | 'contradiction';
 /** A deep sub-question the driver folds into the worker's next prompt. */
 interface DeepQuestion {
-    kind: DeepQuestionKind;
-    text: string;
-    /** sha256-derived stable id, so "addressed" can be tracked across rounds. */
-    id: string;
-    /** Claim id(s) this question interrogates (for contradiction/mechanism kinds). */
-    claimIds: string[];
-    /** True once a later round's evidence addressed it (see `markAddressed`). */
-    addressed: boolean;
-    /** The round this question was raised in. */
-    raisedRound: number;
+  kind: DeepQuestionKind;
+  text: string;
+  /** sha256-derived stable id, so "addressed" can be tracked across rounds. */
+  id: string;
+  /** Claim id(s) this question interrogates (for contradiction/mechanism kinds). */
+  claimIds: string[];
+  /** True once a later round's evidence addressed it (see `markAddressed`). */
+  addressed: boolean;
+  /** The round this question was raised in. */
+  raisedRound: number;
 }
 /** One tracked claim plus the independent sources that assert it. */
 interface TrackedClaim {
-    id: string;
-    /** The claim text as first extracted (kept for prompts/audit). */
-    text: string;
-    /** Canonical hosts of the INDEPENDENT sources that assert this claim. */
-    supportingHosts: Set<string>;
-    /** Source URIs that assert this claim (provenance; may share a host). */
-    supportingUris: string[];
-    /** Claim ids this claim was found to CONTRADICT (and vice versa). */
-    contradicts: Set<string>;
-    /**
-     * CONTESTED = a contradiction the loop surfaced but could not resolve to a
-     * single supported claim. A contested claim counts as "settled enough to be
-     * done" (we report the disagreement) even with < 2 independent sources.
-     */
-    contested: boolean;
-    firstSeenRound: number;
+  id: string;
+  /** The claim text as first extracted (kept for prompts/audit). */
+  text: string;
+  /** Canonical hosts of the INDEPENDENT sources that assert this claim. */
+  supportingHosts: Set<string>;
+  /** Source URIs that assert this claim (provenance; may share a host). */
+  supportingUris: string[];
+  /** Claim ids this claim was found to CONTRADICT (and vice versa). */
+  contradicts: Set<string>;
+  /**
+   * CONTESTED = a contradiction the loop surfaced but could not resolve to a
+   * single supported claim. A contested claim counts as "settled enough to be
+   * done" (we report the disagreement) even with < 2 independent sources.
+   */
+  contested: boolean;
+  firstSeenRound: number;
 }
 /** The driver's accumulated research state — the completion oracle reads this. */
 interface ResearchDrivingState {
-    /** Every claim extracted from the worker's sources, 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;
+  /** Every claim extracted from the worker's sources, 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;
 }
 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;
+  /** 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;
 }
 /** What the driver folded into one round's worker prompt, surfaced for audit. */
 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;
+  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
@@ -2655,25 +2444,45 @@ interface ResearchDrivingSteer {
  * how `createAdaptiveResearchDriver` exposes `stats()`.
  */
 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;
+  /** 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;
 }
 declare function createResearchDrivingDriver(options?: ResearchDrivingDriverOptions): ResearchDrivingDriver;
-
+//#endregion
+//#region src/schemas.d.ts
 declare const SourceAnchorSchema: z.ZodObject<{
+  id: z.ZodString;
+  sourceId: z.ZodString;
+  label: z.ZodOptional<z.ZodString>;
+  page: z.ZodOptional<z.ZodNumber>;
+  lineStart: z.ZodOptional<z.ZodNumber>;
+  lineEnd: z.ZodOptional<z.ZodNumber>;
+  charStart: z.ZodOptional<z.ZodNumber>;
+  charEnd: z.ZodOptional<z.ZodNumber>;
+  timestampMs: z.ZodOptional<z.ZodNumber>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+declare const SourceRecordSchema: z.ZodObject<{
+  id: z.ZodString;
+  uri: z.ZodString;
+  title: z.ZodOptional<z.ZodString>;
+  mediaType: z.ZodOptional<z.ZodString>;
+  contentHash: z.ZodString;
+  text: z.ZodOptional<z.ZodString>;
+  anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
     id: z.ZodString;
     sourceId: z.ZodString;
     label: z.ZodOptional<z.ZodString>;
@@ -2684,8 +2493,41 @@ declare const SourceAnchorSchema: z.ZodObject<{
     charEnd: z.ZodOptional<z.ZodNumber>;
     timestampMs: z.ZodOptional<z.ZodNumber>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  }, z.core.$strip>>>;
+  validUntil: z.ZodOptional<z.ZodISODateTime>;
+  lastVerifiedAt: z.ZodOptional<z.ZodISODateTime>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  createdAt: z.ZodString;
 }, z.core.$strip>;
-declare const SourceRecordSchema: z.ZodObject<{
+declare const KnowledgePageSchema: z.ZodObject<{
+  id: z.ZodString;
+  path: z.ZodString;
+  title: z.ZodString;
+  text: z.ZodString;
+  frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+  sourceIds: z.ZodArray<z.ZodString>;
+  tags: z.ZodArray<z.ZodString>;
+  outLinks: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const KnowledgeGraphNodeSchema: z.ZodObject<{
+  id: z.ZodString;
+  title: z.ZodString;
+  path: z.ZodString;
+  tags: z.ZodArray<z.ZodString>;
+  sourceIds: z.ZodArray<z.ZodString>;
+  outDegree: z.ZodNumber;
+  inDegree: z.ZodNumber;
+}, z.core.$strip>;
+declare const KnowledgeGraphEdgeSchema: z.ZodObject<{
+  source: z.ZodString;
+  target: z.ZodString;
+  weight: z.ZodNumber;
+  reasons: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+declare const KnowledgeIndexSchema: z.ZodObject<{
+  root: z.ZodString;
+  generatedAt: z.ZodString;
+  sources: z.ZodArray<z.ZodObject<{
     id: z.ZodString;
     uri: z.ZodString;
     title: z.ZodOptional<z.ZodString>;
@@ -2693,23 +2535,23 @@ declare const SourceRecordSchema: z.ZodObject<{
     contentHash: z.ZodString;
     text: z.ZodOptional<z.ZodString>;
     anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        sourceId: z.ZodString;
-        label: z.ZodOptional<z.ZodString>;
-        page: z.ZodOptional<z.ZodNumber>;
-        lineStart: z.ZodOptional<z.ZodNumber>;
-        lineEnd: z.ZodOptional<z.ZodNumber>;
-        charStart: z.ZodOptional<z.ZodNumber>;
-        charEnd: z.ZodOptional<z.ZodNumber>;
-        timestampMs: z.ZodOptional<z.ZodNumber>;
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+      id: z.ZodString;
+      sourceId: z.ZodString;
+      label: z.ZodOptional<z.ZodString>;
+      page: z.ZodOptional<z.ZodNumber>;
+      lineStart: z.ZodOptional<z.ZodNumber>;
+      lineEnd: z.ZodOptional<z.ZodNumber>;
+      charStart: z.ZodOptional<z.ZodNumber>;
+      charEnd: z.ZodOptional<z.ZodNumber>;
+      timestampMs: z.ZodOptional<z.ZodNumber>;
+      metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>>>;
     validUntil: z.ZodOptional<z.ZodISODateTime>;
     lastVerifiedAt: z.ZodOptional<z.ZodISODateTime>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     createdAt: z.ZodString;
-}, z.core.$strip>;
-declare const KnowledgePageSchema: z.ZodObject<{
+  }, z.core.$strip>>;
+  pages: z.ZodArray<z.ZodObject<{
     id: z.ZodString;
     path: z.ZodString;
     title: z.ZodString;
@@ -2718,147 +2560,97 @@ declare const KnowledgePageSchema: z.ZodObject<{
     sourceIds: z.ZodArray<z.ZodString>;
     tags: z.ZodArray<z.ZodString>;
     outLinks: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
-declare const KnowledgeGraphNodeSchema: z.ZodObject<{
-    id: z.ZodString;
-    title: z.ZodString;
-    path: z.ZodString;
-    tags: z.ZodArray<z.ZodString>;
-    sourceIds: z.ZodArray<z.ZodString>;
-    outDegree: z.ZodNumber;
-    inDegree: z.ZodNumber;
-}, z.core.$strip>;
-declare const KnowledgeGraphEdgeSchema: z.ZodObject<{
-    source: z.ZodString;
-    target: z.ZodString;
-    weight: z.ZodNumber;
-    reasons: z.ZodArray<z.ZodString>;
-}, z.core.$strip>;
-declare const KnowledgeIndexSchema: z.ZodObject<{
-    root: z.ZodString;
-    generatedAt: z.ZodString;
-    sources: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        uri: z.ZodString;
-        title: z.ZodOptional<z.ZodString>;
-        mediaType: z.ZodOptional<z.ZodString>;
-        contentHash: z.ZodString;
-        text: z.ZodOptional<z.ZodString>;
-        anchors: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            sourceId: z.ZodString;
-            label: z.ZodOptional<z.ZodString>;
-            page: z.ZodOptional<z.ZodNumber>;
-            lineStart: z.ZodOptional<z.ZodNumber>;
-            lineEnd: z.ZodOptional<z.ZodNumber>;
-            charStart: z.ZodOptional<z.ZodNumber>;
-            charEnd: z.ZodOptional<z.ZodNumber>;
-            timestampMs: z.ZodOptional<z.ZodNumber>;
-            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        }, z.core.$strip>>>;
-        validUntil: z.ZodOptional<z.ZodISODateTime>;
-        lastVerifiedAt: z.ZodOptional<z.ZodISODateTime>;
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        createdAt: z.ZodString;
+  }, z.core.$strip>>;
+  graph: z.ZodObject<{
+    nodes: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      title: z.ZodString;
+      path: z.ZodString;
+      tags: z.ZodArray<z.ZodString>;
+      sourceIds: z.ZodArray<z.ZodString>;
+      outDegree: z.ZodNumber;
+      inDegree: z.ZodNumber;
     }, z.core.$strip>>;
-    pages: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        path: z.ZodString;
-        title: z.ZodString;
-        text: z.ZodString;
-        frontmatter: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-        sourceIds: z.ZodArray<z.ZodString>;
-        tags: z.ZodArray<z.ZodString>;
-        outLinks: z.ZodArray<z.ZodString>;
+    edges: z.ZodArray<z.ZodObject<{
+      source: z.ZodString;
+      target: z.ZodString;
+      weight: z.ZodNumber;
+      reasons: z.ZodArray<z.ZodString>;
     }, z.core.$strip>>;
-    graph: z.ZodObject<{
-        nodes: z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            title: z.ZodString;
-            path: z.ZodString;
-            tags: z.ZodArray<z.ZodString>;
-            sourceIds: z.ZodArray<z.ZodString>;
-            outDegree: z.ZodNumber;
-            inDegree: z.ZodNumber;
-        }, z.core.$strip>>;
-        edges: z.ZodArray<z.ZodObject<{
-            source: z.ZodString;
-            target: z.ZodString;
-            weight: z.ZodNumber;
-            reasons: z.ZodArray<z.ZodString>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>;
+  }, z.core.$strip>;
 }, z.core.$strip>;
 declare const KnowledgeEventSchema: z.ZodObject<{
-    id: z.ZodString;
-    type: z.ZodEnum<{
-        "source.added": "source.added";
-        "proposal.applied": "proposal.applied";
-        "index.built": "index.built";
-        "lint.run": "lint.run";
-        "optimization.run": "optimization.run";
-        "release.promoted": "release.promoted";
-        "release.rejected": "release.rejected";
-    }>;
-    createdAt: z.ZodString;
-    actor: z.ZodOptional<z.ZodString>;
-    target: z.ZodOptional<z.ZodString>;
-    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+  id: z.ZodString;
+  type: z.ZodEnum<{
+    "index.built": "index.built";
+    "lint.run": "lint.run";
+    "optimization.run": "optimization.run";
+    "proposal.applied": "proposal.applied";
+    "release.promoted": "release.promoted";
+    "release.rejected": "release.rejected";
+    "source.added": "source.added";
+  }>;
+  createdAt: z.ZodString;
+  actor: z.ZodOptional<z.ZodString>;
+  target: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
 declare const KnowledgeBaseCandidateSchema: z.ZodObject<{
+  id: z.ZodString;
+  units: z.ZodArray<z.ZodObject<{
     id: z.ZodString;
-    units: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        title: z.ZodString;
-        text: z.ZodString;
-        claims: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            id: z.ZodString;
-            text: z.ZodString;
-            refs: z.ZodArray<z.ZodObject<{
-                sourceId: z.ZodString;
-                anchorId: z.ZodOptional<z.ZodString>;
-                quote: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-            confidence: z.ZodOptional<z.ZodNumber>;
-            status: z.ZodOptional<z.ZodEnum<{
-                draft: "draft";
-                active: "active";
-                superseded: "superseded";
-                rejected: "rejected";
-            }>>;
-            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        }, z.core.$strip>>>;
-        relations: z.ZodOptional<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>>>;
-        sourceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-        updatedAt: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    retrievalPolicy: z.ZodOptional<z.ZodString>;
-    synthesisPolicy: z.ZodOptional<z.ZodString>;
-    questionPolicy: z.ZodOptional<z.ZodString>;
-    updatePolicy: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    text: z.ZodString;
+    claims: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      text: z.ZodString;
+      refs: z.ZodArray<z.ZodObject<{
+        sourceId: z.ZodString;
+        anchorId: z.ZodOptional<z.ZodString>;
+        quote: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+      confidence: z.ZodOptional<z.ZodNumber>;
+      status: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        draft: "draft";
+        rejected: "rejected";
+        superseded: "superseded";
+      }>>;
+      metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+    relations: z.ZodOptional<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>>>;
+    sourceIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  retrievalPolicy: z.ZodOptional<z.ZodString>;
+  synthesisPolicy: z.ZodOptional<z.ZodString>;
+  questionPolicy: z.ZodOptional<z.ZodString>;
+  updatePolicy: z.ZodOptional<z.ZodString>;
+  metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, z.core.$strip>;
-
+//#endregion
+//#region src/search.d.ts
 declare function searchKnowledge(index: KnowledgeIndex, query: string, limit?: number): KnowledgeSearchResult[];
 declare function tokenizeQuery(query: string): string[];
 declare function reciprocalRankFusion(rankLists: string[][], k?: number): Map<string, number>;
-
+//#endregion
+//#region src/store.d.ts
 interface KnowledgeLayout {
-    root: string;
-    knowledgeDir: string;
-    rawSourcesDir: string;
-    sourceRegistryPath: string;
-    indexPath: string;
-    logPath: string;
-    cacheDir: string;
+  root: string;
+  knowledgeDir: string;
+  rawSourcesDir: string;
+  sourceRegistryPath: string;
+  indexPath: string;
+  logPath: string;
+  cacheDir: string;
 }
 declare function layoutFor(root: string): KnowledgeLayout;
 /**
@@ -2881,12 +2673,15 @@ declare function isScaffoldPath(path: string): boolean;
 declare function initKnowledgeBase(root: string): Promise<KnowledgeLayout>;
 declare function loadKnowledgePages(root: string): Promise<KnowledgePage[]>;
 declare function writeJson(path: string, value: unknown): Promise<void>;
-
+//#endregion
+//#region src/wikilinks.d.ts
 declare const WIKILINK_REGEX: RegExp;
 declare function extractWikilinks(content: string): string[];
 declare function normalizeLinkTarget(target: string): string;
-
+//#endregion
+//#region src/write-protocol.d.ts
 declare function isSafeKnowledgePath(path: string, allowedPrefixes?: string[]): boolean;
 declare function parseKnowledgeWriteBlocks(text: string, allowedPrefixes?: string[]): KnowledgeWriteParseResult;
-
-export { type AdaptiveDecision, type AdaptiveDriverOptions, type AdaptiveResearchDriver, type AdaptiveStats, type AddSourceOptions, type AddSourceTextInput, type ApplyWriteBlocksResult, type BuildEvalKnowledgeBundleOptions, type ChunkingOptions, type ClaimGroundingDriverOptions, type CompanyEvalCase, type D1Adapter, type DedupReason, type DeepQuestion, type DeepQuestionKind, type DefineReadinessSpecInput, type DetectChangesOptions, type DetectChangesResult, type DiscoveryLoopResult, type DiscoveryLoopRound, type DiscoveryLoopStopReason, type DiscoveryResult, type DiscoveryTask, type DriverResearchContext, type EvalKnowledgeBundleBuildResult, type EvaluateKnowledgeBaseReadinessOptions, type ExpectedGroup, type ExternalRagEvalScore, type FactResult, type FileSystemFreshnessStoreOptions, FileSystemKbStore, type FileSystemSearchOptions, FileSystemSearchProvider, type FileSystemSearchProviderOptions, type FreshnessKey, type FreshnessMark, type FreshnessRecord, type FreshnessTtl, type GroundClaimOptions, type GroundingResult, type KbStore, KnowledgeBaseCandidateSchema, type KnowledgeBaseQualityOptions, type KnowledgeBaseQualityReport, type KnowledgeBaseReadinessEvaluation, type KnowledgeChange, type KnowledgeChangeKind, type KnowledgeChunk, KnowledgeClaim, type KnowledgeControlLoopAction, type KnowledgeControlLoopActionResult, type KnowledgeControlLoopAdapter, type KnowledgeControlLoopAdapterOptions, type KnowledgeControlLoopState, type KnowledgeDiscoveryDispatcher, type KnowledgeDiscoveryWorker, KnowledgeEvent, type KnowledgeEventQuery, KnowledgeEventSchema, KnowledgeEventType, type KnowledgeExplanation, KnowledgeFragment, type KnowledgeFreshnessStore, type KnowledgeGap, KnowledgeGraph, KnowledgeGraphEdgeSchema, KnowledgeGraphNodeSchema, type KnowledgeImprovementActivationPersistence, type KnowledgeImprovementCandidateRecord, type KnowledgeImprovementCandidateRef, KnowledgeImprovementCandidateRefSchema, type KnowledgeImprovementEvaluationInput, type KnowledgeImprovementEvaluator, type KnowledgeImprovementEvent, type KnowledgeImprovementEvidence, KnowledgeImprovementEvidenceSchema, type KnowledgeImprovementMetric, type KnowledgeImprovementMetricProvenance, type KnowledgeImprovementMutationReceipt, type KnowledgeImprovementMutationResult, type KnowledgeImprovementOptions, type KnowledgeImprovementRagOptimizationOptions, type KnowledgeImprovementRagOptimizationRunInput, type KnowledgeImprovementResult, type KnowledgeImprovementRetrievalOptions, type KnowledgeImprovementRunState, KnowledgeImprovementRunStateSchema, type KnowledgeImprovementStatus, type KnowledgeImprovementTarget, type KnowledgeImprovementUpdate, type KnowledgeImprovementUpdateInput, KnowledgeIndex, KnowledgeIndexSchema, type KnowledgeInspection, type KnowledgeLayout, KnowledgeLintFinding, KnowledgePage, KnowledgePageSchema, type KnowledgePolicyDispatch, type KnowledgeProposal, KnowledgeProposalParseError, type KnowledgeReadinessSpec, KnowledgeRelease, type KnowledgeReleaseInput, type KnowledgeReleaseReport, type KnowledgeResearchLoopContext, type KnowledgeResearchLoopDecision, type KnowledgeResearchLoopResult, type KnowledgeResearchLoopStep, KnowledgeSearchResult, KnowledgeWriteBlock, KnowledgeWriteParseResult, type LoadKnowledgeImprovementActivationResultOptions, type MaterialFact, type MaterialFactLens, type MaterialFactsResult, MemoryKbStore, type OptimizeKnowledgeBasePolicyOptions, type OptimizeKnowledgeBasePolicyResult, type ParsedFrontmatter, type PendingKnowledgeMutation, type PromoteKnowledgeCandidateOptions, type ProposeFromFindingsResult, READINESS_SPEC_DEFAULTS, type RagAnswerEvalArtifact, type RagAnswerEvalCase, type RagAnswerEvalScenario, type RagAnswerMetricSummary, type RagAnswerQualityHookOptions, type RagAnswerQualityInput, type RagAnswerQualityJudgeOptions, type RagAnswerQualityResult, type RagCalibrationOptions, type RagCalibrationResult, type RagDiagnosisInput, type RagEvalCitation, type RagEvalClaim, type RagEvalContext, type RagEvalMetricKey, type RagEvalProvider, type RagEvalSlice, type RagGapFinding, type RagGapKind, type RagGapSeverity, type RagKnowledgeAcquisitionInput, type RagKnowledgeImprovementPhase, type RagKnowledgeImprovementPhaseResult, type RagKnowledgeImprovementPhaseStatus, type RagKnowledgeResearchOptions, type RagKnowledgeUpdateInput, type RagKnowledgeUpdateResult, type RagOptimizationConfig, type RagOptimizationSelection, type RagPhaseInputBase, type RagPromotionInput, type RagPromotionResult, type RagRequiredContext, type RecoverPendingKnowledgeMutationOptions, type RejectedSource, type ResearchContribution, type ResearchDriver, type ResearchDrivingDriver, type ResearchDrivingDriverOptions, type ResearchDrivingState, type ResearchDrivingSteer, type ResearchSourceProposal, type ResearchWorker, type ResolvedKnowledgeImprovementCandidate, type ResolvedKnowledgeImprovementComparison, type ResolvedKnowledgeImprovementComparisonSnapshot, type RestoreKnowledgeCandidateBaselineOptions, RetrievalConfig, RetrievalEvalArtifact, RetrievalEvalRetriever, RetrievalEvalScenario, RetrievalMetricWeights, type RetrievalOptimizationSelection, RetrievedKnowledgeHit, type RouterClient, RouterError, type RouterUsage, type RunDiscoveryLoopOptions, type RunKnowledgeResearchLoopOptions, type RunRagKnowledgeImprovementLoopOptions, type RunRagKnowledgeImprovementLoopResult, type RunRagOptimizationOptions, type RunRagOptimizationResult, type RunRetrievalImprovementLoopOptions, type RunRetrievalImprovementLoopResult, RunSerializedKnowledgeOptimizationOptions, RunSerializedKnowledgeOptimizationResult, SCAFFOLD_PAGE_BASENAMES, type SourceAdapter, type SourceAdapterInput, type SourceAdapterOutput, SourceAnchorSchema, type SourceFreshnessInspection, SourceRecord, SourceRecordSchema, SourceRegistry, type SourceVerdict, type SourceVerificationContext, type TangleRouterOptions, type ThesisRunOptions, type ThesisRunResult, type ThesisTaskInput, type TrackedClaim, type TriageClass, type TwoAgentResearchLoopOptions, type TwoAgentResearchLoopResult, type TwoAgentResearchRound, type UseKnowledgeImprovementCandidateOptions, type ValidateKnowledgeOptions, type ValidateKnowledgeResult, type VerifiedResearchLoopOptions, type VerifiedResearchLoopResult, type VerifiedResearchRound, type VerifyingDriverOptions, WIKILINK_REGEX, type WebResearchWorkerOptions, type WebSearchHit, type WorkerClaimDecorationOptions, type WorkerResearchContext, addSourcePath, addSourceText, applyKnowledgeWriteBlocks, applyKnowledgeWriteBlocksFile, buildEvalKnowledgeBundle, buildKnowledgeGraph, buildKnowledgeIndex, calibrateRagAnswerJudge, canonicalizeUrl, chunkMarkdown, citedClaimKey, citedClaimOf, contentKey, createAdaptiveResearchDriver, createClaimDecorator, createClaimGroundingVerifier, createCollectionResearchDriver, createD1FreshnessStoreStub, createFileSystemFreshnessStore, createFileSystemSearchProvider, createKnowledgeControlLoopAdapter, createKnowledgeEvent, createLocalDiscoveryDispatcher, createRagAnswerQualityHook, createResearchDrivingDriver, createTangleRouterClient, createVerifyingResearchDriver, createWebResearchWorker, defineReadinessSpec, detectChanges, diagnoseRagAnswerFailure, evaluateKnowledgeBaseReadiness, explainKnowledgeTarget, extractWikilinks, formatFrontmatter, fromAgentCandidateKnowledgeRef, gradeCompanyAgainstText, gradeFactAgainstText, groundClaimInText, hashKnowledgeBase, improveKnowledgeBase, initKnowledgeBase, inspectKnowledgeIndex, inspectPendingKnowledgeMutation, investmentThesisSet, isSafeKnowledgePath, isScaffoldPath, kbIndexToText, knowledgeImprovementCandidateRef, knowledgeImprovementRunDir, knowledgeImprovementRunId, knowledgeReleaseReport, layoutFor, lensDistribution, lintKnowledgeIndex, loadKnowledgeImprovementActivationResult, loadKnowledgeImprovementEvents, loadKnowledgeImprovementState, loadKnowledgePages, loadSourceRegistry, materialFactsSurfaced, materialFactsSurfacedInText, mediaTypeFor, normalizeExternalRagScores, normalizeLinkTarget, optimizeKnowledgeBasePolicy, parseFrontmatter, parseKnowledgeWriteBlocks, promoteKnowledgeCandidate, proposeFromFinding, proposeFromFindings, ragAnswerQualityJudge, reciprocalRankFusion, recoverPendingKnowledgeMutation, restoreKnowledgeCandidateBaseline, runDiscoveryLoop, runInvestmentThesisTask, runKnowledgeResearchLoop, runRagKnowledgeImprovementLoop, runRagOptimization, runRetrievalImprovementLoop, runTwoAgentResearchLoop, runVerifiedResearchLoop, scoreKnowledgeBaseIndex, scoreRagAnswerArtifact, searchKnowledge, sha256, slugify, sourceMatchesGaps, sourceRegistryPath, stableId, stripFrontmatter, textSourceAdapter, thesisReadinessSpecs, toAgentCandidateKnowledgeRef, toDeepEvalTestCases, toRagCheckerRecords, toRagasEvaluationRows, toTruLensRecords, tokenizeQuery, totalMaterialFacts, triageSource, validateKnowledgeIndex, withCitedClaim, withKnowledgeImprovementCandidate, withKnowledgeImprovementComparison, writeJson, writeKnowledgeIndex, writeSourceRegistry };
+//#endregion
+export { AdaptiveDecision, AdaptiveDriverOptions, AdaptiveResearchDriver, AdaptiveStats, AddSourceOptions, AddSourceTextInput, AgentMemoryAcquireRunLease, type AgentMemoryActivation, type AgentMemoryActivationDriver, AgentMemoryAdapter, type AgentMemoryAttemptEvent, AgentMemoryBranch, AgentMemoryBranchIsolation, AgentMemoryBranchLifetime, AgentMemoryBranchSnapshot, AgentMemoryContext, AgentMemoryControllerMode, type AgentMemoryDimensionComparison, type AgentMemoryExecutionContext, type AgentMemoryExecutionCostMeter, type AgentMemoryExecutionCostReceipt, type AgentMemoryExecutionPaidCallInput, type AgentMemoryExecutionPaidCallResult, type AgentMemoryExecutionStep, type AgentMemoryExperimentCandidate, type AgentMemoryExperimentRankingRow, type AgentMemoryExperimentRunLease, type AgentMemoryFinalEvaluation, type AgentMemoryFinalPair, AgentMemoryHit, AgentMemoryHitSchema, type AgentMemoryImprovementRunLease, AgentMemoryJournalEntry, AgentMemoryKind, AgentMemoryKindSchema, AgentMemoryLifecycleTimeoutError, AgentMemoryLifecycleUnsafeError, type AgentMemoryPromotionDecision, AgentMemoryRunLease, AgentMemoryScope, AgentMemoryScopeSchema, AgentMemorySearchOptions, type AgentMemorySequence, type AgentMemorySequenceArtifact, type AgentMemorySequenceProbe, type AgentMemorySequenceProbeResult, type AgentMemorySequenceScenario, type AgentMemorySequenceStep, AgentMemorySharingPolicy, AgentMemoryVisibility, AgentMemoryWriteInput, AgentMemoryWriteInputSchema, AgentMemoryWriteResult, ApplyWriteBlocksResult, type BuildAgentMemorySequencesFromBenchmarkCasesOptions, BuildEvalKnowledgeBundleOptions, type BuildRetrievalBenchmarkCasesFromQrelsOptions, BuildRetrievalEvalDispatchOptions, ChunkingOptions, ClaimGroundingDriverOptions, ClaimRef, CompanyEvalCase, CornellLiiSelector, CornellLiiSourceOptions, CreateAgentMemoryBranchOptions, D1Adapter, DEFAULT_MEMORY_CLEANUP_TIMEOUT_MS, DedupReason, DeepQuestion, DeepQuestionKind, DefineReadinessSpecInput, DetectChangesOptions, DetectChangesResult, DiscoveryLoopResult, DiscoveryLoopRound, DiscoveryLoopStopReason, DiscoveryResult, DiscoveryTask, DriverResearchContext, EvalKnowledgeBundleBuildResult, EvaluateKnowledgeBaseReadinessOptions, ExpectedGroup, type ExternalRagEvalScore, FactResult, FetchOpts, FileSystemFreshnessStoreOptions, FileSystemKbStore, FileSystemSearchOptions, FileSystemSearchProvider, FileSystemSearchProviderOptions, ForkAgentMemoryBranchSnapshotOptions, FragmentProvenance, FreshnessKey, FreshnessMark, FreshnessRecord, FreshnessTtl, GraphitiMcpClientLike, GraphitiMemoryAdapterOptions, GraphitiToolNames, GroundClaimOptions, GroundingResult, INDUSTRY_MEMORY_BENCHMARKS, INDUSTRY_RAG_BENCHMARKS, IRS_DIMENSION_HINTS, IrsPublicationsSourceOptions, KbStore, type KnowledgeAnswerBenchmarkCase, type KnowledgeAnswerBenchmarkTaskKind, KnowledgeBaseCandidate, KnowledgeBaseCandidateSchema, type KnowledgeBaseQualityOptions, type KnowledgeBaseQualityReport, KnowledgeBaseReadinessEvaluation, 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, KnowledgeChange, KnowledgeChangeKind, KnowledgeChunk, KnowledgeClaim, type KnowledgeClaimMatcher, KnowledgeControlLoopAction, KnowledgeControlLoopActionResult, KnowledgeControlLoopAdapter, KnowledgeControlLoopAdapterOptions, KnowledgeControlLoopState, KnowledgeDiscoveryDispatcher, KnowledgeDiscoveryWorker, KnowledgeEvent, KnowledgeEventQuery, KnowledgeEventSchema, KnowledgeEventType, KnowledgeExplanation, KnowledgeFragment, KnowledgeFreshnessStore, KnowledgeGap, KnowledgeGraph, KnowledgeGraphEdge, KnowledgeGraphEdgeSchema, KnowledgeGraphNode, KnowledgeGraphNodeSchema, KnowledgeId, type KnowledgeImprovementActivationPersistence, type KnowledgeImprovementCandidateRecord, type KnowledgeImprovementCandidateRef, KnowledgeImprovementCandidateRefSchema, type KnowledgeImprovementEvaluationInput, type KnowledgeImprovementEvaluator, type KnowledgeImprovementEvent, type KnowledgeImprovementEvidence, KnowledgeImprovementEvidenceSchema, type KnowledgeImprovementMetric, type KnowledgeImprovementMetricProvenance, type KnowledgeImprovementMutationReceipt, type KnowledgeImprovementMutationResult, type KnowledgeImprovementOptions, type KnowledgeImprovementRagOptimizationOptions, type KnowledgeImprovementRagOptimizationRunInput, type KnowledgeImprovementResult, type KnowledgeImprovementRetrievalOptions, type KnowledgeImprovementRunState, KnowledgeImprovementRunStateSchema, type KnowledgeImprovementStatus, type KnowledgeImprovementTarget, type KnowledgeImprovementUpdate, type KnowledgeImprovementUpdateInput, KnowledgeIndex, KnowledgeIndexSchema, KnowledgeInspection, KnowledgeLayout, KnowledgeLintFinding, type KnowledgeMemoryBenchmarkCase, type KnowledgeMemoryBenchmarkTaskKind, type KnowledgeMemoryEvent, type KnowledgeMemoryFactMatcher, KnowledgePage, KnowledgePageSchema, KnowledgePolicy, type KnowledgePolicyDispatch, KnowledgeProposal, KnowledgeProposalParseError, KnowledgeReadinessSpec, KnowledgeRelation, KnowledgeRelease, KnowledgeReleaseInput, KnowledgeReleaseReport, KnowledgeResearchLoopContext, KnowledgeResearchLoopDecision, KnowledgeResearchLoopResult, KnowledgeResearchLoopStep, type KnowledgeRetrievalBenchmarkCase, type KnowledgeRetrievalBenchmarkQrel, type KnowledgeRetrievalBenchmarkQuery, KnowledgeSearchResult, KnowledgeSource, KnowledgeUnit, KnowledgeWriteBlock, KnowledgeWriteParseResult, type LoadKnowledgeImprovementActivationResultOptions, MAX_RESPONSE_BYTES, MIN_REQUEST_GAP_MS, MaterialFact, MaterialFactLens, MaterialFactsResult, Mem0ClientMode, Mem0HostedClient, Mem0HostedMemoryAdapterOptions, Mem0MemoryAdapterOptions, Mem0OssClient, Mem0OssMemoryAdapterOptions, type MemoryAdapterBenchmarkCandidate, type MemoryAdapterBenchmarkRankingRow, type MemoryConfigScenario, MemoryKbStore, Neo4jAgentMemoryAdapterOptions, type OptimizeKnowledgeBasePolicyOptions, type OptimizeKnowledgeBasePolicyResult, OwnedAgentMemoryRunLease, POLITE_USER_AGENT, ParsedFrontmatter, PartitionRetrievalScenariosOptions, type PendingKnowledgeMutation, PoliteFetchOptions, PoliteFetchResult, type PromoteKnowledgeCandidateOptions, ProposeFromFindingsResult, READINESS_SPEC_DEFAULTS, type RagAnswerEvalArtifact, type RagAnswerEvalCase, type RagAnswerEvalScenario, type RagAnswerMetricSummary, type RagAnswerQualityHookOptions, RagAnswerQualityInput, type RagAnswerQualityJudgeOptions, RagAnswerQualityResult, type RagCalibrationOptions, type RagCalibrationResult, RagDiagnosisInput, type RagEvalCitation, type RagEvalClaim, type RagEvalContext, type RagEvalMetricKey, type RagEvalProvider, type RagEvalSlice, RagGapFinding, RagGapKind, RagGapSeverity, RagKnowledgeAcquisitionInput, RagKnowledgeImprovementPhase, RagKnowledgeImprovementPhaseResult, RagKnowledgeImprovementPhaseStatus, RagKnowledgeResearchOptions, RagKnowledgeUpdateInput, RagKnowledgeUpdateResult, RagOptimizationConfig, RagOptimizationSelection, RagPhaseInputBase, RagPromotionInput, RagPromotionResult, type RagRequiredContext, type RecoverPendingKnowledgeMutationOptions, RejectedSource, ResearchContribution, ResearchDriver, ResearchDrivingDriver, ResearchDrivingDriverOptions, ResearchDrivingState, ResearchDrivingSteer, ResearchSourceProposal, ResearchWorker, 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, RetrievalOptimizationSelection, RetrievalRecallJudgeOptions, RetrievalScenarioPartitions, RetrievedKnowledgeHit, RetrievedSourceSpan, RouterClient, RouterError, RouterUsage, type RunAgentMemoryExperimentOptions, type RunAgentMemoryExperimentResult, type RunAgentMemoryImprovementOptions, type RunAgentMemoryImprovementResult, RunDiscoveryLoopOptions, type RunKnowledgeBenchmarkSuiteOptions, type RunKnowledgeBenchmarkSuiteResult, RunKnowledgeResearchLoopOptions, type RunMemoryAdapterBenchmarkOptions, type RunMemoryAdapterBenchmarkResult, RunRagKnowledgeImprovementLoopOptions, RunRagKnowledgeImprovementLoopResult, RunRagOptimizationOptions, RunRagOptimizationResult, RunRetrievalImprovementLoopOptions, RunRetrievalImprovementLoopResult, RunSerializedKnowledgeOptimizationOptions, RunSerializedKnowledgeOptimizationResult, SCAFFOLD_PAGE_BASENAMES, SerializedCandidate, SerializedCandidateCodec, SourceAdapter, SourceAdapterInput, SourceAdapterOutput, SourceAnchor, SourceAnchorSchema, SourceFreshnessInspection, SourceRecord, SourceRecordSchema, SourceRegistry, SourceVerdict, SourceVerificationContext, StateSosEntity, StateSosSourceConfig, TangleRouterOptions, ThesisRunOptions, ThesisRunResult, ThesisTaskInput, TrackedClaim, TriageClass, type UseKnowledgeImprovementCandidateOptions, ValidateKnowledgeOptions, ValidateKnowledgeResult, VerifiedResearchLoopOptions, VerifiedResearchLoopResult, VerifiedResearchRound, VerifyingDriverOptions, WIKILINK_REGEX, WebResearchWorkerOptions, WebSearchHit, WorkerClaimDecorationOptions, WorkerResearchContext, __resetHttpThrottle, acquireAgentMemoryRunLease, addSourcePath, addSourceText, agentMemorySequenceJudge, applyKnowledgeWriteBlocks, applyKnowledgeWriteBlocksFile, applyRetrievalHoldout, applySessionStickyRetrievalHoldout, buildAgentMemorySequenceScenarios, buildAgentMemorySequencesFromBenchmarkCases, buildEvalKnowledgeBundle, buildFirstPartyMemoryLifecycleBenchmarkCases, buildIndustryMemoryBenchmarkSmokeCases, buildIndustryRagBenchmarkSmokeCases, buildKnowledgeBenchmarkScenarios, buildKnowledgeGraph, buildKnowledgeIndex, buildRetrievalBenchmarkCasesFromQrels, buildRetrievalEvalDispatch, calibrateRagAnswerJudge, canonicalizeUrl, chunkMarkdown, citedClaimKey, citedClaimOf, contentKey, createAdaptiveResearchDriver, createAgentMemoryBranch, createClaimDecorator, createClaimGroundingVerifier, createCollectionResearchDriver, createCornellLiiSource, createD1FreshnessStoreStub, createFileSystemFreshnessStore, createFileSystemSearchProvider, createGraphitiMemoryAdapter, createInMemoryBenchmarkAdapter, createIrsPublicationsSource, createKnowledgeControlLoopAdapter, createKnowledgeEvent, createLocalDiscoveryDispatcher, createMem0MemoryAdapter, createMemoryExecutionPool, createNeo4jAgentMemoryAdapter, createNoopMemoryBenchmarkAdapter, createRagAnswerQualityHook, createResearchDrivingDriver, createStateSosSource, createTangleRouterClient, createVerifyingResearchDriver, createWebResearchWorker, defaultGetMemoryContext, defineReadinessSpec, detectChanges, deterministicRng, diagnoseRagAnswerFailure, emitRetrievalHoldoutBypass, evaluateKnowledgeBaseReadiness, explainKnowledgeTarget, extractLinks, extractWikilinks, firstMatch, forkAgentMemoryBranchSnapshot, formatFrontmatter, fromAgentCandidateKnowledgeRef, gradeCompanyAgainstText, gradeFactAgainstText, graphitiMemoryAdapterIdentity, groundClaimInText, hashKnowledgeBase, htmlToText, improveKnowledgeBase, initKnowledgeBase, innerHtmlById, inspectKnowledgeIndex, inspectPendingKnowledgeMutation, investmentThesisSet, isKnowledgeMemoryBenchmarkCase, isSafeKnowledgePath, isScaffoldPath, jsonCandidateCodec, jsonObjectCandidateCodec, kbIndexToText, knowledgeBenchmarkJudge, knowledgeImprovementCandidateRef, knowledgeImprovementRunDir, knowledgeImprovementRunId, knowledgeReleaseReport, layoutFor, lensDistribution, lintKnowledgeIndex, loadKnowledgeImprovementActivationResult, loadKnowledgeImprovementEvents, loadKnowledgeImprovementState, loadKnowledgePages, loadSourceRegistry, looksLikeBlockPage, materialFactsSurfaced, materialFactsSurfacedInText, mediaTypeFor, mem0MemoryAdapterIdentity, memoryHitToSourceRecord, memoryRecoveryDelayMs, memoryWriteResultToSourceRecord, normalizeExternalRagScores, normalizeLinkTarget, optimizeKnowledgeBasePolicy, parseFrontmatter, parseKnowledgeBenchmarkJsonl, parseKnowledgeBenchmarkQrels, parseKnowledgeWriteBlocks, partitionRetrievalScenarios, politeFetch, promoteKnowledgeCandidate, proposeFromFinding, proposeFromFindings, ragAnswerQualityJudge, reciprocalRankFusion, recoverPendingKnowledgeMutation, renderKnowledgeBenchmarkReportMarkdown, renderMemoryContext, resetRetrievalHoldoutRegistry, resolveMemoryCleanupTimeoutMs, respondToIndustryMemoryBenchmarkSmokeCase, respondToIndustryRagBenchmarkSmokeCase, restoreKnowledgeCandidateBaseline, retrievalConfigFromSurface, retrievalConfigSurface, retrievalHoldoutConfigHash, retrievalRecallJudge, runAgentMemoryExperiment, runAgentMemoryImprovement, runBoundedMemoryLifecycle, runDiscoveryLoop, runInvestmentThesisTask, runKnowledgeBenchmarkSuite, runKnowledgeResearchLoop, runMemoryAdapterBenchmark, runRagKnowledgeImprovementLoop, runRagOptimization, runRetrievalImprovementLoop, runSerializedKnowledgeOptimization, runVerifiedResearchLoop, scenarioContentFingerprint, scoreKnowledgeBaseIndex, scoreKnowledgeBenchmarkArtifact, scoreMemoryBenchmarkArtifact, scoreRagAnswerArtifact, scoreRetrievalArtifact, searchKnowledge, sha256, sleepForMemoryRecovery, slugify, sourceMatchesGaps, sourceRegistryPath, stableId, stripFrontmatter, summarizeKnowledgeBenchmarkCampaign, textSourceAdapter, thesisReadinessSpecs, toAgentCandidateKnowledgeRef, toDeepEvalTestCases, toOffPolicyTrajectory, toRagCheckerRecords, toRagasEvaluationRows, toTruLensRecords, tokenizeQuery, totalMaterialFacts, triageSource, validateKnowledgeIndex, withCitedClaim, withKnowledgeImprovementCandidate, withKnowledgeImprovementComparison, writeJson, writeKnowledgeIndex, writeSourceRegistry };
+//# sourceMappingURL=index.d.ts.map