@tangle-network/agent-knowledge 19.1.5 → 20.0.1

package/dist/index.js

@@ -1,689 +1,18 @@
-import { $ as snapshotSourceTextInput, $n as mediaTypeFor, $t as SourceRecordSchema, A as validateKnowledgePage, An as finishKnowledgeFileTransaction, At as knowledgePageFromMarkdown, B as DEADLINE_EXIT_CODE, Bn as listRegularFilesWithinRoot, Bt as KnowledgeGraphEdgeSchema, C as immutablePageDigest, Cn as recoverPendingKnowledgeMutation, Ct as resolveKnowledgeCitations, D as normalizeVisibilityArtifact, Dn as applyKnowledgeFileTransaction, Dt as initKnowledgeBase, E as nonEmpty$1, En as withKnowledgeRead, Et as SCAFFOLD_PAGE_BASENAMES, F as detectNearDuplicatePages, Fn as normalizePagesDirectory, Ft as extractWikilinks, G as gradeFor, Gn as renameDurable, Gt as KnowledgeRelationGraphSchema, H as assertGradeableEvidence, Hn as readRegularFileWithinRoot, Ht as KnowledgeIndexSchema, I as normalizePageText, In as canonicalPathsEqual, It as normalizeLinkTarget, J as buildKnowledgeIndex, Jn as withSafeDirectory, Jt as ResearchClaimEvidenceSchema, K as verdictFor, Kn as syncDirectory, Kt as KnowledgeRelationNodeSchema, L as validateKnowledgeIndex, Ln as canonicalRelativeWithinRoot, Lt as DeepQuestionSchema, M as verifyKnowledgeVisibilitySnapshot, Mn as prepareKnowledgeFileTransaction, Mt as loadKnowledgePages, N as visibilityIdentity, Nn as rollbackKnowledgeFileTransaction, Nt as writeJson, O as normalizeVisibilityRef, On as assertKnowledgeMutationPath, Ot as isKnowledgePagePath, P as visibilityIndexOf, Pn as DEFAULT_PAGES_DIRECTORY, Pt as WIKILINK_REGEX, Q as loadSourceRegistry, Qn as writeJsonDurableWithinRoot, Qt as SourceAnchorSchema, R as lintKnowledgeIndex, Rn as isKernelAnchoredPath, Rt as KnowledgeBaseCandidateSchema, S as encodeKnowledgeVisibilitySnapshot, Sn as measureKnowledgeMutation, St as resolveKnowledgeCitation, T as knowledgeVisibilityArtifactRef, Tn as withKnowledgeMutation, Tt as resolveRunScopedCitations, U as claimCheckKey, Un as relativeWithinRoot, Ut as KnowledgePageInvalidationSchema, V as UncheckableClaimError, Vn as readRegularFileNoFollow, Vt as KnowledgeGraphNodeSchema, W as gradeClaims, Wn as removeDurable, Wt as KnowledgePageSchema, X as addSourcePath, Xn as writeFileDurableWithinRoot, Xt as ResearchClaimRecordSchema, Y as writeKnowledgeIndex, Yn as writeFileDurable, Yt as ResearchClaimLedgerSchema, Z as addSourceText, Zn as writeJsonDurable, Zt as ResearchSourceVersionSchema, _ as KNOWLEDGE_USE_RECEIPT_SCHEMA_VERSION, _n as formatFrontmatter, _t as assertRunScopedCitationsResolved, a as applyKnowledgeWriteBlocksFile, an as assertTrackedClaimIntegrity, at as KB_EVENTS_PATH, b as decodeKnowledgeVisibilitySnapshot, bn as inspectPendingKnowledgeMutation, bt as formatKnowledgeCitationReference, c as KnowledgeDuplicateIntakeError, cn as claimSourceHost, ct as MemoryKbStore, d as createFileRunLineageAuthority, dn as linkClaimContradictions, dt as knowledgePageRelations, en as KNOWLEDGE_EVENT_TYPES, er as textSourceAdapter, et as sourceRegistryPath, f as createRunScopedStores, fn as materializeRegisteredClaimEvidence, ft as KnowledgeCitationAuditError, g as KNOWLEDGE_RECEIPT_DIGEST_ALGORITHM, gn as researchSourceVersionKey, gt as assertKnowledgeCitationsResolved, h as originatedPages, hn as normalizeClaimText, ht as assertKnowledgeCitationAudit, i as applyKnowledgeWriteBlocks, in as assertResearchClaimLedgerIntegrity, it as KB_CLAIM_LEDGER_DIR, j as validateOrigin, jn as knowledgeFileTransactionPlanHash, jt as layoutFor, k as snapshotImmutableVisibility, kn as commitKnowledgeFileMutations, kt as isScaffoldPath, l as assertKnowledgeWriteIntake, ln as deepQuestionId, lt as assertClaimLedgerId, m as loadKnowledgeToolChain, mn as mergeTrackedClaims, mt as assertCurrentRunCitationsResolved, n as inspectKnowledgeIndex, nn as assertDeepQuestionIntegrity, nt as ClaimLedgerMigrationRequiredError, o as isSafeKnowledgePath, on as claimEvidenceId, ot as KB_INDEX_PATH, p as isKnowledgeToolChain, pn as mergeClaimLedgers, pt as KnowledgeCitationResolutionError, q as verifyGradeableEvidence, qn as withSafeDescendant, qt as KnowledgeRelationSchema, r as stringMetadata, rn as assertResearchClaimEvidenceIntegrity, rt as FileSystemKbStore, s as parseKnowledgeWriteBlocks, sn as claimId, st as KB_STORE_DIR, t as explainKnowledgeTarget, tn as ClaimLedgerGoalConflictError, tt as writeSourceRegistry, u as RUN_LINEAGE_BASENAME, un as emptyClaimLedger, ut as buildKnowledgeGraph, v as assertSchemaVersion, vn as parseFrontmatter, vt as auditCurrentRunCitations, w as knowledgePageDigest, wn as runInKnowledgeMutationScope, wt as resolveRunScopedCitation, x as digest, xn as isKnowledgeMutationHeld, xt as parseKnowledgeCitationReference, y as createKnowledgeVisibilitySnapshot, yn as acquireDurableFileLock, yt as auditKnowledgeCitations, z as CHECKABLE_RUNG_THRESHOLD, zn as isMissingFile, zt as KnowledgeEventSchema } from "./inspect-C6c4zuKp.js";
+import { $ as assertGradeableEvidence, $n as removeDurable, $t as KnowledgeIndexSchema, A as createKnowledgeVisibilitySnapshot, An as isKnowledgeMutationHeld, At as auditKnowledgeCitations, B as snapshotImmutableVisibility, Bn as knowledgeFileTransactionPlanHash, Bt as isScaffoldPath, C as createRunScopedStores, Cn as mergeTrackedClaims, Ct as KnowledgeCitationAuditError, D as KNOWLEDGE_RECEIPT_DIGEST_ALGORITHM, Dn as parseFrontmatter, Dt as assertKnowledgeCitationsResolved, E as originatedPages, En as formatFrontmatter, Et as assertKnowledgeCitationAudit, F as knowledgePageDigest, Fn as withKnowledgeRead, Ft as resolveRunScopedCitation, G as visibilityIndexOf, Gn as canonicalPathsEqual, Gt as WIKILINK_REGEX, H as validateOrigin, Hn as rollbackKnowledgeFileTransaction, Ht as layoutFor, I as knowledgeVisibilityArtifactRef, In as applyKnowledgeFileTransaction, It as resolveRunScopedCitations, J as validateKnowledgeIndex, Jn as isMissingFile, Jt as DeepQuestionSchema, K as detectNearDuplicatePages, Kn as canonicalRelativeWithinRoot, Kt as extractWikilinks, L as nonEmpty$1, Ln as assertKnowledgeMutationPath, Lt as SCAFFOLD_PAGE_BASENAMES, M as digest, Mn as recoverPendingKnowledgeMutation, Mt as parseKnowledgeCitationReference, N as encodeKnowledgeVisibilitySnapshot, Nn as runInKnowledgeMutationScope, Nt as resolveKnowledgeCitation, O as KNOWLEDGE_USE_RECEIPT_SCHEMA_VERSION, On as acquireDurableFileLock, Ot as assertRunScopedCitationsResolved, P as immutablePageDigest, Pn as withKnowledgeMutation, Pt as resolveKnowledgeCitations, Q as UncheckableClaimError, Qn as relativeWithinRoot, Qt as KnowledgeGraphNodeSchema, R as normalizeVisibilityArtifact, Rn as commitKnowledgeFileMutations, Rt as initKnowledgeBase, S as createFileRunLineageAuthority, Sn as mergeClaimLedgers, St as knowledgePageRelations, T as loadKnowledgeToolChain, Tn as researchSourceVersionKey, Tt as assertCurrentRunCitationsResolved, U as verifyKnowledgeVisibilitySnapshot, Un as DEFAULT_PAGES_DIRECTORY, Ut as loadKnowledgePages, V as validateKnowledgePage, Vn as prepareKnowledgeFileTransaction, Vt as knowledgePageFromMarkdown, W as visibilityIdentity, Wn as normalizePagesDirectory, Wt as writeJson, X as CHECKABLE_RUNG_THRESHOLD, Xn as readRegularFileNoFollow, Xt as KnowledgeEventSchema, Y as lintKnowledgeIndex, Yn as listRegularFilesWithinRoot, Yt as KnowledgeBaseCandidateSchema, Z as DEADLINE_EXIT_CODE, Zn as readRegularFileWithinRoot, Zt as KnowledgeGraphEdgeSchema, _ as isSafeKnowledgePath, _n as claimSourceHost, _t as KB_INDEX_PATH, a as searchKnowledge, an as ResearchClaimRecordSchema, ar as writeFileDurableWithinRoot, at as buildKnowledgeIndex, b as assertKnowledgeWriteIntake, bn as linkClaimContradictions, bt as assertClaimLedgerId, c as scoreBm25, cn as SourceRecordSchema, cr as mediaTypeFor, ct as addSourceText, d as DEFAULT_FIELD_BOOSTS, dn as assertDeepQuestionIntegrity, dt as sourceRegistryPath, en as KnowledgePageInvalidationSchema, er as renameDurable, et as claimCheckKey, f as assembleLexicalIndex, fn as assertResearchClaimEvidenceIntegrity, ft as writeSourceRegistry, g as applyKnowledgeWriteBlocksFile, gn as claimId, gt as KB_EVENTS_PATH, h as applyKnowledgeWriteBlocks, hn as claimEvidenceId, ht as KB_CLAIM_LEDGER_DIR, i as reciprocalRankFusion, in as ResearchClaimLedgerSchema, ir as writeFileDurable, it as verifyGradeableEvidence, j as decodeKnowledgeVisibilitySnapshot, jn as measureKnowledgeMutation, jt as formatKnowledgeCitationReference, k as assertSchemaVersion, kn as inspectPendingKnowledgeMutation, kt as auditCurrentRunCitations, l as tokenizeQuery, ln as KNOWLEDGE_EVENT_TYPES, lr as textSourceAdapter, lt as loadSourceRegistry, m as stringMetadata, mn as assertTrackedClaimIntegrity, mt as FileSystemKbStore, n as inspectKnowledgeIndex, nn as KnowledgeRelationSchema, nr as withSafeDescendant, nt as gradeFor, o as searchKnowledgePages, on as ResearchSourceVersionSchema, or as writeJsonDurable, ot as writeKnowledgeIndex, p as lexicalPageTerms, pn as assertResearchClaimLedgerIntegrity, pt as ClaimLedgerMigrationRequiredError, q as normalizePageText, qn as isKernelAnchoredPath, qt as normalizeLinkTarget, r as KNOWLEDGE_SEARCH_RETRIEVER_ID, rn as ResearchClaimEvidenceSchema, rr as withSafeDirectory, rt as verdictFor, s as buildKnowledgeLexicalIndex, sn as SourceAnchorSchema, sr as writeJsonDurableWithinRoot, st as addSourcePath, t as explainKnowledgeTarget, tn as KnowledgePageSchema, tr as syncDirectory, tt as gradeClaims, u as tokenizeText, un as ClaimLedgerGoalConflictError, ut as snapshotSourceTextInput, v as parseKnowledgeWriteBlocks, vn as deepQuestionId, vt as KB_STORE_DIR, w as isKnowledgeToolChain, wn as normalizeClaimText, wt as KnowledgeCitationResolutionError, x as RUN_LINEAGE_BASENAME, xn as materializeRegisteredClaimEvidence, xt as buildKnowledgeGraph, y as KnowledgeDuplicateIntakeError, yn as emptyClaimLedger, yt as MemoryKbStore, z as normalizeVisibilityRef, zn as finishKnowledgeFileTransaction, zt as isKnowledgePagePath } from "./inspect-CMigdsD5.js";
 import { i as textSourceId, n as slugify, r as stableId, t as sha256 } from "./ids-Bevz_pXV.js";
-import { A as retrievalHoldoutConfigHash, C as defaultGetMemoryContext, D as deterministicRng, E as applySessionStickyRetrievalHoldout, F as scenarioContentFingerprint, I as assertImmutableRef, M as jsonCandidateCodec, N as jsonObjectCandidateCodec, O as emitRetrievalHoldoutBypass, P as runSerializedKnowledgeOptimization, S as forkAgentMemoryBranchSnapshot, T as applyRetrievalHoldout, _ as runAgentMemoryExperiment, a as runAgentMemoryImprovement, b as buildAgentMemorySequencesFromBenchmarkCases, c as hindsightMemoryBankId, d as AgentMemoryScopeSchema, f as AgentMemoryWriteInputSchema, g as runAgentMemoryLearningExperiment, h as compareAgentMemoryLearning, i as mem0MemoryAdapterIdentity, j as toOffPolicyTrajectory, k as resetRetrievalHoldoutRegistry, l as AgentMemoryHitSchema, m as graphitiMemoryAdapterIdentity, n as createNeo4jAgentMemoryAdapter, o as HindsightOperationUnknownError, p as createGraphitiMemoryAdapter, r as createMem0MemoryAdapter, s as createHindsightMemoryAdapter, t as createPlayMemoryTools, u as AgentMemoryKindSchema, v as agentMemorySequenceJudge, w as renderMemoryContext, x as createAgentMemoryBranch, y as buildAgentMemorySequenceScenarios } from "./memory-CUk1mgPY.js";
-import { C as sleepForMemoryRecovery, F as buildIndustryRagBenchmarkSmokeCases, G as buildRetrievalEvalDispatch, H as createNoopMemoryBenchmarkAdapter, I as respondToIndustryMemoryBenchmarkSmokeCase, J as retrievalConfigSurface, K as partitionRetrievalScenarios, L as respondToIndustryRagBenchmarkSmokeCase, M as INDUSTRY_RAG_BENCHMARKS, N as buildFirstPartyMemoryLifecycleBenchmarkCases, P as buildIndustryMemoryBenchmarkSmokeCases, R as isKnowledgeMemoryBenchmarkCase, S as runBoundedMemoryLifecycle, U as memoryHitToSourceRecord, V as createInMemoryBenchmarkAdapter, W as memoryWriteResultToSourceRecord, X as scoreRetrievalArtifact, Y as retrievalRecallJudge, Z as mean, a as buildKnowledgeBenchmarkScenarios, b as memoryRecoveryDelayMs, c as runKnowledgeBenchmarkSuite, d as summarizeKnowledgeBenchmarkCampaign, f as acquireAgentMemoryRunLease, h as DEFAULT_MEMORY_CLEANUP_TIMEOUT_MS, i as runMemoryAdapterBenchmark, j as INDUSTRY_MEMORY_BENCHMARKS, l as scoreKnowledgeBenchmarkArtifact, m as AgentMemoryLifecycleUnsafeError, n as parseKnowledgeBenchmarkJsonl, o as knowledgeBenchmarkJudge, p as AgentMemoryLifecycleTimeoutError, q as retrievalConfigFromSurface, r as parseKnowledgeBenchmarkQrels, s as renderKnowledgeBenchmarkReportMarkdown, t as buildRetrievalBenchmarkCasesFromQrels, u as scoreMemoryBenchmarkArtifact, x as resolveMemoryCleanupTimeoutMs, y as createMemoryExecutionPool } from "./benchmarks-BjXxjAke.js";
-import { a as buildKnowledgeLexicalIndex, c as tokenizeText, d as lexicalPageTerms, i as searchKnowledgePages, l as DEFAULT_FIELD_BOOSTS, n as reciprocalRankFusion, o as scoreBm25, r as searchKnowledge, s as tokenizeQuery, t as KNOWLEDGE_SEARCH_RETRIEVER_ID, u as assembleLexicalIndex } from "./search-BBr5eUyT.js";
-import { IRS_DIMENSION_HINTS, MAX_RESPONSE_BYTES, MIN_REQUEST_GAP_MS, POLITE_USER_AGENT, __resetHttpThrottle, createCornellLiiSource, createIrsPublicationsSource, createStateSosSource, extractLinks, firstMatch, htmlToText, innerHtmlById, looksLikeBlockPage, politeFetch } from "./sources/index.js";
-import { createHash } from "node:crypto";
-import { TCloudClient, TCloudError } from "@tangle-network/tcloud";
-import { cp, lstat, mkdir, mkdtemp, readFile, rm, stat } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { agentImprovementActivationResultSchema, agentImprovementActivationSchema, canonicalCandidateDigest, canonicalCandidateJson, omitTopLevelDigest, sha256Bytes, sha256DigestSchema } from "@tangle-network/agent-interface";
+import { n as memoryWriteResultToSourceRecord, t as memoryHitToSourceRecord } from "./source-record-CdWvzvO6.js";
+import { n as createNoopMemoryBenchmarkAdapter, t as createInMemoryBenchmarkAdapter } from "./benchmarks-jir3ZP-M.js";
+import { A as resetRetrievalHoldoutRegistry, C as forkAgentMemoryBranchSnapshot, D as applySessionStickyRetrievalHoldout, E as applyRetrievalHoldout, M as toOffPolicyTrajectory, O as deterministicRng, S as createAgentMemoryBranch, T as renderMemoryContext, _ as resolveMemoryCleanupTimeoutMs, a as HindsightOperationUnknownError, b as createGraphitiMemoryAdapter, c as AgentMemoryHitSchema, d as AgentMemoryWriteInputSchema, f as AgentMemoryLifecycleTimeoutError, g as memoryRecoveryDelayMs, h as createMemoryExecutionPool, i as mem0MemoryAdapterIdentity, j as retrievalHoldoutConfigHash, k as emitRetrievalHoldoutBypass, l as AgentMemoryKindSchema, m as DEFAULT_MEMORY_CLEANUP_TIMEOUT_MS, n as createNeo4jAgentMemoryAdapter, o as createHindsightMemoryAdapter, p as AgentMemoryLifecycleUnsafeError, r as createMem0MemoryAdapter, s as hindsightMemoryBankId, t as createPlayMemoryTools, u as AgentMemoryScopeSchema, v as runBoundedMemoryLifecycle, w as defaultGetMemoryContext, x as graphitiMemoryAdapterIdentity, y as sleepForMemoryRecovery } from "./memory-BH6oT1Qe.js";
+import { agentImprovementActivationResultSchema, agentImprovementActivationSchema, canonicalCandidateDigest, omitTopLevelDigest, sha256Bytes, sha256DigestSchema } from "@tangle-network/agent-interface";
 import { acquisitionPlansForKnowledgeGaps, blockingKnowledgeEval, canonicalJson, contentHash, evaluateReleaseConfidence, objectiveEval, scoreKnowledgeReadiness, userQuestionsForKnowledgeGaps, validateRunRecord } from "@tangle-network/agent-eval";
 import { z } from "zod";
-import { surfaceHash } from "@tangle-network/agent-eval/campaign";
+import { createHash } from "node:crypto";
+import { cp, lstat, mkdir, mkdtemp, rm, stat } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { compareOptimizationMethods, surfaceHash } from "@tangle-network/agent-eval/campaign";
 import { tmpdir } from "node:os";
 import { isDeepStrictEqual } from "node:util";
 import { pathToFileURL } from "node:url";
-//#region src/web-research-worker.ts
-/**
-* 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.
-*
-* Model and search requests use the published TCloud SDK. Knowledge owns the
-* research policy, not HTTP, bearer headers, retries or provider rate cards.
-* Point it at any router with `baseUrl`; supply `apiKey` or `TANGLE_API_KEY`.
-*/
-/** Default router model. Plain id (no namespace) — see CLAUDE/creds notes. */
-const DEFAULT_MODEL = "glm-5.2";
-/** Default router base. */
-const DEFAULT_BASE_URL = "https://router.tangle.tools/v1";
-/**
-* glm-5.2 spends its first tokens on hidden `reasoning_content`; below ~1200
-* output tokens it returns EMPTY visible content. Floor every call so a
-* reasoning model never silently yields nothing. (Verified creds note.)
-*/
-const MIN_MAX_TOKENS = 1200;
-/** Compatibility error facade. HTTP execution and classification belong to TCloud. */
-var RouterError = class extends Error {
-	status;
-	constructor(status, message) {
-		super(`router ${status}: ${message}`);
-		this.status = status;
-		this.name = "RouterError";
-	}
-};
-/** Adapt Knowledge's public contract to the published SDK, without a second transport. */
-function createTangleRouterClient(options = {}) {
-	const apiKey = options.apiKey ?? process.env.TANGLE_API_KEY;
-	if (!apiKey) throw new RouterError(401, "no TANGLE_API_KEY (pass apiKey or set the env var)");
-	const client = new TCloudClient({
-		baseURL: (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, ""),
-		apiKey,
-		model: options.model ?? DEFAULT_MODEL,
-		timeout: 0,
-		retry: {
-			maxRetries: Math.max(0, options.maxRetries ?? 4),
-			initialBackoffMs: Math.max(1, options.retryBaseMs ?? 1500),
-			retryableStatuses: [
-				429,
-				502,
-				503,
-				504
-			]
-		}
-	});
-	const acc = {
-		chatCalls: 0,
-		searchCalls: 0,
-		promptTokens: 0,
-		completionTokens: 0,
-		usd: 0,
-		wallMs: 0
-	};
-	const recordCost = (cost) => {
-		acc.usd += typeof cost === "number" && Number.isFinite(cost) && cost >= 0 ? cost : NaN;
-	};
-	const translate = (error) => {
-		options.signal?.throwIfAborted();
-		if (error instanceof TCloudError) throw new RouterError(error.status, error.message);
-		throw error;
-	};
-	return {
-		async search(query, opts) {
-			options.signal?.throwIfAborted();
-			const started = Date.now();
-			try {
-				const response = await client.search({
-					query,
-					...options.searchProvider ? { provider: options.searchProvider } : {},
-					...opts?.maxResults != null ? { maxResults: opts.maxResults } : {},
-					signal: options.signal
-				});
-				recordCost(response.usage?.billed_cost);
-				return (response.data ?? []).filter((hit) => typeof hit?.url === "string" && hit.url.length > 0).map((hit) => ({
-					title: hit.title ?? hit.url,
-					url: hit.url,
-					snippet: hit.snippet
-				}));
-			} catch (error) {
-				return translate(error);
-			} finally {
-				acc.searchCalls += 1;
-				acc.wallMs += Date.now() - started;
-			}
-		},
-		async chat(messages, maxTokens) {
-			options.signal?.throwIfAborted();
-			const started = Date.now();
-			try {
-				const response = await client.chat({
-					messages,
-					maxTokens: Math.max(MIN_MAX_TOKENS, maxTokens ?? MIN_MAX_TOKENS),
-					temperature: .2,
-					signal: options.signal
-				});
-				acc.chatCalls += 1;
-				acc.promptTokens += response.usage?.prompt_tokens ?? 0;
-				acc.completionTokens += response.usage?.completion_tokens ?? 0;
-				recordCost(response.tangle?.costSource === "receipt" ? response.tangle.costUsd : void 0);
-				return response.choices?.[0]?.message?.content ?? "";
-			} catch (error) {
-				return translate(error);
-			} finally {
-				acc.wallMs += Date.now() - started;
-			}
-		},
-		usage() {
-			return { ...acc };
-		}
-	};
-}
-/** Bind run cancellation to the default router without changing an injected client. */
-function resolveRouter(opts, signal) {
-	if (opts.router) return opts.router;
-	const requestSignal = combineRouterSignals(signal, opts.router_options?.signal);
-	return createTangleRouterClient({
-		...opts.router_options,
-		signal: requestSignal
-	});
-}
-function combineRouterSignals(runSignal, configuredSignal) {
-	return runSignal && configuredSignal ? AbortSignal.any([runSignal, configuredSignal]) : runSignal ?? configuredSignal;
-}
-function throwIfRouterAborted(runSignal, opts) {
-	runSignal?.throwIfAborted();
-	if (!opts.router) opts.router_options?.signal?.throwIfAborted();
-}
-/**
-* The real web-research worker. Conforms to the loop's `ResearchWorker`
-* contract: given the open gaps, it returns the sources it found plus a
-* `buildPages` that emits citing pages from the sources the driver accepted.
-*/
-function createWebResearchWorker(options = {}) {
-	const queriesPerGap = Math.max(1, options.queriesPerGap ?? 2);
-	const resultsPerQuery = Math.max(1, options.resultsPerQuery ?? 3);
-	const maxSourcesPerRound = Math.max(1, options.maxSourcesPerRound ?? 6);
-	const minTextChars = Math.max(1, options.minTextChars ?? 200);
-	const maxTextChars = Math.max(minTextChars, options.maxTextChars ?? 4e3);
-	return async (ctx) => {
-		const assertActive = () => throwIfRouterAborted(ctx.signal, options);
-		assertActive();
-		const router = resolveRouter(options, ctx.signal);
-		const fetchSignal = options.router ? ctx.signal : combineRouterSignals(ctx.signal, options.router_options?.signal);
-		const targetGaps = ctx.gaps.filter((gap) => gap.blocking);
-		const gaps = targetGaps.length > 0 ? targetGaps : ctx.gaps;
-		if (gaps.length === 0) return {
-			sources: [],
-			notes: "no open gaps to research"
-		};
-		const queries = await formSearchQueries(router, ctx, gaps, queriesPerGap, assertActive);
-		assertActive();
-		const proposals = [];
-		const seenUris = /* @__PURE__ */ new Set();
-		for (const query of queries) {
-			if (proposals.length >= maxSourcesPerRound) break;
-			assertActive();
-			let hits;
-			try {
-				hits = await router.search(query, { maxResults: resultsPerQuery });
-			} catch (error) {
-				assertActive();
-				if (error?.name === "AbortError") throw error;
-				continue;
-			}
-			assertActive();
-			for (const hit of hits) {
-				assertActive();
-				if (proposals.length >= maxSourcesPerRound) break;
-				if (seenUris.has(hit.url)) continue;
-				const fetched = await politeFetch(hit.url, {
-					signal: fetchSignal,
-					cacheDir: options.cacheDir
-				});
-				assertActive();
-				if (!fetched.verifiable) continue;
-				const text = htmlToText(fetched.body).slice(0, maxTextChars);
-				if (text.length < minTextChars) continue;
-				seenUris.add(hit.url);
-				proposals.push({
-					uri: hit.url,
-					title: hit.title || hit.url,
-					text,
-					lastVerifiedAt: fetched.fetchedAt,
-					metadata: {
-						discoveredVia: query,
-						snippet: hit.snippet ?? "",
-						goal: ctx.goal,
-						sourceUpdatedAt: fetched.sourceUpdatedAt
-					}
-				});
-			}
-		}
-		assertActive();
-		return {
-			sources: proposals,
-			buildPages: buildCitingPages(proposals),
-			notes: `web-research worker: ${queries.length} queries → ${proposals.length} fetched sources`
-		};
-	};
-}
-/**
-* Ask the LLM to turn the open gaps into focused web search queries. Falls back
-* to the gap's own readiness query if the model returns nothing parseable, so a
-* model hiccup degrades to a sane search rather than an empty round.
-*/
-async function formSearchQueries(router, ctx, gaps, queriesPerGap, assertActive) {
-	const gapLines = gaps.map((gap, i) => `${i + 1}. ${gap.description} (readiness query: "${gap.query}")`).join("\n");
-	const want = gaps.length * queriesPerGap;
-	const system = "You are a research librarian. Turn knowledge gaps into precise web search queries that will surface authoritative primary sources (papers, docs, standards, official pages). Return ONLY a JSON array of query strings, no prose.";
-	const user = [
-		`Research goal: ${ctx.goal}`,
-		ctx.steer ? `Steer from the coordinator:\n${ctx.steer}` : "",
-		`Open knowledge gaps:\n${gapLines}`,
-		`Return up to ${want} search query strings as a JSON array (e.g. ["query one","query two"]).`
-	].filter(Boolean).join("\n\n");
-	let raw = "";
-	try {
-		raw = await router.chat([{
-			role: "system",
-			content: system
-		}, {
-			role: "user",
-			content: user
-		}], MIN_MAX_TOKENS);
-		assertActive();
-	} catch (error) {
-		assertActive();
-		if (error?.name === "AbortError") throw error;
-		raw = "";
-	}
-	const fromLlm = parseQueryList(raw).slice(0, want);
-	if (fromLlm.length > 0) return dedupeStrings(fromLlm);
-	return dedupeStrings(gaps.map((gap) => gap.query || gap.description));
-}
-/** Parse a JSON array of query strings, tolerant of code fences / surrounding prose. */
-function parseQueryList(raw) {
-	const text = raw.trim();
-	if (!text) return [];
-	const candidates = [];
-	const arrayMatch = text.match(/\[[\s\S]*\]/);
-	if (arrayMatch) try {
-		const arr = JSON.parse(arrayMatch[0]);
-		for (const item of arr) if (typeof item === "string" && item.trim()) candidates.push(item.trim());
-	} catch {}
-	if (candidates.length === 0) for (const line of text.split("\n")) {
-		const cleaned = line.replace(/^\s*(?:[-*]|\d+[.)])\s*/, "").replace(/^["']|["']$/g, "").trim();
-		if (cleaned && cleaned.length > 2 && !cleaned.startsWith("{")) candidates.push(cleaned);
-	}
-	return candidates;
-}
-function dedupeStrings(values) {
-	const seen = /* @__PURE__ */ new Set();
-	const out = [];
-	for (const value of values) {
-		const key = value.toLowerCase().trim();
-		if (key && !seen.has(key)) {
-			seen.add(key);
-			out.push(value.trim());
-		}
-	}
-	return out;
-}
-/**
-* Build the curated `knowledge/*.md` pages from the sources the driver accepted.
-* Each page cites the registered source by its assigned `record.id` (matched back
-* to the proposal via `metadata.originalUri`, which `addSourceText` stashes).
-*/
-function buildCitingPages(proposals) {
-	return (acceptedSources) => {
-		if (acceptedSources.length === 0) return void 0;
-		return acceptedSources.map((record) => {
-			const proposal = proposals.find((p) => p.uri === record.metadata?.originalUri);
-			const uri = proposal?.uri ?? record.id;
-			const slug = uri.replace(/^https?:\/\//, "").replace(/[^a-z0-9]+/gi, "-").replace(/^-+|-+$/g, "").slice(0, 120) || record.id;
-			const title = proposal?.title ?? record.id;
-			const body = proposal?.text ?? "";
-			return [
-				`---FILE: knowledge/${slug}.md---`,
-				"---",
-				`title: ${escapeYaml(title)}`,
-				`sources: ["${record.id}"]`,
-				`source_url: ${uri}`,
-				"---",
-				`# ${title}`,
-				"",
-				body,
-				"",
-				`Source: ${uri}`,
-				"---END FILE---"
-			].join("\n");
-		}).join("\n");
-	};
-}
-function escapeYaml(value) {
-	return value.replace(/[\r\n]+/g, " ").replace(/"/g, "'").trim();
-}
-/**
-* The verifying driver: a real LLM pass that judges each candidate source's
-* on-topic relevance to the goal + open gaps and whether it duplicates material
-* already accepted this round. This is the differentiated coordinator role — it
-* GATES the worker's additions; it adds nothing itself.
-*
-* The loop already dedups exact-uri duplicates and only calls this on genuinely
-* new candidates, so the verifier focuses on relevance + near-duplicate
-* judgement, not bookkeeping.
-*/
-function createVerifyingResearchDriver(options = {}) {
-	const acceptOnParseFailure = options.acceptOnParseFailure ?? false;
-	return { async verifySource(source, ctx) {
-		const assertActive = () => throwIfRouterAborted(ctx.signal, options);
-		assertActive();
-		const router = resolveRouter(options, ctx.signal);
-		const gapLines = ctx.gaps.map((gap) => `- ${gap.description} (query: "${gap.query}")`).join("\n");
-		const acceptedTitles = ctx.acceptedThisRound.map((accepted) => `- ${accepted.title ?? accepted.uri}`).join("\n");
-		const excerpt = source.text.slice(0, 1500);
-		const system = "You verify whether a fetched web source belongs in a curated knowledge base. Accept a source ONLY if it is genuinely on-topic for the research goal and helps close one of the open gaps, AND it is not a near-duplicate of an already-accepted source. Reject spam, listicles, off-topic pages, marketing, and near-duplicates. Respond with ONLY a JSON object: {\"accept\": true|false, \"reason\": \"<short reason>\"}.";
-		const user = [
-			`Research goal: ${ctx.goal}`,
-			`Open gaps:\n${gapLines || "(none specified)"}`,
-			acceptedTitles ? `Already accepted this round:\n${acceptedTitles}` : "Nothing accepted yet this round.",
-			`Candidate source:\nURL: ${source.uri}\nTitle: ${source.title ?? "(none)"}\nExcerpt:\n${excerpt}`,
-			"Verdict as JSON {\"accept\": boolean, \"reason\": string}:"
-		].join("\n\n");
-		let raw = "";
-		try {
-			raw = await router.chat([{
-				role: "system",
-				content: system
-			}, {
-				role: "user",
-				content: user
-			}], MIN_MAX_TOKENS);
-			assertActive();
-		} catch (error) {
-			assertActive();
-			if (error?.name === "AbortError") throw error;
-			return acceptOnParseFailure ? { accept: true } : {
-				accept: false,
-				reason: `verifier unavailable: ${error.message}`
-			};
-		}
-		const verdict = parseVerdict(raw);
-		if (verdict) return verdict;
-		return acceptOnParseFailure ? { accept: true } : {
-			accept: false,
-			reason: "verifier returned an unparseable verdict"
-		};
-	} };
-}
-/** Parse the verifier's `{accept, reason}` JSON, tolerant of fences / prose. */
-function parseVerdict(raw) {
-	const text = raw.trim();
-	if (!text) return null;
-	const objMatch = text.match(/\{[\s\S]*\}/);
-	if (!objMatch) return null;
-	try {
-		const parsed = JSON.parse(objMatch[0]);
-		if (typeof parsed.accept !== "boolean") return null;
-		if (parsed.accept) return { accept: true };
-		return {
-			accept: false,
-			reason: typeof parsed.reason === "string" && parsed.reason.trim() ? parsed.reason.trim() : "rejected by verifier"
-		};
-	} catch {
-		return null;
-	}
-}
-//#endregion
-//#region src/adaptive-driver.ts
-/**
-* 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.
-*/
-/**
-* Canonicalize a URL for duplicate detection: lowercase host, strip a leading
-* `www.`, drop the scheme, the fragment, a trailing slash, and tracking query
-* params (`utm_*`, `ref`, `fbclid`, `gclid`, …). Two URLs that differ only by
-* those decorations canonicalize to the same key, so the dedup stage treats them
-* as the same source. Falls back to the lowercased raw string when the input is
-* not a parseable absolute URL (so non-http identifiers still dedup by equality).
-*/
-function canonicalizeUrl(uri) {
-	const trimmed = uri.trim();
-	try {
-		const url = new URL(trimmed);
-		const host = url.hostname.toLowerCase().replace(/^www\./, "");
-		const kept = [];
-		for (const [key, value] of url.searchParams) {
-			const lower = key.toLowerCase();
-			if (lower.startsWith("utm_")) continue;
-			if (trackingParams.has(lower)) continue;
-			kept.push([key, value]);
-		}
-		kept.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
-		const query = kept.map(([k, v]) => `${k}=${v}`).join("&");
-		return `${host}${url.pathname.replace(/\/+$/, "") || "/"}${query ? `?${query}` : ""}`;
-	} catch {
-		return trimmed.toLowerCase();
-	}
-}
-/** Tracking / referrer query params dropped during URL canonicalization. */
-const trackingParams = /* @__PURE__ */ new Set([
-	"ref",
-	"ref_src",
-	"source",
-	"fbclid",
-	"gclid",
-	"mc_cid",
-	"mc_eid",
-	"igshid",
-	"spm",
-	"_hsenc",
-	"_hsmi"
-]);
-/**
-* A stable content key for a fetched page: the sha256 of its normalized text
-* (lowercased, punctuation/whitespace collapsed). Two pages whose readable body
-* is the same modulo formatting collide here, so the dedup stage rejects a
-* mirror/syndication of an already-accepted source even when the URL differs.
-*/
-function contentKey(text) {
-	const normalized = text.toLowerCase().replace(/[^\p{L}\p{N}\s]+/gu, " ").replace(/\s+/g, " ").trim();
-	return sha256(normalized);
-}
-/** Default authoritative host suffixes — papers, official docs, standards. */
-const defaultAuthoritativeHosts = [
-	"arxiv.org",
-	"aclanthology.org",
-	"openreview.net",
-	"dl.acm.org",
-	"ieeexplore.ieee.org",
-	"nature.com",
-	"science.org",
-	"pubmed.ncbi.nlm.nih.gov",
-	"ncbi.nlm.nih.gov",
-	".edu",
-	".gov",
-	"docs.python.org",
-	"pytorch.org",
-	"tensorflow.org",
-	"huggingface.co",
-	"github.com",
-	"developer.mozilla.org",
-	"wikipedia.org",
-	"w3.org",
-	"ietf.org",
-	"rfc-editor.org"
-];
-/** Default spam/listicle/marketing title patterns. */
-const defaultSpamPatterns = [
-	/\bbuy\b.*\b(cheap|now|deal|sale|discount)\b/i,
-	/\b\d+\s+(things|ways|reasons|tips|tricks|secrets|hacks)\b.*\b(you|that|will)\b/i,
-	/\bshock(ing|ed)?\b/i,
-	/\bclickbait\b/i,
-	/!!!|\$\$\$/,
-	/\b(coupon|promo code|affiliate|sponsored)\b/i,
-	/\bbest .* (of \d{4}|in \d{4})\b/i
-];
-/**
-* Classify a UNIQUE survivor (already past dedup) with cheap host/title/length
-* signals only — no LLM. Returns `keep`, `drop`, or `ambiguous`. `ambiguous` is
-* the residue the LLM is reserved for: on-topic-looking pages on unknown hosts
-* with a plausible body, which a host/title rule cannot adjudicate.
-*/
-function triageSource(source, options) {
-	const titleAndSnippet = `${source.title ?? ""} ${typeof source.metadata?.snippet === "string" ? source.metadata.snippet : ""}`.trim();
-	const bodyLen = source.text.trim().length;
-	for (const pattern of options.spamPatterns) if (pattern.test(titleAndSnippet)) return {
-		triage: "drop",
-		reason: `spam/listicle title (${pattern.source})`
-	};
-	if (bodyLen < options.minBodyChars) return {
-		triage: "drop",
-		reason: `thin body (${bodyLen} < ${options.minBodyChars} chars)`
-	};
-	const host = hostOf(source.uri);
-	if (host.length > 0 && options.authoritativeHosts.some((suffix) => hostMatches(host, suffix)) && bodyLen >= options.substantialBodyChars) return {
-		triage: "keep",
-		reason: `authoritative host ${host} + substantial body (${bodyLen})`
-	};
-	return {
-		triage: "ambiguous",
-		reason: `unknown host ${host || "(none)"}, body ${bodyLen} chars`
-	};
-}
-function hostOf(uri) {
-	try {
-		return new URL(uri.trim()).hostname.toLowerCase().replace(/^www\./, "");
-	} catch {
-		return "";
-	}
-}
-/** Suffix host match: `.edu` matches `mit.edu`; `arxiv.org` matches `export.arxiv.org`. */
-function hostMatches(host, suffix) {
-	if (suffix.startsWith(".")) return host.endsWith(suffix) || host === suffix.slice(1);
-	return host === suffix || host.endsWith(`.${suffix}`);
-}
-/**
-* Build the adaptive verifier. The deterministic stages (dedup + heuristic
-* triage) cost $0; only AMBIGUOUS survivors escalate to the LLM relevance
-* verifier. `stats()` exposes where every decision was spent so the A/B can read
-* the LLM $/calls the adaptive driver saved against the cleanliness it kept.
-*
-* Dedup state is kept on the driver instance: it tracks the canonical URLs and
-* content hashes it has ACCEPTED, plus those it sees in the verification
-* context's `acceptedThisRound` and the KB index. Use one driver per loop run.
-*/
-function createAdaptiveResearchDriver(options = {}) {
-	const authoritativeHosts = options.authoritativeHosts ?? defaultAuthoritativeHosts;
-	const spamPatterns = options.spamPatterns ?? defaultSpamPatterns;
-	const minBodyChars = Math.max(1, options.minBodyChars ?? 400);
-	const substantialBodyChars = Math.max(minBodyChars, options.substantialBodyChars ?? 600);
-	const relevance = createVerifyingResearchDriver({
-		router: options.router,
-		router_options: options.router_options,
-		acceptOnParseFailure: options.verifying?.acceptOnParseFailure
-	});
-	const acceptedUrlKeys = /* @__PURE__ */ new Set();
-	const acceptedContentKeys = /* @__PURE__ */ new Set();
-	const stats = {
-		total: 0,
-		dedupRejected: 0,
-		heuristicKept: 0,
-		heuristicDropped: 0,
-		llmCalls: 0,
-		llmAccepted: 0,
-		decisions: []
-	};
-	function record(decision) {
-		stats.decisions.push(decision);
-		options.onDecision?.(decision);
-	}
-	return {
-		async verifySource(source, ctx) {
-			stats.total += 1;
-			const urlKey = canonicalizeUrl(source.uri);
-			const cKey = contentKey(source.text);
-			const roundUrlKeys = new Set(ctx.acceptedThisRound.map((accepted) => canonicalizeUrl(accepted.uri)));
-			const roundContentKeys = new Set(ctx.acceptedThisRound.map((accepted) => contentKey(accepted.text)));
-			const indexUrlKeys = new Set(ctx.index.sources.flatMap((indexed) => typeof indexed.metadata?.originalUri === "string" ? [canonicalizeUrl(indexed.metadata.originalUri)] : []));
-			const dupUrl = acceptedUrlKeys.has(urlKey) || roundUrlKeys.has(urlKey) || indexUrlKeys.has(urlKey);
-			const dupContent = acceptedContentKeys.has(cKey) || roundContentKeys.has(cKey);
-			if (dupUrl || dupContent) {
-				stats.dedupRejected += 1;
-				const reason = dupUrl ? "duplicate-url" : "duplicate-content";
-				record({
-					uri: source.uri,
-					stage: "dedup",
-					accepted: false,
-					reason
-				});
-				return {
-					accept: false,
-					reason: `dedup: ${reason}`
-				};
-			}
-			const { triage, reason } = triageSource(source, {
-				authoritativeHosts,
-				spamPatterns,
-				minBodyChars,
-				substantialBodyChars
-			});
-			if (triage === "keep") {
-				stats.heuristicKept += 1;
-				acceptedUrlKeys.add(urlKey);
-				acceptedContentKeys.add(cKey);
-				record({
-					uri: source.uri,
-					stage: "heuristic",
-					accepted: true,
-					triage,
-					reason
-				});
-				return { accept: true };
-			}
-			if (triage === "drop") {
-				stats.heuristicDropped += 1;
-				record({
-					uri: source.uri,
-					stage: "heuristic",
-					accepted: false,
-					triage,
-					reason
-				});
-				return {
-					accept: false,
-					reason: `heuristic drop: ${reason}`
-				};
-			}
-			stats.llmCalls += 1;
-			const verdict = await relevance.verifySource(source, ctx);
-			if (verdict.accept) {
-				stats.llmAccepted += 1;
-				acceptedUrlKeys.add(urlKey);
-				acceptedContentKeys.add(cKey);
-			}
-			record({
-				uri: source.uri,
-				stage: "llm",
-				accepted: verdict.accept,
-				triage,
-				reason: verdict.accept ? "llm accepted" : verdict.reason
-			});
-			return verdict;
-		},
-		stats() {
-			return {
-				...stats,
-				decisions: [...stats.decisions]
-			};
-		}
-	};
-}
-//#endregion
 //#region src/knowledge-state-scope.ts
 const knowledgeStateScopeSchema = z.object({
 	pagesDirectory: z.string().transform((value) => normalizePagesDirectory(value)).optional(),
@@ -906,17 +235,6 @@ const EVALUATION_PHASES = [
 	"answer-quality",
 	"promotion"
 ];
-/**
-* The pages directory every knowledge-improvement path reads and writes.
-*
-* This subsystem has no option for a caller-chosen pages directory: the
-* workspace it snapshots, the plan it hashes, and the transaction it applies
-* all address the default tree. Naming it once means the write allowlist, the
-* plan hash, and the generated-page set cannot disagree about which tree they
-* are talking about, and threading a real choice through later changes one
-* constant instead of hunting call sites.
-*/
-const KB_IMPROVEMENT_PAGES_DIRECTORY = DEFAULT_PAGES_DIRECTORY;
 //#endregion
 //#region src/kb-improvement/state.ts
 function knowledgeImprovementRunId(root, goal) {
@@ -1163,6 +481,13 @@ function immutableJsonValue(value) {
 	return Object.freeze(value);
 }
 //#endregion
+//#region src/immutable-ref.ts
+const SHA256_REF = /^sha256:[a-f0-9]{64}$/;
+const GIT_REF = /^git:[a-f0-9]{40}$/;
+function assertImmutableRef(value, label) {
+	if (typeof value !== "string" || !SHA256_REF.test(value) && !GIT_REF.test(value)) throw new Error(`${label} must be lowercase sha256:<64 hex> or git:<40 hex>`);
+}
+//#endregion
 //#region src/rag-answer-evidence.ts
 function assertRagAnswerEvidence(result) {
 	if (!result || typeof result !== "object") throw new Error("answer-quality evidence must be an object");
@@ -1190,34 +515,108 @@ function exceedsCostCeiling$1(totalCostUsd, costCeiling) {
 	return totalCostUsd - costCeiling > tolerance;
 }
 //#endregion
-//#region src/claim-grounding.ts
-/**
-* Metadata key under which a proposal carries the specific claim it is cited
-* for. The worker sets `metadata[citedClaimKey] = '<the claim>'`; the
-* claim-grounding driver reads it and checks it against the fetched page text.
-*/
-const citedClaimKey = "citedClaim";
-/** Read the cited claim a proposal carries, if any. */
-function citedClaimOf(source) {
-	const claim = source.metadata?.[citedClaimKey];
-	return typeof claim === "string" && claim.trim() ? claim.trim() : void 0;
-}
-/** Attach a cited claim to a proposal (immutably returns a new proposal). */
-function withCitedClaim(source, claim) {
-	return {
-		...source,
-		metadata: {
-			...source.metadata,
-			[citedClaimKey]: claim
+//#region src/rag-eval/knowledge-base.ts
+function scoreKnowledgeBaseIndex(index, options = {}) {
+	const validation = validateKnowledgeIndex(index, { strict: options.strict });
+	const lintFindings = lintKnowledgeIndex(index);
+	const now = options.now ?? /* @__PURE__ */ new Date();
+	const staleSourceCount = index.sources.filter((source) => {
+		return source.validUntil ? Date.parse(source.validUntil) < now.getTime() : false;
+	}).length;
+	const sourceHashCounts = /* @__PURE__ */ new Map();
+	for (const source of index.sources) sourceHashCounts.set(source.contentHash, (sourceHashCounts.get(source.contentHash) ?? 0) + 1);
+	const duplicateSourceHashCount = [...sourceHashCounts.values()].filter((count) => count > 1).length;
+	const pagesWithInlineCitations = index.pages.filter((page) => sourceRefs(page.text).length > 0).length;
+	const pagesWithSources = index.pages.filter((page) => page.sourceIds.length > 0).length;
+	const nearDuplicates = detectNearDuplicatePages(index.pages, options.nearDuplicates);
+	const maxNearDuplicatePageRate = unitInterval(options.maxNearDuplicatePageRate ?? 1, "maxNearDuplicatePageRate");
+	const metrics = {
+		page_count: index.pages.length,
+		source_count: index.sources.length,
+		citation_rate: index.pages.length === 0 ? 1 : pagesWithInlineCitations / index.pages.length,
+		source_backed_page_rate: index.pages.length === 0 ? 1 : pagesWithSources / index.pages.length,
+		stale_source_rate: index.sources.length === 0 ? 0 : staleSourceCount / index.sources.length,
+		duplicate_source_hash_rate: index.sources.length === 0 ? 0 : duplicateSourceHashCount / index.sources.length,
+		lint_error_count: validation.findings.filter((finding) => finding.severity === "error").length,
+		lint_warning_count: lintFindings.filter((finding) => finding.severity === "warning").length,
+		near_duplicate_page_rate: nearDuplicates.duplicatePageRate,
+		near_duplicate_page_count: nearDuplicates.duplicatePageCount,
+		near_duplicate_pair_count: nearDuplicates.duplicatePairCount
+	};
+	const findings = [];
+	if (metrics.lint_error_count > 0) findings.push({
+		id: "kb:lint-errors",
+		kind: "unknown",
+		severity: "critical",
+		message: `${metrics.lint_error_count} validation error(s) in the knowledge index.`,
+		evidence: { lint_error_count: metrics.lint_error_count }
+	});
+	if (metrics.citation_rate < (options.minCitationRate ?? 0)) findings.push({
+		id: "kb:citation-rate",
+		kind: "missing-source",
+		severity: "error",
+		message: "Inline citation coverage is below the configured minimum.",
+		evidence: { citation_rate: metrics.citation_rate }
+	});
+	if (metrics.stale_source_rate > (options.maxStaleSourceRate ?? 1)) findings.push({
+		id: "kb:stale-source-rate",
+		kind: "stale-source",
+		severity: "error",
+		message: "Stale source rate exceeds the configured maximum.",
+		evidence: { stale_source_rate: metrics.stale_source_rate }
+	});
+	if (nearDuplicates.truncated && maxNearDuplicatePageRate < 1) findings.push({
+		id: "kb:near-duplicate-analysis-truncated",
+		kind: "unknown",
+		severity: "error",
+		message: "Near-duplicate analysis reached a configured bound, so the duplicate-page gate cannot be evaluated completely.",
+		evidence: {
+			candidate_pair_count: nearDuplicates.candidatePairCount,
+			compared_pair_count: nearDuplicates.comparedPairCount,
+			duplicate_pair_count: nearDuplicates.duplicatePairCount
+		}
+	});
+	else if (metrics.near_duplicate_page_rate > maxNearDuplicatePageRate) findings.push({
+		id: "kb:near-duplicate-page-rate",
+		kind: "unknown",
+		severity: "error",
+		message: "Near-duplicate page rate exceeds the configured maximum.",
+		evidence: {
+			near_duplicate_page_rate: metrics.near_duplicate_page_rate,
+			near_duplicate_page_count: metrics.near_duplicate_page_count,
+			near_duplicate_pair_count: metrics.near_duplicate_pair_count,
+			threshold: nearDuplicates.threshold
 		}
+	});
+	return {
+		ok: findings.length === 0,
+		metrics,
+		nearDuplicates,
+		findings
 	};
 }
+function sourceRefs(text) {
+	const refs = [];
+	const regex = /\[\^([A-Za-z0-9_-]+)(?:#([A-Za-z0-9_.:-]+))?\]/g;
+	let match = regex.exec(text);
+	while (match !== null) {
+		refs.push(match[0]);
+		match = regex.exec(text);
+	}
+	return refs;
+}
+function unitInterval(value, name) {
+	if (!Number.isFinite(value) || value < 0 || value > 1) throw new Error(`${name} must be a finite number in [0, 1]`);
+	return value;
+}
+//#endregion
+//#region src/claim-grounding.ts
 /**
 * Stopwords stripped before overlap scoring so the bar measures the claim's
 * SUBSTANTIVE words (the numbers, nouns, methods it asserts), not filler a
 * misattributed page would trivially share with the real one.
 */
-const stopwords$2 = /* @__PURE__ */ new Set([
+const stopwords$1 = /* @__PURE__ */ new Set([
 	"the",
 	"a",
 	"an",
@@ -1274,12 +673,11 @@ function normalize(text) {
 }
 /** The claim's substantive content words (deduped, stopwords + short words removed). */
 function contentWords$1(claim, minWordLength) {
-	const words = normalize(claim).split(" ").filter((word) => word.length >= minWordLength && !stopwords$2.has(word));
+	const words = normalize(claim).split(" ").filter((word) => word.length >= minWordLength && !stopwords$1.has(word));
 	return [...new Set(words)];
 }
 /**
-* THE ORACLE. Is `claim` grounded in `pageText` (the `htmlToText` output of the
-* page the worker fetched)? Deterministic, no model call:
+* Is `claim` grounded in `pageText`? Deterministic, no model call:
 *
 *   1. verbatim — the claim string appears as-is (case-insensitive).
 *   2. normalized — the claim appears after collapsing punctuation/whitespace
@@ -1288,9 +686,8 @@ function contentWords$1(claim, minWordLength) {
 *      substantive content words appear in the page text. A misattributed page
 *      fails here because the SPECIFIC words the claim asserts are absent.
 *
-* Returns the match mode, the measured overlap, and the missing content words —
-* enough for the driver to give a precise rejection reason and for a test/doc to
-* audit WHY a claim grounded or didn't.
+* Returns the match mode, the measured overlap, and the missing content words,
+* so a caller can state why a claim grounded or did not.
 */
 function groundClaimInText(claim, pageText, options = {}) {
 	const minOverlap = options.minOverlap ?? .7;
@@ -1340,76 +737,27 @@ function groundClaimInText(claim, pageText, options = {}) {
 		missingWords
 	};
 }
+//#endregion
+//#region src/statistics.ts
 /**
-* A `ResearchDriver`-shaped verifier (just the `verifySource` arm) that gates on
-* CLAIM GROUNDING: it rejects a source whose cited claim is not present in its
-* fetched page text — a misattributed / fabricated citation — and (optionally)
-* composes a relevance verifier after grounding passes.
+* The mean of a set of measurements.
 *
-* The returned function matches `ResearchDriver['verifySource']`, so it drops
-* straight into `runVerifiedResearchLoop` as `{ verifySource: createClaimGroundingVerifier(...) }`.
+* A measurement that is not a finite number is not a measurement: it is a
+* scorer that divided by zero or an adapter that answered with nothing usable.
+* Averaging it in would spread one broken probe across the whole aggregate,
+* and carrying it through would make the aggregate itself unusable — a
+* non-finite `scoreMean` fails every numeric comparison in the ranking
+* comparator, so the candidate carrying it falls through to the identifier
+* tie-break and places by name rather than by what it scored. Such values are
+* left out, and the mean reports what was actually measured.
+*
+* An empty set answers `0`. That is a reported score, not an absence, and it
+* is the behavior every caller in this package already depends on.
 */
-function createClaimGroundingVerifier(options = {}) {
-	const onMissingClaim = options.onMissingClaim ?? "reject";
-	return async function verifySource(source, ctx) {
-		const claim = citedClaimOf(source);
-		if (!claim) {
-			if (onMissingClaim === "reject") return {
-				accept: false,
-				reason: "no cited claim: claim-grounding mode requires every source to declare its claim"
-			};
-			return options.relevanceVerifier ? options.relevanceVerifier(source, ctx) : { accept: true };
-		}
-		const grounding = groundClaimInText(claim, source.text, options);
-		if (!grounding.grounded) return {
-			accept: false,
-			reason: `misattributed citation: ${grounding.mode === "empty-text" ? "fetched page has no text" : `claim not found in the fetched page (overlap ${(grounding.overlap * 100).toFixed(0)}%${grounding.missingWords.length ? `, missing: ${grounding.missingWords.slice(0, 6).join(", ")}` : ""})`}`
-		};
-		if (options.relevanceVerifier) return options.relevanceVerifier(source, ctx);
-		return { accept: true };
-	};
-}
-/**
-* Ask an LLM to state, for one source, the single specific factual claim a
-* researcher would cite THIS page for toward the goal. Used to DECORATE the
-* sources a relevance-only worker produced with the claim a citation would make,
-* so the claim-grounding verifier has something executable to check. The model
-* is told to ground the claim in the provided excerpt; the verifier then checks
-* it against the FULL page text independently — the model does not get to mark
-* its own homework.
-*
-* Returns the proposal annotated via `withCitedClaim`, or the original proposal
-* unchanged if the model returns nothing parseable (the verifier's
-* `onMissingClaim` policy then decides).
-*/
-function createClaimDecorator(options = {}) {
-	const maxTokens = options.maxTokens ?? 1200;
-	return async function decorate(source, goal) {
-		const router = options.router ?? createTangleRouterClient(options.router_options);
-		const excerpt = source.text.slice(0, 1500);
-		const system = "You extract the single most important factual claim a researcher would cite a page for. State ONE concrete, checkable sentence using the page's own key terms and numbers. Do NOT invent facts not in the excerpt. Respond with ONLY the claim sentence, no prose.";
-		const user = [
-			`Research goal: ${goal}`,
-			`Page title: ${source.title ?? "(none)"}`,
-			`Page excerpt:\n${excerpt}`,
-			"The single claim this page should be cited for:"
-		].join("\n\n");
-		let raw = "";
-		try {
-			raw = await router.chat([{
-				role: "system",
-				content: system
-			}, {
-				role: "user",
-				content: user
-			}], maxTokens);
-		} catch {
-			return source;
-		}
-		const claim = raw.trim().split("\n")[0]?.trim();
-		if (!claim) return source;
-		return withCitedClaim(source, claim);
-	};
+function mean(values) {
+	const finite = values.filter(Number.isFinite);
+	if (finite.length === 0) return 0;
+	return finite.reduce((sum, value) => sum + value, 0) / finite.length;
 }
 //#endregion
 //#region src/rag-eval/answer.ts
@@ -1532,7 +880,7 @@ function textSupportScore(needle, haystack) {
 	return needleWords.filter((word) => haystackWords.has(word)).length / needleWords.length;
 }
 function contentWords(text) {
-	const normalized = text.toLowerCase().replace(/[^\p{L}\p{N}\s]+/gu, " ").split(/\s+/).map((word) => stem(word.trim())).filter((word) => (word.length >= 3 || /^\d+$/.test(word)) && !stopwords$1.has(word));
+	const normalized = text.toLowerCase().replace(/[^\p{L}\p{N}\s]+/gu, " ").split(/\s+/).map((word) => stem(word.trim())).filter((word) => (word.length >= 3 || /^\d+$/.test(word)) && !stopwords.has(word));
 	return [...new Set(normalized)];
 }
 function stem(word) {
@@ -1549,7 +897,7 @@ function clamp01(value) {
 	if (!Number.isFinite(value)) return 0;
 	return Math.max(0, Math.min(1, value));
 }
-const stopwords$1 = /* @__PURE__ */ new Set([
+const stopwords = /* @__PURE__ */ new Set([
 	"the",
 	"a",
 	"an",
@@ -1863,14 +1211,6 @@ function mergeMetrics(deterministic, providerScores, policy = "prefer-external")
 	}
 	return merged;
 }
-function aggregateRagAnswerMetrics(summaries) {
-	const keys = /* @__PURE__ */ new Set();
-	for (const summary of summaries) for (const key of Object.keys(summary.metrics)) keys.add(key);
-	const out = {};
-	for (const key of [...keys].sort()) out[key] = mean(summaries.map((summary) => summary.metrics[key]));
-	out.composite = mean(summaries.map((summary) => summary.composite));
-	return out;
-}
 function weightedComposite(metrics, weights) {
 	let weighted = 0;
 	let total = 0;
@@ -1888,162 +1228,169 @@ function below(metric, threshold) {
 	return threshold !== void 0 && metric < threshold;
 }
 //#endregion
-//#region src/rag-eval/calibration.ts
-function createRagAnswerQualityHook(options) {
-	assertImmutableRef(options.evaluatorRef, "RAG answer evaluatorRef");
-	const finalScenarioIds = options.scenarios.map((scenario) => scenario.id);
-	if (finalScenarioIds.length < 2 || new Set(finalScenarioIds).size !== finalScenarioIds.length || finalScenarioIds.some((id) => !id.trim())) throw new Error("RAG answer quality requires at least 2 unique final scenarios");
-	const datasetRef = `sha256:${contentHash(options.scenarios)}`;
-	return async () => {
-		const summaries = [];
-		const findings = [];
-		for (const scenario of options.scenarios) {
-			const initialArtifact = await options.run(scenario);
-			const external = await options.externalEvaluator?.({
+//#region src/optimization.ts
+/**
+* Runs one complete agent-eval method over a serialized knowledge candidate.
+* The method receives train and selection data; agent-eval owns final scoring.
+*/
+async function runSerializedKnowledgeOptimization(options) {
+	assertCompleteOptimizationMethod(options.method);
+	assertImmutableRef(options.executionRef, "knowledge optimization executionRef");
+	const codec = options.codec ?? jsonCandidateCodec();
+	const baseline = normalizeCandidate(options.baseline, codec, "baseline");
+	const dispatchRef = [
+		"knowledge-optimization",
+		options.executionRef,
+		baseline.surfaceHash,
+		surfaceHash(options.method.name)
+	].join(":");
+	assertPartitionContent(options.trainScenarios, options.selectionScenarios, options.finalScenarios, options.scenarioFingerprint ?? scenarioContentFingerprint);
+	const method = canonicalCandidateMethod(options.method, codec);
+	const { baseline: _baseline, method: _method, trainScenarios, selectionScenarios, finalScenarios, dispatchCandidate, executionRef: _executionRef, codec: _codec, scenarioFingerprint: _scenarioFingerprint, ...comparisonOptions } = options;
+	const optimizationRunOptions = {
+		...comparisonOptions.reps !== void 0 ? { reps: comparisonOptions.reps } : {},
+		...comparisonOptions.resumable !== void 0 ? { resumable: comparisonOptions.resumable } : {},
+		...comparisonOptions.labeledStore !== void 0 ? { labeledStore: comparisonOptions.labeledStore } : {},
+		...comparisonOptions.captureSource !== void 0 ? { captureSource: comparisonOptions.captureSource } : {},
+		...comparisonOptions.captureSourceVersionHash !== void 0 ? { captureSourceVersionHash: comparisonOptions.captureSourceVersionHash } : {},
+		...comparisonOptions.maxConcurrency !== void 0 ? { maxConcurrency: comparisonOptions.maxConcurrency } : {},
+		...comparisonOptions.dispatchTimeoutMs !== void 0 ? { dispatchTimeoutMs: comparisonOptions.dispatchTimeoutMs } : {},
+		...comparisonOptions.repo !== void 0 ? { repo: comparisonOptions.repo } : {},
+		...comparisonOptions.tracing !== void 0 ? { tracing: comparisonOptions.tracing } : {},
+		...comparisonOptions.expectUsage !== void 0 ? { expectUsage: comparisonOptions.expectUsage } : {},
+		...comparisonOptions.now !== void 0 ? { now: comparisonOptions.now } : {},
+		...comparisonOptions.buildTraceWriter !== void 0 ? { buildTraceWriter: comparisonOptions.buildTraceWriter } : {},
+		...comparisonOptions.storage !== void 0 ? { storage: comparisonOptions.storage } : {},
+		...comparisonOptions.cellPlacement !== void 0 ? { cellPlacement: comparisonOptions.cellPlacement } : {},
+		...comparisonOptions.optimizationRunOptions ?? {},
+		dispatchRef
+	};
+	const comparison = await compareOptimizationMethods({
+		...comparisonOptions,
+		dispatchRef,
+		optimizationRunOptions,
+		methods: [method],
+		baselineSurface: baseline.surface,
+		trainScenarios: trainScenarios.map((scenario) => structuredClone(scenario)),
+		selectionScenarios: selectionScenarios.map((scenario) => structuredClone(scenario)),
+		testScenarios: finalScenarios.map((scenario) => structuredClone(scenario)),
+		dispatchWithSurface: async (surface, scenario, context) => {
+			const candidate = normalizeSurface(surface, codec, "candidate");
+			return dispatchCandidate({
+				candidate: structuredClone(candidate.value),
+				candidateSurface: candidate.surface,
+				candidateSurfaceHash: candidate.surfaceHash,
 				scenario,
-				artifact: initialArtifact
-			});
-			const summary = scoreRagAnswerArtifact(external ? {
-				...initialArtifact,
-				externalScores: [...initialArtifact.externalScores ?? [], ...Array.isArray(external) ? external : [external]]
-			} : initialArtifact, scenario, {
-				thresholds: options.thresholds,
-				weights: options.weights
+				context
 			});
-			summaries.push(summary);
-			findings.push(...summary.findings);
 		}
-		const metrics = aggregateRagAnswerMetrics(summaries);
-		const cost = typeof options.cost === "function" ? await options.cost() : structuredClone(options.cost);
-		return {
-			passed: findings.length === 0,
-			metrics,
-			finalScenarioIds,
-			datasetRef,
-			evaluatorRef: options.evaluatorRef,
-			cost,
-			findings,
-			metadata: { scenarioCount: options.scenarios.length }
-		};
-	};
-}
-async function calibrateRagAnswerJudge(options) {
-	const judge = options.judge ?? ragAnswerQualityJudge();
-	const strong = await judge.score({
-		artifact: options.strong,
-		scenario: options.scenario,
-		signal: options.signal ?? new AbortController().signal
 	});
-	const weak = await judge.score({
-		artifact: options.weak,
-		scenario: options.scenario,
-		signal: options.signal ?? new AbortController().signal
-	});
-	const strongScore = strong.composite;
-	const weakScore = weak.composite;
-	const minStrongScore = options.minStrongScore ?? .7;
-	const maxWeakScore = options.maxWeakScore ?? .3;
+	const winner = normalizeSurface(comparison.best.winnerSurface, codec, "winner");
 	return {
-		passed: strongScore >= minStrongScore && weakScore <= maxWeakScore,
-		strongScore,
-		weakScore,
-		gap: strongScore - weakScore
+		methodName: options.method.name,
+		baseline,
+		winner,
+		comparison
 	};
 }
-//#endregion
-//#region src/rag-eval/knowledge-base.ts
-function scoreKnowledgeBaseIndex(index, options = {}) {
-	const validation = validateKnowledgeIndex(index, { strict: options.strict });
-	const lintFindings = lintKnowledgeIndex(index);
-	const now = options.now ?? /* @__PURE__ */ new Date();
-	const staleSourceCount = index.sources.filter((source) => {
-		return source.validUntil ? Date.parse(source.validUntil) < now.getTime() : false;
-	}).length;
-	const sourceHashCounts = /* @__PURE__ */ new Map();
-	for (const source of index.sources) sourceHashCounts.set(source.contentHash, (sourceHashCounts.get(source.contentHash) ?? 0) + 1);
-	const duplicateSourceHashCount = [...sourceHashCounts.values()].filter((count) => count > 1).length;
-	const pagesWithInlineCitations = index.pages.filter((page) => sourceRefs(page.text).length > 0).length;
-	const pagesWithSources = index.pages.filter((page) => page.sourceIds.length > 0).length;
-	const nearDuplicates = detectNearDuplicatePages(index.pages, options.nearDuplicates);
-	const maxNearDuplicatePageRate = unitInterval(options.maxNearDuplicatePageRate ?? 1, "maxNearDuplicatePageRate");
-	const metrics = {
-		page_count: index.pages.length,
-		source_count: index.sources.length,
-		citation_rate: index.pages.length === 0 ? 1 : pagesWithInlineCitations / index.pages.length,
-		source_backed_page_rate: index.pages.length === 0 ? 1 : pagesWithSources / index.pages.length,
-		stale_source_rate: index.sources.length === 0 ? 0 : staleSourceCount / index.sources.length,
-		duplicate_source_hash_rate: index.sources.length === 0 ? 0 : duplicateSourceHashCount / index.sources.length,
-		lint_error_count: validation.findings.filter((finding) => finding.severity === "error").length,
-		lint_warning_count: lintFindings.filter((finding) => finding.severity === "warning").length,
-		near_duplicate_page_rate: nearDuplicates.duplicatePageRate,
-		near_duplicate_page_count: nearDuplicates.duplicatePageCount,
-		near_duplicate_pair_count: nearDuplicates.duplicatePairCount
-	};
-	const findings = [];
-	if (metrics.lint_error_count > 0) findings.push({
-		id: "kb:lint-errors",
-		kind: "unknown",
-		severity: "critical",
-		message: `${metrics.lint_error_count} validation error(s) in the knowledge index.`,
-		evidence: { lint_error_count: metrics.lint_error_count }
-	});
-	if (metrics.citation_rate < (options.minCitationRate ?? 0)) findings.push({
-		id: "kb:citation-rate",
-		kind: "missing-source",
-		severity: "error",
-		message: "Inline citation coverage is below the configured minimum.",
-		evidence: { citation_rate: metrics.citation_rate }
-	});
-	if (metrics.stale_source_rate > (options.maxStaleSourceRate ?? 1)) findings.push({
-		id: "kb:stale-source-rate",
-		kind: "stale-source",
-		severity: "error",
-		message: "Stale source rate exceeds the configured maximum.",
-		evidence: { stale_source_rate: metrics.stale_source_rate }
-	});
-	if (nearDuplicates.truncated && maxNearDuplicatePageRate < 1) findings.push({
-		id: "kb:near-duplicate-analysis-truncated",
-		kind: "unknown",
-		severity: "error",
-		message: "Near-duplicate analysis reached a configured bound, so the duplicate-page gate cannot be evaluated completely.",
-		evidence: {
-			candidate_pair_count: nearDuplicates.candidatePairCount,
-			compared_pair_count: nearDuplicates.comparedPairCount,
-			duplicate_pair_count: nearDuplicates.duplicatePairCount
+function assertCompleteOptimizationMethod(method) {
+	const candidate = method;
+	if (!candidate || typeof candidate.name !== "string" || candidate.name.trim().length === 0 || typeof candidate.optimize !== "function") throw new Error("knowledge optimization requires a complete OptimizationMethod with a non-empty name and optimize()");
+}
+function jsonCandidateCodec() {
+	return {
+		serialize: (candidate) => canonicalJson(candidate),
+		parse(surface) {
+			let parsed;
+			try {
+				parsed = JSON.parse(surface);
+			} catch (error) {
+				throw new Error("serialized knowledge candidate is not valid JSON", { cause: error });
+			}
+			return parsed;
 		}
-	});
-	else if (metrics.near_duplicate_page_rate > maxNearDuplicatePageRate) findings.push({
-		id: "kb:near-duplicate-page-rate",
-		kind: "unknown",
-		severity: "error",
-		message: "Near-duplicate page rate exceeds the configured maximum.",
-		evidence: {
-			near_duplicate_page_rate: metrics.near_duplicate_page_rate,
-			near_duplicate_page_count: metrics.near_duplicate_page_count,
-			near_duplicate_pair_count: metrics.near_duplicate_pair_count,
-			threshold: nearDuplicates.threshold
+	};
+}
+function jsonObjectCandidateCodec() {
+	const codec = jsonCandidateCodec();
+	return {
+		serialize: codec.serialize,
+		parse(surface) {
+			const candidate = codec.parse(surface);
+			if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) throw new Error("serialized knowledge candidate must be a JSON object");
+			return candidate;
 		}
-	});
+	};
+}
+function scenarioContentFingerprint(scenario) {
+	const { id: _id, tags: _tags, split: _split, splitTag: _splitTag, ...content } = scenario;
+	return surfaceHash(canonicalJson(content));
+}
+function canonicalCandidateMethod(method, codec) {
 	return {
-		ok: findings.length === 0,
-		metrics,
-		nearDuplicates,
-		findings
+		name: method.name,
+		async optimize(input) {
+			const result = await method.optimize(input);
+			const winner = normalizeSurface(result.winnerSurface, codec, `${method.name} winner`);
+			return {
+				...result,
+				winnerSurface: winner.surface
+			};
+		}
 	};
 }
-function sourceRefs(text) {
-	const refs = [];
-	const regex = /\[\^([A-Za-z0-9_-]+)(?:#([A-Za-z0-9_.:-]+))?\]/g;
-	let match = regex.exec(text);
-	while (match !== null) {
-		refs.push(match[0]);
-		match = regex.exec(text);
+function normalizeCandidate(candidate, codec, label) {
+	let surface;
+	try {
+		surface = codec.serialize(candidate);
+	} catch (error) {
+		throw new Error(`${label} serializer failed`, { cause: error });
 	}
-	return refs;
+	return normalizeSurface(surface, codec, label);
 }
-function unitInterval(value, name) {
-	if (!Number.isFinite(value) || value < 0 || value > 1) throw new Error(`${name} must be a finite number in [0, 1]`);
-	return value;
+function normalizeSurface(surface, codec, label) {
+	if (typeof surface !== "string" || surface.trim().length === 0) throw new Error(`${label} must be a non-empty serialized string`);
+	let value;
+	try {
+		value = codec.parse(surface);
+	} catch (error) {
+		const detail = error instanceof Error ? `: ${error.message}` : "";
+		throw new Error(`${label} parser failed${detail}`, { cause: error });
+	}
+	let canonicalSurface;
+	try {
+		canonicalSurface = codec.serialize(value);
+	} catch (error) {
+		throw new Error(`${label} serializer failed after parsing`, { cause: error });
+	}
+	if (typeof canonicalSurface !== "string" || canonicalSurface.trim().length === 0) throw new Error(`${label} serializer must return a non-empty string`);
+	if (codec.serialize(codec.parse(canonicalSurface)) !== canonicalSurface) throw new Error(`${label} codec must round-trip to one canonical surface`);
+	return {
+		value: structuredClone(value),
+		surface: canonicalSurface,
+		surfaceHash: surfaceHash(canonicalSurface)
+	};
+}
+function assertPartitionContent(train, selection, final, fingerprint) {
+	if (!fingerprint) return;
+	const owner = /* @__PURE__ */ new Map();
+	for (const [name, scenarios] of [
+		["train", train],
+		["selection", selection],
+		["final", final]
+	]) for (const scenario of scenarios) {
+		const identity = fingerprint(scenario);
+		if (typeof identity !== "string" || identity.trim().length === 0) throw new Error(`scenarioFingerprint returned no identity for '${scenario.id}'`);
+		const prior = owner.get(identity);
+		if (prior) {
+			const scope = prior.partition === name ? `${name} partition duplicates` : `${prior.partition}/${name} partitions duplicate`;
+			throw new Error(`serialized knowledge optimization ${scope} scenario content at '${prior.scenarioId}'/'${scenario.id}'`);
+		}
+		owner.set(identity, {
+			partition: name,
+			scenarioId: scenario.id
+		});
+	}
 }
 //#endregion
 //#region src/rag-optimization.ts
@@ -2411,6 +1758,231 @@ async function applyKnowledgeResearchDecision(options, decision, iteration = 1)
 	};
 }
 //#endregion
+//#region src/retrieval-eval.ts
+function retrievalConfigSurface(config) {
+	return canonicalJson(config);
+}
+function retrievalConfigFromSurface(surface) {
+	if (typeof surface !== "string") throw new Error(`retrievalConfigFromSurface expected a JSON string surface, got ${typeof surface}`);
+	let parsed;
+	try {
+		parsed = JSON.parse(surface);
+	} catch (error) {
+		throw new Error(`retrievalConfigFromSurface could not parse JSON: ${error.message}`);
+	}
+	if (!isJsonObject(parsed)) throw new Error("retrievalConfigFromSurface expected a JSON object");
+	return parsed;
+}
+function buildRetrievalEvalDispatch(options) {
+	if (!options.retrieve && !options.index) throw new Error("buildRetrievalEvalDispatch requires either index or retrieve");
+	const defaultK = options.defaultK ?? 5;
+	const retrieve = options.retrieve ?? defaultSearchRetriever;
+	return async (surface, scenario, context) => {
+		const config = retrievalConfigFromSurface(surface);
+		const k = retrievalK(config, scenario, defaultK);
+		const startedAt = Date.now();
+		const normalized = normalizeRetrieverResult(await retrieve({
+			index: options.index,
+			config,
+			scenario,
+			k,
+			signal: context.signal,
+			context
+		}));
+		return {
+			config,
+			query: scenario.query,
+			requestedK: k,
+			hits: normalized.hits,
+			durationMs: Date.now() - startedAt,
+			costUsd: normalized.costUsd,
+			metadata: normalized.metadata
+		};
+	};
+}
+function retrievalRecallJudge(options = {}) {
+	const weights = normalizeWeights(options.weights ?? { recall: 1 });
+	return {
+		name: options.name ?? "retrieval-recall",
+		dimensions: [
+			{
+				key: "recall",
+				description: "fraction of expected knowledge targets retrieved"
+			},
+			{
+				key: "mrr",
+				description: "reciprocal rank of the first matching hit"
+			},
+			{
+				key: "ndcg",
+				description: "rank-aware gain for newly matched targets"
+			},
+			{
+				key: "precision_at_k",
+				description: "share of returned hits that match at least one target"
+			}
+		],
+		appliesTo: (scenario) => scenario.kind === "retrieval-eval",
+		async score({ artifact, scenario }) {
+			const metrics = scoreRetrievalArtifact(artifact, scenario);
+			const composite = (metrics.recall * weights.recall + metrics.mrr * weights.mrr + metrics.ndcg * weights.ndcg + metrics.precisionAtK * weights.precisionAtK) / (weights.recall + weights.mrr + weights.ndcg + weights.precisionAtK);
+			return {
+				dimensions: {
+					recall: metrics.recall,
+					mrr: metrics.mrr,
+					ndcg: metrics.ndcg,
+					precision_at_k: metrics.precisionAtK
+				},
+				composite,
+				notes: `matched ${metrics.matchedCount}/${metrics.expectedCount}; first_hit_rank=${metrics.firstHitRank ?? "none"}`
+			};
+		}
+	};
+}
+function scoreRetrievalArtifact(artifact, scenario) {
+	const targets = normalizeTargets(scenario.expected);
+	if (targets.length === 0) throw new Error(`retrieval eval scenario ${scenario.id} has no expected targets`);
+	const matchedTargetIds = /* @__PURE__ */ new Set();
+	let firstHitRank = null;
+	let relevantHitCount = 0;
+	let dcg = 0;
+	for (const hit of artifact.hits) {
+		const newlyMatched = targets.filter((target) => {
+			const targetId = retrievalTargetId(target);
+			return !matchedTargetIds.has(targetId) && hitMatchesTarget(hit, target);
+		});
+		if (newlyMatched.length === 0) continue;
+		relevantHitCount += 1;
+		if (firstHitRank === null) firstHitRank = hit.rank;
+		dcg += 1 / Math.log2(hit.rank + 1);
+		for (const target of newlyMatched) matchedTargetIds.add(retrievalTargetId(target));
+	}
+	const expectedCount = targets.length;
+	const matchedCount = matchedTargetIds.size;
+	const idcg = idealDcg(Math.min(expectedCount, Math.max(1, artifact.requestedK)));
+	return {
+		recall: matchedCount / expectedCount,
+		mrr: firstHitRank === null ? 0 : 1 / firstHitRank,
+		ndcg: idcg === 0 ? 0 : dcg / idcg,
+		precisionAtK: artifact.hits.length === 0 ? 0 : relevantHitCount / artifact.hits.length,
+		expectedCount,
+		matchedCount,
+		relevantHitCount,
+		firstHitRank,
+		matchedTargetIds: [...matchedTargetIds].sort()
+	};
+}
+function partitionRetrievalScenarios(scenarios, options = {}) {
+	if (scenarios.length < 4) throw new Error("partitionRetrievalScenarios requires at least 4 scenarios for non-empty train and selection partitions plus 2 final scenarios");
+	const selectionFraction = options.selectionFraction ?? .2;
+	const finalFraction = options.finalFraction ?? .2;
+	assertPartitionFraction(selectionFraction, "selectionFraction");
+	assertPartitionFraction(finalFraction, "finalFraction");
+	if (selectionFraction + finalFraction >= 1) throw new Error("selectionFraction + finalFraction must be less than 1");
+	const shuffled = seededShuffle(scenarios, options.seed ?? 42);
+	const finalCount = Math.max(2, Math.round(shuffled.length * finalFraction));
+	const selectionCount = Math.max(1, Math.round(shuffled.length * selectionFraction));
+	if (finalCount + selectionCount >= shuffled.length) throw new Error("retrieval scenario fractions leave no training scenarios");
+	const trainEnd = shuffled.length - selectionCount - finalCount;
+	return {
+		trainScenarios: shuffled.slice(0, trainEnd),
+		selectionScenarios: shuffled.slice(trainEnd, trainEnd + selectionCount),
+		finalScenarios: shuffled.slice(trainEnd + selectionCount)
+	};
+}
+function assertPartitionFraction(value, name) {
+	if (!Number.isFinite(value) || value <= 0 || value >= 1) throw new Error(`${name} must be greater than 0 and less than 1`);
+}
+function retrievalK(config, scenario, defaultK) {
+	const rawK = config.k ?? config.topK ?? scenario.k ?? defaultK;
+	if (typeof rawK !== "number" || !Number.isFinite(rawK) || rawK <= 0) throw new Error(`retrieval k must be a positive number, got ${String(rawK)}`);
+	return Math.floor(rawK);
+}
+async function defaultSearchRetriever(input) {
+	if (!input.index) throw new Error("default retrieval eval search requires an index");
+	return { hits: searchKnowledge(input.index, input.scenario.query, input.k).map(hitFromSearchResult$1) };
+}
+function hitFromSearchResult$1(result) {
+	return {
+		pageId: result.page.id,
+		path: result.page.path,
+		title: result.page.title,
+		rank: result.rank,
+		score: result.score,
+		normalizedScore: result.normalizedScore,
+		sourceIds: result.page.sourceIds,
+		snippet: result.snippet
+	};
+}
+function normalizeRetrieverResult(result) {
+	if (isHitArray(result)) return { hits: result };
+	return result;
+}
+function normalizeTargets(expected) {
+	return isTargetArray(expected) ? [...expected] : [expected];
+}
+function isHitArray(result) {
+	return Array.isArray(result);
+}
+function isTargetArray(expected) {
+	return Array.isArray(expected);
+}
+function hitMatchesTarget(hit, target) {
+	switch (target.kind) {
+		case "page": return hit.pageId === target.pageId;
+		case "page-path": return hit.path === target.path;
+		case "source": return Boolean(hit.sourceIds?.includes(target.sourceId));
+		case "source-anchor": return Boolean(hit.sourceSpans?.some((span) => span.sourceId === target.sourceId && span.anchorId === target.anchorId));
+		case "source-span": return Boolean(hit.sourceSpans?.some((span) => span.sourceId === target.sourceId && spanOverlaps(span, target)));
+	}
+}
+function spanOverlaps(hit, target) {
+	if (typeof hit.charStart !== "number" || typeof hit.charEnd !== "number") return false;
+	return hit.charStart < target.charEnd && target.charStart < hit.charEnd;
+}
+function retrievalTargetId(target) {
+	switch (target.kind) {
+		case "page": return `page:${target.pageId}`;
+		case "page-path": return `page-path:${target.path}`;
+		case "source": return `source:${target.sourceId}`;
+		case "source-anchor": return `source-anchor:${target.sourceId}:${target.anchorId}`;
+		case "source-span": return `source-span:${target.sourceId}:${target.charStart}:${target.charEnd}`;
+	}
+}
+function idealDcg(count) {
+	let score = 0;
+	for (let i = 1; i <= count; i += 1) score += 1 / Math.log2(i + 1);
+	return score;
+}
+function normalizeWeights(weights) {
+	const normalized = {
+		recall: normalizeWeight(weights.recall),
+		mrr: normalizeWeight(weights.mrr),
+		ndcg: normalizeWeight(weights.ndcg),
+		precisionAtK: normalizeWeight(weights.precisionAtK)
+	};
+	if (normalized.recall + normalized.mrr + normalized.ndcg + normalized.precisionAtK <= 0) throw new Error("retrievalRecallJudge requires at least one positive metric weight");
+	return normalized;
+}
+function normalizeWeight(value) {
+	if (value === void 0) return 0;
+	if (!Number.isFinite(value) || value < 0) throw new Error(`retrievalRecallJudge metric weights must be non-negative finite numbers, got ${String(value)}`);
+	return value;
+}
+function isJsonObject(value) {
+	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function seededShuffle(items, seed) {
+	const out = [...items];
+	let state = seed >>> 0;
+	for (let i = out.length - 1; i > 0; i -= 1) {
+		state = state * 1664525 + 1013904223 >>> 0;
+		const j = state % (i + 1);
+		[out[i], out[j]] = [out[j], out[i]];
+	}
+	return out;
+}
+//#endregion
 //#region src/retrieval-optimization.ts
 async function runRetrievalImprovementLoop(options) {
 	const dispatch = buildRetrievalEvalDispatch({
@@ -3814,446 +3386,35 @@ async function improveKnowledgeBaseInRun(options, runId, runDir, now) {
 	}
 }
 //#endregion
-//#region src/kb-improvement/optimization.ts
-/**
-* Optimizes a serialized KB-maintenance policy, then materializes the selected
-* policy in one isolated knowledge candidate. Activation remains explicit.
-*/
-async function optimizeKnowledgeBasePolicy(options) {
-	const { root, goal, baselinePolicy, method, trainScenarios, selectionScenarios, finalScenarios, policyApplicationRef, candidateRunLabel, candidate, applyPolicy, ...optimizationOptions } = options;
-	if (typeof root !== "string" || !root.trim()) throw new Error("optimizeKnowledgeBasePolicy root must be non-empty");
-	if (typeof goal !== "string" || !goal.trim()) throw new Error("optimizeKnowledgeBasePolicy goal must be non-empty");
-	assertImmutableRef(policyApplicationRef, "optimizeKnowledgeBasePolicy policyApplicationRef");
-	if (candidateRunLabel !== void 0 && (typeof candidateRunLabel !== "string" || !candidateRunLabel.trim())) throw new Error("optimizeKnowledgeBasePolicy candidateRunLabel must be non-empty");
-	const baseHash = await hashKnowledgeBase(root, candidate?.stateScope);
-	const optimization = await runSerializedKnowledgeOptimization({
-		...optimizationOptions,
-		executionRef: policyApplicationRef,
-		baseline: baselinePolicy,
-		method,
-		trainScenarios,
-		selectionScenarios,
-		finalScenarios
-	});
-	const winner = optimization.winner;
-	const currentBaseHash = await hashKnowledgeBase(root, candidate?.stateScope);
-	if (currentBaseHash !== baseHash) throw new Error(`knowledge base changed during policy optimization: expected ${baseHash}, got ${currentBaseHash}`);
-	const runId = stableId("kbpolicy", `${candidateRunLabel ?? "default"}:${goal}:${optimization.methodName}:${winner.surfaceHash}:${policyApplicationRef}:${baseHash}`);
+//#region src/agent-candidate.ts
+/** Convert a measured knowledge candidate into the shared review and execution identity. */
+function toAgentCandidateKnowledgeRef(candidate) {
+	const parsed = KnowledgeImprovementCandidateRefSchema.parse(candidate);
 	return {
-		optimization,
-		improvement: await improveKnowledgeBase({
-			...candidate ?? {},
-			root,
-			goal,
-			implementationRef: `sha256:${sha256(`${policyApplicationRef}\n${winner.surfaceHash}\n${optimization.methodName}`)}`,
-			runId,
-			maxCandidates: 1,
-			updateKnowledge: async (input) => {
-				if (input.baseHash !== baseHash) throw new Error(`knowledge base changed before policy materialization: expected ${baseHash}, got ${input.baseHash}`);
-				const result = await applyPolicy({
-					...input,
-					policy: structuredClone(winner.value),
-					policySurface: winner.surface,
-					policySurfaceHash: winner.surfaceHash,
-					optimizationMethod: optimization.methodName
-				});
-				return {
-					...result,
-					metadata: {
-						...result.metadata ?? {},
-						optimization: {
-							method: optimization.methodName,
-							policySurfaceHash: winner.surfaceHash,
-							policyApplicationRef
-						}
-					}
-				};
-			}
-		})
+		...parsed,
+		goalHash: prefixedDigest(parsed.goalHash),
+		baseHash: prefixedDigest(parsed.baseHash),
+		candidateHash: prefixedDigest(parsed.candidateHash),
+		evidenceHash: prefixedDigest(parsed.evidenceHash),
+		promotionPlanHash: prefixedDigest(parsed.promotionPlanHash)
 	};
-}
-//#endregion
-//#region src/kb-improvement/selected-candidate.ts
-const selectionPathSchema = z.string().min(1).transform((path, context) => {
-	try {
-		try {
-			return assertKnowledgeMutationPath(path, KB_IMPROVEMENT_PAGES_DIRECTORY, true);
-		} catch {
-			return normalizePagesDirectory(path);
-		}
-	} catch (error) {
-		context.addIssue({
-			code: "custom",
-			message: error instanceof Error ? error.message : String(error)
-		});
-		return z.NEVER;
-	}
-});
-const selectionMetadataSchema = z.record(z.string(), z.json());
-const measuredSelectionLifecycleSchema = z.object({
-	kind: z.literal("measured-knowledge-change-selection"),
-	version: z.literal(1),
-	selectionDigest: z.string().regex(/^[a-f0-9]{64}$/),
-	sourceCandidateId: z.string().min(1),
-	sourceEvidenceHash: z.string().regex(/^[a-f0-9]{64}$/),
-	sourcePlanHash: z.string().regex(/^[a-f0-9]{64}$/),
-	selectedPaths: z.array(selectionPathSchema),
-	selectedCandidateHash: z.string().regex(/^[a-f0-9]{64}$/),
-	selectedPlanHash: z.string().regex(/^[a-f0-9]{64}$/)
-}).strict();
-const measuredSelectionReceiptSchema = z.object({
-	kind: z.literal("measured-knowledge-change-selection-receipt"),
-	version: z.literal(1),
-	receiptHash: z.string().regex(/^[a-f0-9]{64}$/),
-	selectionDigest: z.string().regex(/^[a-f0-9]{64}$/),
-	sourceCandidate: KnowledgeImprovementCandidateRefSchema,
-	sourcePlanHash: z.string().regex(/^[a-f0-9]{64}$/),
-	selectedPaths: z.array(selectionPathSchema),
-	derivedImplementationRef: immutableRefSchema,
-	runId: z.string().min(1),
-	derivedCandidateId: z.string().min(1),
-	derivedCandidateStatus: z.string().min(1),
-	selectedCandidateHash: z.string().regex(/^[a-f0-9]{64}$/),
-	selectedPlanHash: z.string().regex(/^[a-f0-9]{64}$/),
-	selectedEvidenceHash: z.string().regex(/^[a-f0-9]{64}$/),
-	rationale: z.string().trim().min(1).optional(),
-	metadata: selectionMetadataSchema.optional()
-}).strict();
-/**
-* Derive a subset from an already measured candidate, then measure the subset as
-* a new candidate before it can be promoted.
-*
-* Directly filtering an activation plan is unsafe: a whole candidate can pass
-* while one page subset breaks links, removes supporting sources, or changes a
-* readiness score. This helper instead applies the chosen changed paths to an
-* isolated baseline, recomputes the index, runs the ordinary improvement
-* evaluator, and returns the ordinary candidate reference. Promotion therefore
-* remains one path and can never admit an unmeasured hybrid.
-*/
-async function improveSelectedKnowledgeCandidate(options) {
-	const sourceCandidate = Object.freeze(KnowledgeImprovementCandidateRefSchema.parse(options.sourceCandidate));
-	const requestedImplementationRef = immutableRefSchema.parse(options.implementationRef);
-	const enabledEvaluationPhases = normalizeEvaluationPhases(options.enabledEvaluationPhases ?? ["gap-diagnosis", ...EVALUATION_PHASES], "enabledEvaluationPhases");
-	const requiredEvaluationPhases = normalizeEvaluationPhases(options.requiredEvaluationPhases ?? [], "requiredEvaluationPhases");
-	const metadata = options.selectionMetadata ? selectionMetadataSchema.parse(structuredClone(options.selectionMetadata)) : void 0;
-	return withKnowledgeImprovementComparison({
-		root: options.root,
-		candidate: sourceCandidate
-	}, async (source) => {
-		const scope = normalizeKnowledgeStateScope(source.stateScope);
-		if (options.stateScope !== void 0 && canonicalJson(normalizeKnowledgeStateScope(options.stateScope)) !== canonicalJson(scope)) throw new Error("selected knowledge candidate stateScope differs from its source");
-		const sourcePlan = await knowledgeFilePlanEntries(source.baseline.root, source.candidate.root, scope);
-		const sourcePlanHash = knowledgeFileTransactionPlanHash(sourcePlan, scope.pagesDirectory, scope.researchState);
-		if (sourcePlanHash !== sourceCandidate.promotionPlanHash) throw new Error("source knowledge candidate plan no longer matches its measured identity");
-		const changedSourcePlan = sourcePlan.filter(planEntryChanged).filter((entry) => notDerivedPath(entry, scope));
-		const selectedPaths = normalizeSelectedPaths(options.selectedPaths, changedSourcePlan, scope);
-		const selectionMaterial = immutableJson({
-			kind: "measured-knowledge-change-selection",
-			version: 1,
-			sourceCandidate,
-			sourcePlanHash,
-			selectedPaths,
-			...options.rationale?.trim() ? { rationale: options.rationale.trim() } : {},
-			...metadata ? { metadata } : {}
-		});
-		const selectionDigest = contentHash(selectionMaterial);
-		const derivedImplementationRef = immutableRefSchema.parse(`sha256:${contentHash({
-			engine: "agent-knowledge/measured-selection-v1",
-			implementationRef: requestedImplementationRef,
-			selectionDigest
-		})}`);
-		const runId = options.runId ?? stableId("kimpsel", canonicalJson({
-			root: options.root,
-			goal: options.goal,
-			derivedImplementationRef,
-			selectionDigest
-		}));
-		const selectedEntries = selectedPaths.map((path) => {
-			const entry = changedSourcePlan.find((candidate) => candidate.path === path);
-			if (!entry) throw new Error(`selected knowledge path disappeared: ${path}`);
-			return entry;
-		});
-		const selectionMutationPlanHash = knowledgeFileTransactionPlanHash(selectedEntries, scope.pagesDirectory, scope.researchState);
-		let lifecycleSelection;
-		const result = await improveKnowledgeBase({
-			...improvementOptions(options),
-			root: options.root,
-			stateScope: scope,
-			goal: options.goal,
-			implementationRef: derivedImplementationRef,
-			runId,
-			enabledPhases: ["knowledge-update", ...enabledEvaluationPhases],
-			requiredPhases: ["knowledge-update", ...requiredEvaluationPhases],
-			async updateKnowledge(input) {
-				const purpose = `knowledge-selected-candidate:${selectionDigest}`;
-				const recoveryOwner = `knowledge-selected-candidate:${sourceCandidate.candidateId}`;
-				await withKnowledgeMutation(input.candidateRoot, async (lock) => {
-					lock.assertOwned();
-					if (!lock.recovery && selectedEntries.length > 0) {
-						const transaction = await prepareKnowledgeFileTransaction({
-							root: input.candidateRoot,
-							transactionRoot: lock.transactionRoot,
-							purpose,
-							...scope,
-							recoveryOwner,
-							mutations: await selectionMutations(source.candidate.root, selectedEntries),
-							now: options.now
-						});
-						if (transaction) {
-							assertSelectionTransaction(transaction, selectionMutationPlanHash);
-							await applyKnowledgeFileTransaction({
-								root: input.candidateRoot,
-								transactionRoot: lock.transactionRoot,
-								transaction,
-								beforeCommit: lock.assertOwned
-							});
-							await finishKnowledgeFileTransaction({
-								root: input.candidateRoot,
-								transactionRoot: lock.transactionRoot,
-								transaction,
-								assertOwned: lock.assertOwned
-							});
-						}
-					}
-					await writeKnowledgeIndex(input.candidateRoot, scope);
-					lock.assertOwned();
-				}, { resumeTransaction: {
-					purpose,
-					recoveryOwner,
-					validate: (transaction) => assertSelectionTransaction(transaction, selectionMutationPlanHash)
-				} });
-				const selectedPlan = await knowledgeFilePlanEntries(source.baseline.root, input.candidateRoot, scope);
-				assertExactSelectedChanges(selectedPlan, selectedPaths, scope);
-				const selectedPlanHash = knowledgeFileTransactionPlanHash(selectedPlan, scope.pagesDirectory, scope.researchState);
-				const selectedCandidateHash = await hashKnowledgeBase(input.candidateRoot, scope);
-				lifecycleSelection = measuredSelectionLifecycleSchema.parse({
-					kind: "measured-knowledge-change-selection",
-					version: 1,
-					selectionDigest,
-					sourceCandidateId: sourceCandidate.candidateId,
-					sourceEvidenceHash: sourceCandidate.evidenceHash,
-					sourcePlanHash,
-					selectedPaths,
-					selectedCandidateHash,
-					selectedPlanHash
-				});
-				return {
-					applied: selectedPaths.length > 0,
-					summary: selectedPaths.length > 0 ? `Applied ${selectedPaths.length} selected measured change(s).` : "Selected no changes; measuring the exact baseline as a null candidate.",
-					metadata: { selection: lifecycleSelection }
-				};
-			}
-		});
-		const candidate = result.candidate;
-		if (!candidate?.candidateHash || !candidate.promotionPlanHash || !candidate.evidenceHash) throw new Error("selected knowledge candidate did not produce measured candidate evidence");
-		const recordedSelection = measuredSelectionLifecycleSchema.parse(result.lifecycle?.knowledgeUpdate?.metadata?.selection ?? lifecycleSelection);
-		if (recordedSelection.selectionDigest !== selectionDigest || recordedSelection.selectedCandidateHash !== candidate.candidateHash || recordedSelection.selectedPlanHash !== candidate.promotionPlanHash || canonicalJson(recordedSelection.selectedPaths) !== canonicalJson(selectedPaths)) throw new Error("selected knowledge candidate evidence does not bind the measured subset");
-		const receiptWithoutHash = immutableJson({
-			kind: "measured-knowledge-change-selection-receipt",
-			version: 1,
-			selectionDigest,
-			sourceCandidate,
-			sourcePlanHash,
-			selectedPaths,
-			derivedImplementationRef,
-			runId: result.runId,
-			derivedCandidateId: candidate.candidateId,
-			derivedCandidateStatus: candidate.status,
-			selectedCandidateHash: candidate.candidateHash,
-			selectedPlanHash: candidate.promotionPlanHash,
-			selectedEvidenceHash: candidate.evidenceHash,
-			...options.rationale?.trim() ? { rationale: options.rationale.trim() } : {},
-			...metadata ? { metadata } : {}
-		});
-		const receipt = measuredSelectionReceiptSchema.parse({
-			...receiptWithoutHash,
-			receiptHash: contentHash(receiptWithoutHash)
-		});
-		await persistSelectionReceipt(options.root, receipt);
-		return {
-			...result,
-			selection: receipt
-		};
-	});
-}
-function improvementOptions(options) {
-	const { root: _root, goal: _goal, implementationRef: _implementationRef, sourceCandidate: _sourceCandidate, selectedPaths: _selectedPaths, runId: _runId, rationale: _rationale, selectionMetadata: _selectionMetadata, enabledEvaluationPhases: _enabledEvaluationPhases, requiredEvaluationPhases: _requiredEvaluationPhases, ...rest } = options;
-	return rest;
-}
-function normalizeEvaluationPhases(phases, field) {
-	const unique = [...new Set(phases)];
-	for (const phase of unique) if (phase === "knowledge-acquisition" || phase === "knowledge-update") throw new Error(`${field} cannot contain the selection-owned phase '${phase}'`);
-	return unique;
-}
-function normalizeSelectedPaths(paths, changedPlan, scope) {
-	const available = new Set(changedPlan.map((entry) => entry.path));
-	const selected = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const input of paths) {
-		const path = assertKnowledgeMutationPath(selectionPathSchema.parse(input), normalizeKnowledgeStateScope(scope).pagesDirectory, scope.researchState);
-		if (!notDerivedPath({ path }, scope)) throw new Error(`derived knowledge path cannot be selected directly: ${path}`);
-		if (seen.has(path)) throw new Error(`selected knowledge path is repeated: ${path}`);
-		if (!available.has(path)) throw new Error(`selected knowledge path is not a changed source-candidate file: ${path}`);
-		seen.add(path);
-		selected.push(path);
-	}
-	return selected.sort((left, right) => left.localeCompare(right));
-}
-function planEntryChanged(entry) {
-	return entry.beforeHash !== entry.afterHash || entry.beforeHash !== null && entry.afterHash !== null && entry.beforeMode !== entry.afterMode;
-}
-function notDerivedPath(entry, scope) {
-	return entry.path !== `${normalizeKnowledgeStateScope(scope).pagesDirectory}/index.md`;
-}
-async function selectionMutations(sourceCandidateRoot, entries) {
-	return Promise.all(entries.map(async (entry) => {
-		if (entry.afterHash === null) return {
-			path: entry.path,
-			content: null
-		};
-		const file = await readRegularFileWithinRoot(sourceCandidateRoot, entry.path);
-		if (createHash("sha256").update(file.bytes).digest("hex") !== entry.afterHash || file.mode !== entry.afterMode) throw new Error(`source candidate changed before subset materialization: ${entry.path}`);
-		return {
-			path: entry.path,
-			content: file.bytes,
-			mode: file.mode
-		};
-	}));
-}
-function assertSelectionTransaction(transaction, expectedPlanHash) {
-	if (knowledgeFileTransactionPlanHash(transaction.entries, normalizePagesDirectory(transaction.pagesDirectory), transaction.researchState) !== expectedPlanHash) throw new Error("selected knowledge transaction does not match its approved path set");
-}
-function assertExactSelectedChanges(plan, selectedPaths, scope) {
-	const actual = plan.filter(planEntryChanged).filter((entry) => notDerivedPath(entry, scope)).map((entry) => entry.path).sort((left, right) => left.localeCompare(right));
-	if (canonicalJson(actual) !== canonicalJson(selectedPaths)) throw new Error(`selected knowledge candidate changed the wrong files: expected ${selectedPaths.join(", ") || "(none)"}, got ${actual.join(", ") || "(none)"}`);
-}
-async function persistSelectionReceipt(root, receipt) {
-	const runDir = knowledgeImprovementRunDir(root, receipt.runId);
-	const relativePath = join("candidates", safePathSegmentSchema.parse(receipt.derivedCandidateId), "selection.json").replace(/\\/g, "/");
-	try {
-		const existing = measuredSelectionReceiptSchema.parse(JSON.parse((await readRegularFileWithinRoot(runDir, relativePath)).bytes.toString("utf8")));
-		if (canonicalJson(existing) !== canonicalJson(receipt)) throw new Error("measured knowledge selection receipt conflicts with durable content");
-		return;
-	} catch (error) {
-		if (!isMissingFile(error)) throw error;
-	}
-	await writeJsonDurableWithinRoot(runDir, relativePath, receipt);
-}
-function immutableJson(value) {
-	if (value === null || typeof value !== "object") return value;
-	const children = Array.isArray(value) ? value : Object.values(value);
-	for (const child of children) immutableJson(child);
-	return Object.freeze(value);
-}
-//#endregion
-//#region src/agent-candidate.ts
-/** Convert a measured knowledge candidate into the shared review and execution identity. */
-function toAgentCandidateKnowledgeRef(candidate) {
-	const parsed = KnowledgeImprovementCandidateRefSchema.parse(candidate);
-	return {
-		...parsed,
-		goalHash: prefixedDigest(parsed.goalHash),
-		baseHash: prefixedDigest(parsed.baseHash),
-		candidateHash: prefixedDigest(parsed.candidateHash),
-		evidenceHash: prefixedDigest(parsed.evidenceHash),
-		promotionPlanHash: prefixedDigest(parsed.promotionPlanHash)
-	};
-}
-/** Recover agent-knowledge's candidate identity from the shared contract. */
-function fromAgentCandidateKnowledgeRef(candidate) {
-	return KnowledgeImprovementCandidateRefSchema.parse({
-		...candidate,
-		goalHash: rawDigest(candidate.goalHash),
-		baseHash: rawDigest(candidate.baseHash),
-		candidateHash: rawDigest(candidate.candidateHash),
-		evidenceHash: rawDigest(candidate.evidenceHash),
-		promotionPlanHash: rawDigest(candidate.promotionPlanHash)
-	});
-}
-function prefixedDigest(value) {
-	return sha256DigestSchema.parse(`sha256:${value}`);
-}
-function rawDigest(value) {
-	return sha256DigestSchema.parse(value).slice(7);
-}
-//#endregion
-//#region src/changes.ts
-function detectChanges(prev, next, options = {}) {
-	const skipUnverifiable = options.skipUnverifiable ?? true;
-	const warnings = [];
-	const { map: prevMap, warnings: prevWarn } = indexFragments(prev, skipUnverifiable, "prev");
-	const { map: nextMap, warnings: nextWarn } = indexFragments(next, skipUnverifiable, "next");
-	warnings.push(...prevWarn, ...nextWarn);
-	const changes = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const [id, nextFragment] of nextMap) {
-		seen.add(id);
-		const prevFragment = prevMap.get(id);
-		if (!prevFragment) {
-			changes.push({
-				fragmentId: id,
-				kind: "added",
-				diff: { after: nextFragment.body },
-				affectedDimensions: dedup(nextFragment.dimensionHints),
-				url: nextFragment.provenance.url,
-				detectedAt: nextFragment.provenance.sourceUpdatedAt
-			});
-			continue;
-		}
-		if (prevFragment.bodyHash !== nextFragment.bodyHash) changes.push({
-			fragmentId: id,
-			kind: "modified",
-			diff: {
-				before: prevFragment.body,
-				after: nextFragment.body
-			},
-			affectedDimensions: dedup([...prevFragment.dimensionHints, ...nextFragment.dimensionHints]),
-			url: nextFragment.provenance.url,
-			detectedAt: nextFragment.provenance.sourceUpdatedAt
-		});
-	}
-	for (const [id, prevFragment] of prevMap) {
-		if (seen.has(id)) continue;
-		changes.push({
-			fragmentId: id,
-			kind: "removed",
-			diff: { before: prevFragment.body },
-			affectedDimensions: dedup(prevFragment.dimensionHints),
-			url: prevFragment.provenance.url,
-			detectedAt: prevFragment.provenance.sourceUpdatedAt
-		});
-	}
-	const filtered = options.filterDimensions ? changes.filter((c) => c.affectedDimensions.some((d) => options.filterDimensions?.includes(d))) : changes;
-	return {
-		changes: filtered,
-		summary: {
-			added: filtered.filter((c) => c.kind === "added").length,
-			removed: filtered.filter((c) => c.kind === "removed").length,
-			modified: filtered.filter((c) => c.kind === "modified").length
-		},
-		warnings
-	};
-}
-function indexFragments(fragments, skipUnverifiable, side) {
-	const map = /* @__PURE__ */ new Map();
-	const warnings = [];
-	let dropped = 0;
-	for (const fragment of fragments) {
-		if (skipUnverifiable && !fragment.provenance.verifiable) {
-			dropped += 1;
-			continue;
-		}
-		if (map.has(fragment.id)) warnings.push(`${side}: duplicate fragment id ${fragment.id} — keeping last`);
-		map.set(fragment.id, fragment);
-	}
-	if (dropped > 0) warnings.push(`${side}: dropped ${dropped} unverifiable fragment(s) before diff`);
-	return {
-		map,
-		warnings
-	};
-}
-function dedup(items) {
-	return [...new Set(items)];
+}
+/** Recover agent-knowledge's candidate identity from the shared contract. */
+function fromAgentCandidateKnowledgeRef(candidate) {
+	return KnowledgeImprovementCandidateRefSchema.parse({
+		...candidate,
+		goalHash: rawDigest(candidate.goalHash),
+		baseHash: rawDigest(candidate.baseHash),
+		candidateHash: rawDigest(candidate.candidateHash),
+		evidenceHash: rawDigest(candidate.evidenceHash),
+		promotionPlanHash: rawDigest(candidate.promotionPlanHash)
+	});
+}
+function prefixedDigest(value) {
+	return sha256DigestSchema.parse(`sha256:${value}`);
+}
+function rawDigest(value) {
+	return sha256DigestSchema.parse(value).slice(7);
 }
 //#endregion
 //#region src/chunking.ts
@@ -4408,57 +3569,6 @@ function mergeTinyChunks(chunks, opts) {
 	return out;
 }
 //#endregion
-//#region src/citation-lint.ts
-/** Convert a chain-aware citation audit into the package lint vocabulary. */
-function knowledgeCitationAuditFindings(report) {
-	return report.issues.map(issueToFinding);
-}
-/** Lint only current-run pages against their complete declared visibility chain. */
-async function lintCurrentRunCitations(stores, runId) {
-	return knowledgeCitationAuditFindings(await auditCurrentRunCitations(stores, runId));
-}
-function issueToFinding(issue) {
-	const candidates = issue.candidates.map((candidate) => ({
-		pageId: candidate.pageId,
-		path: candidate.page.path,
-		origin: candidate.origin
-	}));
-	if (issue.kind === "ambiguous") return {
-		type: "ambiguous-citation",
-		severity: "error",
-		page: issue.sourcePath,
-		message: `Citation "${issue.persistedCitation}" resolves to ${issue.candidates.length} visible pages; qualify it as here::<pageId>, inherited:<runId>::<pageId>, or shared::<pageId>.`,
-		metadata: {
-			sourcePageId: issue.sourcePageId,
-			sourceOrigin: issue.sourceOrigin,
-			candidates
-		}
-	};
-	return {
-		type: "broken-citation",
-		severity: "error",
-		page: issue.sourcePath,
-		message: issue.kind === "self" ? `Page "${issue.sourcePageId}" cites itself through "${issue.persistedCitation}".` : `Citation "${issue.persistedCitation}" resolves to no visible page.`,
-		metadata: {
-			sourcePageId: issue.sourcePageId,
-			sourceOrigin: issue.sourceOrigin,
-			candidates
-		}
-	};
-}
-//#endregion
-//#region src/collection-research-driver.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.
-*/
-function createCollectionResearchDriver() {
-	return { verifySource(_source) {
-		return { accept: true };
-	} };
-}
-//#endregion
 //#region src/discovery.ts
 /**
 * Dispatch discovery tasks and recursively pursue worker-proposed follow-ups.
@@ -4611,1340 +3721,33 @@ var FileSystemSearchProvider = class {
 			lexicalIndex: this.lexicalIndex
 		});
 	}
-	async retrieve(query, options = {}) {
-		return (await this.search(query, options)).map(hitFromSearchResult);
-	}
-	asRetrievalEvalRetriever() {
-		return async ({ config, scenario, k }) => ({ hits: await this.retrieve(scenario.query, {
-			limit: k,
-			refresh: config.refresh === true
-		}) });
-	}
-	invalidate() {
-		this.index = void 0;
-		this.lexicalIndex = void 0;
-	}
-};
-function createFileSystemSearchProvider(options) {
-	return new FileSystemSearchProvider(options);
-}
-function hitFromSearchResult(result) {
-	return {
-		pageId: result.page.id,
-		path: result.page.path,
-		title: result.page.title,
-		rank: result.rank,
-		score: result.score,
-		normalizedScore: result.normalizedScore,
-		sourceIds: result.page.sourceIds,
-		snippet: result.snippet
-	};
-}
-//#endregion
-//#region src/freshness.ts
-const freshnessRecordSchema = z.object({
-	workspaceId: z.string().min(1),
-	sourceId: z.string().min(1),
-	lastRefreshedAt: z.iso.datetime(),
-	contentHash: z.string().min(1).optional()
-}).strict();
-const freshnessFileSchema = z.object({ records: z.record(z.string(), freshnessRecordSchema) }).strict();
-/**
-* Filesystem-backed implementation. Single JSON file per knowledge root,
-* indexed by `${workspaceId}::${sourceId}`. Reads parse on every call;
-* cron tick rate is well below the cost of one JSON parse.
-*
-* Writes share the package-wide filesystem lock, so multiple workers cannot
-* overwrite one another or run through an interrupted knowledge promotion.
-*/
-function createFileSystemFreshnessStore(options) {
-	const path = join(options.root, ".agent-knowledge", "freshness.json");
-	const read = async () => {
-		return withKnowledgeRead(options.root, async () => {
-			try {
-				return freshnessFileSchema.parse(JSON.parse(await readFile(path, "utf8"))).records;
-			} catch (error) {
-				if (isMissingFile(error)) return {};
-				throw error;
-			}
-		});
-	};
-	const write = async (records) => {
-		await writeJsonDurableWithinRoot(options.root, ".agent-knowledge/freshness.json", freshnessFileSchema.parse({ records }));
-	};
-	return {
-		async last(key) {
-			const record = (await read())[buildKey(key)];
-			return record ? new Date(record.lastRefreshedAt) : null;
-		},
-		async mark(input) {
-			await withKnowledgeMutation(options.root, async () => {
-				const records = await read();
-				records[buildKey(input)] = {
-					workspaceId: input.workspaceId,
-					sourceId: input.sourceId,
-					lastRefreshedAt: input.when.toISOString(),
-					...input.contentHash === void 0 ? {} : { contentHash: input.contentHash }
-				};
-				await write(records);
-			});
-		},
-		async stale(input) {
-			const last = await this.last(input);
-			if (!last) return true;
-			return (input.now ?? /* @__PURE__ */ new Date()).getTime() - last.getTime() > input.ttlMs;
-		},
-		async list(workspaceId) {
-			const records = await read();
-			return Object.values(records).filter((r) => r.workspaceId === workspaceId);
-		}
-	};
-}
-function createD1FreshnessStoreStub(adapter) {
-	return {
-		async last(key) {
-			const record = await adapter.get(key.workspaceId, key.sourceId);
-			return record ? new Date(record.lastRefreshedAt) : null;
-		},
-		async mark(input) {
-			await adapter.upsert({
-				workspaceId: input.workspaceId,
-				sourceId: input.sourceId,
-				lastRefreshedAt: input.when.toISOString(),
-				contentHash: input.contentHash
-			});
-		},
-		async stale(input) {
-			const last = await this.last(input);
-			if (!last) return true;
-			return (input.now ?? /* @__PURE__ */ new Date()).getTime() - last.getTime() > input.ttlMs;
-		},
-		async list(workspaceId) {
-			return adapter.listByWorkspace(workspaceId);
-		}
-	};
-}
-function buildKey(key) {
-	return `${key.workspaceId}::${key.sourceId}`;
-}
-//#endregion
-//#region src/invalidation-propagation.ts
-/**
-* Invalidation propagation.
-*
-* A page whose own evidence refuted it carries an `invalidation`. That verdict
-* is invisible to a reader who arrives through a citation, so a page that cites
-* a refuted page records which of its citations are refuted. The pass is
-* planned as a diff, so a store already stamped produces no mutation and the
-* pass can run after every grading round.
-*/
-/** Frontmatter field naming the cited pages whose evidence refuted them. */
-const CITES_INVALIDATED_FIELD = "citesInvalidated";
-/**
-* Plan the `citesInvalidated` stamp for every page authored in the target
-* store.
-*
-* Citations resolve over the whole chain, so a page here may be stamped for
-* citing a refuted inherited or shared page. Only `here` pages are stamped: a
-* run does not write the stores it inherits or shares.
-*/
-function planInvalidationPropagation(visiblePages) {
-	if (!Array.isArray(visiblePages)) throw new TypeError("knowledge invalidation propagation requires the visible pages");
-	const invalidatedPageIds = [...new Set(visiblePages.filter((entry) => entry.page.invalidation !== void 0).map((entry) => entry.page.id))].sort();
-	const stamps = [];
-	for (const entry of visiblePages) {
-		if (entry.origin !== "here") continue;
-		const page = entry.page;
-		const refuted = /* @__PURE__ */ new Set();
-		for (const persisted of page.cites ?? []) {
-			const resolution = resolveKnowledgeCitation(visiblePages, parseKnowledgeCitationReference(persisted));
-			if (resolution.resolved?.page.invalidation !== void 0) refuted.add(resolution.resolved.page.id);
-		}
-		const citesInvalidated = [...refuted].sort();
-		const current = idList(page.frontmatter[CITES_INVALIDATED_FIELD]);
-		if (sameOrder(current, citesInvalidated)) continue;
-		stamps.push({
-			page,
-			citesInvalidated,
-			current
-		});
-	}
-	stamps.sort((left, right) => left.page.path.localeCompare(right.page.path));
-	return {
-		invalidatedPageIds,
-		stamps
-	};
-}
-/**
-* Render one plan as a write-block proposal for `applyKnowledgeWriteBlocks`.
-*
-* Only the stamped field changes. The page is rendered through
-* `formatFrontmatter`, so its frontmatter is written in that writer's
-* normalized form.
-*/
-function formatKnowledgeInvalidationProposal(plan) {
-	return plan.stamps.map((stamp) => renderStampedBlock(stamp)).join("\n");
-}
-function renderStampedBlock(stamp) {
-	const frontmatter = { ...stamp.page.frontmatter };
-	if (stamp.citesInvalidated.length === 0) delete frontmatter[CITES_INVALIDATED_FIELD];
-	else frontmatter[CITES_INVALIDATED_FIELD] = [...stamp.citesInvalidated];
-	const content = formatFrontmatter(frontmatter, stamp.page.text);
-	return `---FILE: ${stamp.page.path}---\n${content.replace(/\n+$/, "")}\n---END FILE---`;
-}
-function idList(value) {
-	return (typeof value === "string" ? [value] : Array.isArray(value) ? value : []).filter((item) => typeof item === "string" && item.trim() !== "");
-}
-function sameOrder(left, right) {
-	return left.length === right.length && left.every((item, index) => item === right[index]);
-}
-//#endregion
-//#region src/investment-thesis-set.ts
-/**
-* The eval set. 5 public companies, 5-8 held-out material facts each, every fact
-* grounded in a primary SEC EDGAR 10-K filed on or before the cutoff.
-*
-* CURATION-BIAS DISCLOSURE (full version in the doc): all five are companies
-* whose buried risks later materialized, because that is where the material-vs-
-* surface distinction is sharpest AND where the figures are easy to verify after
-* the fact. This biases the set toward downside risks (two of the eight lenses,
-* concentration + leverage, dominate) and toward distressed names. A production
-* eval would balance these with companies whose buried facts were POSITIVE
-* drivers and with survivors. This set is honest about that and reports the lens
-* distribution so the bias is measurable, not hidden.
-*/
-const investmentThesisSet = [
-	{
-		ticker: "SIVB",
-		company: "SVB Financial Group",
-		cik: "719739",
-		cutoff: "2023-02-24",
-		sector: "Banking",
-		knownOutcome: "Failed in a deposit run and was placed in FDIC receivership on March 10, 2023; the holding company filed Chapter 11 on March 17, 2023.",
-		facts: [
-			{
-				id: "SIVB/f1",
-				lens: "off-balance-sheet",
-				fact: "Held-to-maturity (HTM) securities carried at $91.3B amortized cost had a fair value of only $76.2B — a ~$15.1B unrealized loss that, because the portfolio is HTM, never touched earnings or equity and sat only in the footnotes.",
-				expected: [{
-					label: "HTM securities",
-					anyOf: [
-						"held-to-maturity",
-						"held to maturity",
-						"htm"
-					]
-				}, {
-					label: "large unrealized loss (~$15B) / fair value gap",
-					anyOf: [
-						"15.1",
-						"15.2",
-						"$15 billion",
-						"15 billion",
-						"76,169",
-						"76.2 billion",
-						"91,321",
-						"unrealized loss",
-						"below amortized cost",
-						"fair value"
-					]
-				}],
-				minGroups: 2,
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/719739/000071973923000021/sivb-20221231.htm",
-				evidence: "Balance sheet (Dec 31, 2022): \"Held-to-maturity securities, at amortized cost ... 91,321\" with parenthetical \"(fair value of $ 76,169 ...)\". The gap = $91,321M - $76,169M = ~$15,152M unrealized loss, disclosed only in the notes."
-			},
-			{
-				id: "SIVB/f2",
-				lens: "off-balance-sheet",
-				fact: "The HTM unrealized loss (~$15.1B) was roughly equal to the company's entire $16.0B total stockholders' equity — a mark-to-market wipeout hidden by HTM accounting.",
-				expected: [{
-					label: "loss near/exceeds total equity",
-					anyOf: [
-						"equity",
-						"capital",
-						"insolvent",
-						"wipe out",
-						"exceeds",
-						"nearly all",
-						"tangible book",
-						"16,004",
-						"16 billion"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/719739/000071973923000021/sivb-20221231.htm",
-				evidence: "\"Total SVBFG stockholders' equity 16,004\" (Dec 31, 2022). The ~$15.15B HTM unrealized loss is ~95% of the $16.0B reported equity."
-			},
-			{
-				id: "SIVB/f3",
-				lens: "concentration",
-				fact: "Estimated uninsured deposits in U.S. offices were $151.5B at year-end 2022 — the run-prone funding base; a high share of total deposits exceeded the FDIC limit.",
-				expected: [{
-					label: "large uninsured deposit base",
-					anyOf: [
-						"uninsured deposit",
-						"above the fdic",
-						"exceed the fdic",
-						"exceeds the fdic",
-						"151.5",
-						"$151 billion",
-						"fdic insurance limit"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/719739/000071973923000021/sivb-20221231.htm",
-				evidence: "\"As of December 31, 2022 ... the amount of estimated uninsured deposits in U.S. offices that exceed the FDIC insurance limit were $151.5 billion\"."
-			},
-			{
-				id: "SIVB/f4",
-				lens: "margin-trend",
-				fact: "Cheap noninterest-bearing demand deposits fell 20 percentage points in one year — to 47% of total deposits from 67% — meaning funding costs were set to rise sharply as clients moved to interest-bearing accounts.",
-				expected: [{
-					label: "deposit mix shift to costlier funding",
-					anyOf: [
-						"noninterest-bearing",
-						"non-interest-bearing",
-						"noninterest bearing",
-						"deposit mix",
-						"funding cost",
-						"cost of deposits",
-						"interest-bearing",
-						"47 percent",
-						"20 percentage"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/719739/000071973923000021/sivb-20221231.htm",
-				evidence: "\"Noninterest-bearing demand deposits to total deposits decreased by 20 percentage points to 47 percent as of December 31, 2022, compared to ... 2021.\""
-			},
-			{
-				id: "SIVB/f5",
-				lens: "concentration",
-				fact: "The deposit and loan base was concentrated in a single client type — the \"innovation economy\" (venture-backed technology and life-science startups) — so a downturn in venture funding would hit deposits and credit simultaneously.",
-				expected: [{
-					label: "concentration in tech / startups / innovation economy",
-					anyOf: [
-						"innovation economy",
-						"technology",
-						"life science",
-						"venture",
-						"startup",
-						"early-stage",
-						"concentrat",
-						"single industry",
-						"sector concentration"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/719739/000071973923000021/sivb-20221231.htm",
-				evidence: "The 10-K repeatedly frames the franchise around clients in \"the innovation economy\" (technology, life science / healthcare, and the venture firms that back them) — a single-sector deposit + credit concentration."
-			},
-			{
-				id: "SIVB/f6",
-				lens: "off-balance-sheet",
-				fact: "Available-for-sale (AFS) securities of $28.6B amortized cost were marked to a $26.1B fair value — a ~$2.5B loss that DID flow through equity (AOCI), the visible tip of a much larger unrealized-loss iceberg dominated by the footnote-only HTM book.",
-				expected: [{
-					label: "AFS unrealized loss / AOCI",
-					anyOf: [
-						"available-for-sale",
-						"available for sale",
-						"afs",
-						"aoci",
-						"accumulated other comprehensive",
-						"28,602",
-						"26,069",
-						"2.5 billion"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/719739/000071973923000021/sivb-20221231.htm",
-				evidence: "\"Available-for-sale securities, at fair value (cost of $ 28,602 ...) 26,069\" — a ~$2.5B AFS unrealized loss carried in AOCI, separate from and much smaller than the HTM gap."
-			}
-		]
-	},
-	{
-		ticker: "BBBY",
-		company: "Bed Bath & Beyond Inc.",
-		cik: "886158",
-		cutoff: "2022-04-21",
-		sector: "Specialty retail",
-		knownOutcome: "Filed for Chapter 11 bankruptcy on April 23, 2023; shareholders were wiped out.",
-		facts: [
-			{
-				id: "BBBY/f1",
-				lens: "capital-return",
-				fact: "The company had repurchased ~$11.685B of its own stock since 2004 — including $574.9M in fiscal 2021 alone, \"two years ahead of schedule\" — draining the balance sheet of a business that was losing money.",
-				expected: [{
-					label: "massive buyback program",
-					anyOf: [
-						"repurchas",
-						"buyback",
-						"buy back",
-						"share repurchase",
-						"11.685",
-						"$11.7 billion",
-						"574.9",
-						"$575 million"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/886158/000088615822000047/bbby-20220226.htm",
-				evidence: "\"Since 2004 through the end of Fiscal 2021, we have repurchased approximately $11.685 billion of our common stock\"; FY2021 alone \"completed share repurchases of $574.9 million ... two years ahead of schedule.\""
-			},
-			{
-				id: "BBBY/f2",
-				lens: "liquidity",
-				fact: "Operating cash flow collapsed to just $17.9M in FY2021, down from $268.1M and $590.9M in the two prior years — a near-total loss of internally generated cash while it kept buying back stock.",
-				expected: [{
-					label: "operating cash flow collapse",
-					anyOf: [
-						"operating cash flow",
-						"cash from operations",
-						"cash provided by operating",
-						"cash flow from operations",
-						"17.9",
-						"17,854",
-						"declining cash flow",
-						"cash generation"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/886158/000088615822000047/bbby-20220226.htm",
-				evidence: "Statement of cash flows: \"Net cash provided by operating activities 17,854 268,108 590,941\" (FY2021 / FY2020 / FY2019, $ thousands)."
-			},
-			{
-				id: "BBBY/f3",
-				lens: "liquidity",
-				fact: "Total shareholders' equity fell ~86% in one year — from $1.277B to $174.1M — as losses plus buybacks ate the equity cushion.",
-				expected: [{
-					label: "equity erosion",
-					anyOf: [
-						"shareholders’ equity",
-						"shareholders' equity",
-						"stockholders equity",
-						"book value",
-						"equity",
-						"net worth",
-						"174.1",
-						"174,145",
-						"eroded"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/886158/000088615822000047/bbby-20220226.htm",
-				evidence: "\"Total shareholders' equity 174,145 1,276,936\" (FY2021 vs FY2020, $ thousands) — an ~86% decline in one year."
-			},
-			{
-				id: "BBBY/f4",
-				lens: "liquidity",
-				fact: "The company posted a $559.6M net loss in FY2021 — yet spent $574.9M on buybacks the same year, i.e. it returned more cash to shareholders than it had, let alone earned.",
-				expected: [{
-					label: "net loss FY2021",
-					anyOf: [
-						"net loss",
-						"unprofitable",
-						"lost money",
-						"losing money",
-						"559.6",
-						"559,623",
-						"$560 million"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/886158/000088615822000047/bbby-20220226.htm",
-				evidence: "\"Net loss $ ( 559,623 )\" for fiscal 2021 ($ thousands)."
-			},
-			{
-				id: "BBBY/f5",
-				lens: "margin-trend",
-				fact: "Merchandise inventories rose to $1.725B even as sales fell — inventory building into a demand decline, a classic markdown-risk and cash-trap signal.",
-				expected: [{
-					label: "inventory building into falling demand",
-					anyOf: [
-						"inventor",
-						"merchandise inventories",
-						"overstock",
-						"markdown",
-						"1,725",
-						"1.7 billion",
-						"stockpile"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/886158/000088615822000047/bbby-20220226.htm",
-				evidence: "\"Merchandise inventories 1,725,410 1,671,909\" ($ thousands) — inventory grew year over year while comparable sales declined."
-			}
-		]
-	},
-	{
-		ticker: "CVNA",
-		company: "Carvana Co.",
-		cik: "1690820",
-		cutoff: "2023-02-23",
-		sector: "Auto e-commerce",
-		knownOutcome: "The stock fell ~98% from its 2021 peak; the company narrowly avoided bankruptcy via a 2023 debt-exchange that cut and extended its obligations.",
-		facts: [
-			{
-				id: "CVNA/f1",
-				lens: "leverage",
-				fact: "Total debt had grown to $8.39B by year-end 2022 (from $5.45B) — a debt load far larger than the equity base, built up funding growth and the ADESA deal.",
-				expected: [{
-					label: "large/growing debt load",
-					anyOf: [
-						"total debt",
-						"long-term debt",
-						"leverage",
-						"highly leveraged",
-						"debt load",
-						"8,391",
-						"8.4 billion",
-						"$8.4 billion"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/1690820/000169082023000052/cvna-20221231.htm",
-				evidence: "\"Total debt 8,391 5,447\" (Dec 31, 2022 vs 2021, $ millions)."
-			},
-			{
-				id: "CVNA/f2",
-				lens: "leverage",
-				fact: "Interest expense nearly tripled to $486M in 2022 (from $176M) — debt-service was consuming cash a still-unprofitable company did not have.",
-				expected: [{
-					label: "rising interest burden",
-					anyOf: [
-						"interest expense",
-						"interest cost",
-						"debt service",
-						"cost of debt",
-						"486",
-						"interest burden"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/1690820/000169082023000052/cvna-20221231.htm",
-				evidence: "\"Interest expense 486 176\" (FY2022 vs FY2021, $ millions)."
-			},
-			{
-				id: "CVNA/f3",
-				lens: "leverage",
-				fact: "In May 2022 Carvana bought ADESA's U.S. physical auction business for ~$2.2B in cash — a debt-funded acquisition that stretched the balance sheet right as used-car demand turned.",
-				expected: [{
-					label: "ADESA acquisition ~$2.2B",
-					anyOf: [
-						"adesa",
-						"2.2 billion",
-						"$2.2 billion",
-						"physical auction",
-						"acquisition"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/1690820/000169082023000052/cvna-20221231.htm",
-				evidence: "\"physical auction business of ADESA US Auction, LLC for approximately $2.2 billion in cash (the 'ADESA Acquisition')\", closed 2022-05-09."
-			},
-			{
-				id: "CVNA/f4",
-				lens: "governance",
-				fact: "Carvana leases hubs and properties from DriveTime — a company controlled by founder/CEO Ernest Garcia III and his father Ernest Garcia II — a recurring related-party arrangement with the controlling family.",
-				expected: [{
-					label: "related-party with founder family / DriveTime",
-					anyOf: [
-						"related party",
-						"related-party",
-						"drivetime",
-						"garcia",
-						"controlled by",
-						"affiliate of",
-						"conflict of interest"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/1690820/000169082023000052/cvna-20221231.htm",
-				evidence: "Related Party Transactions note: lease agreements with \"DriveTime Automotive Group\", a related party \"due to Ernest Garcia II, Ernest Garcia III, and entities controlled by one or both of them\"."
-			},
-			{
-				id: "CVNA/f5",
-				lens: "liquidity",
-				fact: "The 2022 net loss was $2.894B — a loss far wider than prior years, showing the unit economics had not turned even at scale.",
-				expected: [{
-					label: "large net loss FY2022",
-					anyOf: [
-						"net loss",
-						"unprofitable",
-						"losing money",
-						"cash burn",
-						"2,894",
-						"2.9 billion",
-						"$2.9 billion"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/1690820/000169082023000052/cvna-20221231.htm",
-				evidence: "\"Net loss $ (2,894 ...\" for fiscal 2022 ($ millions)."
-			}
-		]
-	},
-	{
-		ticker: "PTON",
-		company: "Peloton Interactive, Inc.",
-		cik: "1639825",
-		cutoff: "2022-09-07",
-		sector: "Consumer fitness hardware",
-		knownOutcome: "The stock fell ~95% from its 2021 peak; the founder-CEO departed, the company underwent mass layoffs and a multi-year turnaround through fiscal 2024.",
-		facts: [
-			{
-				id: "PTON/f1",
-				lens: "margin-trend",
-				fact: "Connected Fitness (hardware) gross margin turned NEGATIVE — to (11)% in FY2022 — meaning Peloton lost money on every bike/tread it sold before any operating cost; revenue growth was masking a broken unit economics.",
-				expected: [{
-					label: "negative / collapsing hardware gross margin",
-					anyOf: [
-						"gross margin",
-						"negative margin",
-						"gross profit",
-						"margin compression",
-						"losing money on each",
-						"below cost",
-						"(11)",
-						"-11",
-						"negative gross"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/1639825/000163982522000117/pton-20220630.htm",
-				evidence: "MD&A \"Gross Profit, and Gross Margin\" table: Connected Fitness \"Gross Margin decreased to (11)\" percent in fiscal 2022 — a negative hardware gross margin."
-			},
-			{
-				id: "PTON/f2",
-				lens: "liquidity",
-				fact: "Inventories climbed to $1.105B as pandemic demand normalized — a glut of unsold equipment that tied up cash and risked markdowns.",
-				expected: [{
-					label: "inventory glut",
-					anyOf: [
-						"inventor",
-						"overstock",
-						"excess inventory",
-						"glut",
-						"markdown",
-						"unsold",
-						"1,104",
-						"1.1 billion"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/1639825/000163982522000117/pton-20220630.htm",
-				evidence: "\"Inventories, net 1,104.5 937\" (FY2022 vs FY2021, $ millions)."
-			},
-			{
-				id: "PTON/f3",
-				lens: "governance",
-				fact: "A dual-class structure gives Class B holders 20 votes per share vs 1 for Class A — concentrating control with insiders/founders and limiting public shareholders' say.",
-				expected: [{
-					label: "dual-class super-voting control",
-					anyOf: [
-						"dual-class",
-						"dual class",
-						"class b",
-						"20 votes",
-						"super-voting",
-						"supervoting",
-						"voting control",
-						"multiple votes per share"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/1639825/000163982522000117/pton-20220630.htm",
-				evidence: "\"Class B common stock has 20 votes per share and our Class A common stock has one vote per share.\""
-			},
-			{
-				id: "PTON/f4",
-				lens: "liquidity",
-				fact: "Peloton reported a $2.827B net loss in FY2022 — an order-of-magnitude wider loss than the prior year, signaling the demand normalization had broken the model, not just dented it.",
-				expected: [{
-					label: "large net loss FY2022",
-					anyOf: [
-						"net loss",
-						"unprofitable",
-						"losing money",
-						"cash burn",
-						"2,827",
-						"2.8 billion",
-						"$2.8 billion"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/1639825/000163982522000117/pton-20220630.htm",
-				evidence: "\"Net loss $ (2,827 ...\" for fiscal 2022 ($ millions)."
-			},
-			{
-				id: "PTON/f5",
-				lens: "regulatory",
-				fact: "Peloton was running a CPSC recall of its Tread+ treadmill (tied to injuries and a child death) — an open product-safety and legal exposure beyond the demand story.",
-				expected: [{
-					label: "Tread+ / CPSC recall exposure",
-					anyOf: [
-						"recall",
-						"cpsc",
-						"consumer product safety",
-						"tread+",
-						"tread plus",
-						"product safety",
-						"injuries",
-						"safety"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/1639825/000163982522000117/pton-20220630.htm",
-				evidence: "\"recall on Tread+, which we are conducting in collaboration with the Consumer Product Safety Commission ('CPSC')\"; the Tread product recalls \"in the fourth quarter of fiscal 2021 continued to impact\" results."
-			},
-			{
-				id: "PTON/f6",
-				lens: "leverage",
-				fact: "Peloton was locked into ~$334M of manufacturing purchase commitments even as demand fell — contractual inventory it had to take on regardless of whether it could sell it.",
-				expected: [{
-					label: "locked-in purchase commitments",
-					anyOf: [
-						"purchase commitment",
-						"purchase obligation",
-						"minimum purchase",
-						"take-or-pay",
-						"committed to purchase",
-						"334",
-						"manufacturing commitment"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/1639825/000163982522000117/pton-20220630.htm",
-				evidence: "\"purchase commitments related to the manufacture of Peloton products were estimated to be approximately $334\" million."
-			}
-		]
-	},
-	{
-		ticker: "SI",
-		company: "Silvergate Capital Corporation",
-		cik: "1312109",
-		cutoff: "2022-02-28",
-		sector: "Banking (digital-asset)",
-		knownOutcome: "After the FTX collapse triggered a deposit run, Silvergate announced a voluntary wind-down of Silvergate Bank and liquidation in March 2023.",
-		facts: [
-			{
-				id: "SI/f1",
-				lens: "concentration",
-				fact: "About 99.5% of total deposits were noninterest-bearing — essentially all funding was non-term money that could leave on demand, an extreme run-risk masked by very low funding cost.",
-				expected: [{
-					label: "almost all deposits noninterest-bearing / on-demand",
-					anyOf: [
-						"noninterest bearing",
-						"noninterest-bearing",
-						"non-interest-bearing",
-						"demand deposit",
-						"no term",
-						"on demand",
-						"99.5",
-						"99 percent",
-						"leave at any time"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/1312109/000131210922000051/si-20211231.htm",
-				evidence: "\"noninterest bearing deposits as a percentage of total deposits was 99.5% as of December 31, 2021.\""
-			},
-			{
-				id: "SI/f2",
-				lens: "concentration",
-				fact: "Roughly 58% of deposits came from digital-currency EXCHANGES alone — a handful of correlated crypto counterparties whose own troubles would pull deposits out together.",
-				expected: [{
-					label: "deposits concentrated in crypto exchanges",
-					anyOf: [
-						"digital currency exchange",
-						"crypto exchange",
-						"exchanges represent",
-						"counterpart",
-						"concentrat",
-						"58%",
-						"58 percent",
-						"approximately 58"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/1312109/000131210922000051/si-20211231.htm",
-				evidence: "\"Deposits from digital currency exchanges represent approximately 58%\" of deposits."
-			},
-			{
-				id: "SI/f3",
-				lens: "concentration",
-				fact: "The entire deposit franchise was tied to a single, volatile industry — digital-currency (crypto) customers — so a crypto downturn was a direct, undiversified funding shock.",
-				expected: [{
-					label: "single-industry deposit CONCENTRATION (not just \"it banks crypto\")",
-					anyOf: [
-						"digital currency customers",
-						"single industry",
-						"one industry",
-						"single volatile industry",
-						"sector concentration",
-						"undiversified",
-						"concentrat"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/1312109/000131210922000051/si-20211231.htm",
-				evidence: "The 10-K's strategy and risk factors center the bank on \"digital currency customers\" and \"the concentration of our deposits\" in that single industry."
-			},
-			{
-				id: "SI/f4",
-				lens: "liquidity",
-				fact: "Total deposits had ballooned to $14.3B (from $10.4B) — fast, hot-money growth from the crypto boom that could reverse just as fast.",
-				expected: [{
-					label: "specific hot-money deposit base ($14.3B / volatile)",
-					anyOf: [
-						"hot money",
-						"hot-money",
-						"volatile deposit",
-						"could reverse",
-						"14.3 billion",
-						"14,290",
-						"$14.3b",
-						"$14 billion"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/1312109/000131210922000051/si-20211231.htm",
-				evidence: "\"Total deposits $ 14,290,628\" ... prior year \"$ 10,411,278\" ($ thousands)."
-			},
-			{
-				id: "SI/f5",
-				lens: "concentration",
-				fact: "The franchise hinged on a single proprietary product — the Silvergate Exchange Network (SEN), a payment network built exclusively for the digital-currency industry — so its competitive moat and its deposit base were the SAME crypto-dependent bet, not two diversified ones.",
-				expected: [{
-					label: "names the SEN single-product dependence (not generic \"payment network\")",
-					anyOf: [
-						"silvergate exchange network",
-						"the sen",
-						"sen)",
-						"sen'",
-						"single product",
-						"single-product",
-						"core product",
-						"one product",
-						"same bet"
-					]
-				}],
-				sourceUrl: "https://www.sec.gov/Archives/edgar/data/1312109/000131210922000051/si-20211231.htm",
-				evidence: "\"Silvergate Exchange Network ('SEN'), our proprietary, virtually instantaneous payment network for participants in the digital currency industry\" — the bank's differentiator and its deposit magnet are the same crypto-only product."
-			}
-		]
-	}
-];
-/**
-* Grade ONE material fact against an investment thesis's full text. Returns
-* whether the thesis SURFACED it plus which expected groups were found. The
-* check is a deterministic case-insensitive substring scan — $0, model-free,
-* reproducible — so the eval never leaks into a model the loop could observe.
-*/
-function gradeFactAgainstText(fact, thesisText) {
-	const haystack = thesisText.toLowerCase();
-	const found = fact.expected.filter((group) => group.anyOf.some((fragment) => haystack.includes(fragment.toLowerCase())));
-	const minGroups = fact.minGroups ?? fact.expected.length;
-	return {
-		surfaced: found.length >= minGroups,
-		groupsFound: found.length,
-		groupsTotal: fact.expected.length,
-		foundLabels: found.map((group) => group.label)
-	};
-}
-/** Grade a whole company's thesis text: how many of its held-out facts it surfaces. */
-function gradeCompanyAgainstText(company, thesisText) {
-	const perFact = company.facts.map((fact) => gradeFactAgainstText(fact, thesisText));
-	return {
-		surfaced: perFact.filter((result) => result.surfaced).length,
-		total: company.facts.length,
-		perFact
-	};
-}
-/** Total held-out facts across the set (the denominator the doc reports). */
-function totalMaterialFacts(set = investmentThesisSet) {
-	return set.reduce((sum, company) => sum + company.facts.length, 0);
-}
-/** Count facts per lens across the set — used to report (and bound) curation bias. */
-function lensDistribution(set = investmentThesisSet) {
-	const dist = {};
-	for (const company of set) for (const fact of company.facts) dist[fact.lens] = (dist[fact.lens] ?? 0) + 1;
-	return dist;
-}
-//#endregion
-//#region src/material-facts-metric.ts
-/**
-* `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.
-*/
-/**
-* Join a KB index into the single text blob the grader scans: every curated PAGE
-* (title + body) followed by every raw SOURCE (title + fetched text). This is the
-* text read AFTER the loop finished — it is never handed to the loop. Identical
-* in spirit to `kbText` in the research-quality A/B so both metrics read a KB the
-* same way.
-*/
-function kbIndexToText(index) {
-	return `${index.pages.map((page) => `${page.title}\n${page.text}`).join("\n\n")}\n\n${index.sources.map((source) => `${source.title ?? ""}\n${source.text ?? ""}`).join("\n\n")}`;
-}
-/**
-* Grade one company's KB against its held-out material-fact checklist, given the
-* KB's already-joined text. The pure core — no I/O — so calibration can score a
-* hand-written shallow/deep thesis string directly and the live path can score a
-* real KB. Returns the surfaced FRACTION plus the per-fact audit trail.
-*/
-function materialFactsSurfacedInText(company, kbText) {
-	const grade = gradeCompanyAgainstText(company, kbText);
-	const perFact = company.facts.map((fact) => {
-		const r = gradeFactAgainstText(fact, kbText);
-		return {
-			id: fact.id,
-			lens: fact.lens,
-			surfaced: r.surfaced,
-			groupsFound: r.groupsFound,
-			groupsTotal: r.groupsTotal,
-			foundLabels: r.foundLabels
-		};
-	});
-	return {
-		ticker: company.ticker,
-		company: company.company,
-		surfaced: grade.surfaced,
-		total: grade.total,
-		fraction: grade.total === 0 ? 0 : grade.surfaced / grade.total,
-		perFact
-	};
-}
-/**
-* `materialFactsSurfaced(kb, checklist)` — the metric in its KB-reading form.
-*
-* `kb` is EITHER a knowledge-base root directory (the loop wrote pages there) or
-* an already-built `KnowledgeIndex`. `checklist` is the company's held-out
-* `CompanyEvalCase`. Returns the surfaced fraction + per-fact trail.
-*
-* The checklist is HELD OUT by construction: it lives in the test eval set, is
-* never passed to the loop, and is read only here, after the loop finished.
-*/
-async function materialFactsSurfaced(kb, checklist) {
-	return materialFactsSurfacedInText(checklist, kbIndexToText(typeof kb === "string" ? await buildKnowledgeIndex(kb) : kb));
-}
-//#endregion
-//#region src/verified-research-loop.ts
-/**
-* Two-agent (driver + worker) sibling of `runKnowledgeResearchLoop`.
-*
-* Both agents research to grow ONE knowledge base. The roles are differentiated:
-*
-* - **WORKER** = primary research. Each round it reads the open gaps, discovers
-*   new sources, and proposes additions (`sources` + `proposalText`). It ADDS.
-* - **DRIVER** = the verifier / gap-filler / gate. It (1) VERIFIES the worker's
-*   sources before they commit — dedup against the KB, then `verifySource`
-*   rejects ones that aren't real/relevant; (2) GAP-FILLS the gaps the worker
-*   missed with its own research pass (when `driverResearches`); (3) folds the
-*   remaining gaps into the worker's next prompt; and (4) GATES on
-*   `scoreKnowledgeReadiness` and optional `isComplete` — the loop stops when
-*   readiness passes and the driver has no unfinished research.
-*
-* Set `driverResearches: false` (default) for the pure-coordinator mode: the
-* driver only verifies + gates and contributes no research itself.
-*
-* Composes existing atoms — `initKnowledgeBase`, `addSourceText`,
-* `applyKnowledgeWriteBlocks`, `buildEvalKnowledgeBundle` (the readiness gate),
-* and `searchKnowledge` — and reinvents none of them.
-*/
-async function runVerifiedResearchLoop(options) {
-	const assertActive = () => options.signal?.throwIfAborted();
-	assertActive();
-	const maxRounds = Math.max(1, options.maxRounds ?? 3);
-	await initKnowledgeBase(options.root);
-	assertActive();
-	const store = new FileSystemKbStore({ root: options.root });
-	const steps = [];
-	let index = await buildKnowledgeIndex(options.root);
-	assertActive();
-	await confirmRegisteredSources(options.driver, index.sources);
-	assertActive();
-	let readiness = readinessFor(options, index);
-	let ready = isReady(readiness?.report) && (options.driver.isComplete?.() ?? true);
-	let steer;
-	for (let round = 1; round <= maxRounds && !ready; round++) {
-		assertActive();
-		const gaps = gapsFromReadiness(readiness);
-		const workerContribution = await options.worker({
-			root: options.root,
-			goal: options.goal,
-			round,
-			index,
-			gaps,
-			steer,
-			readiness: requireReadiness(readiness, options),
-			signal: options.signal
-		});
-		assertActive();
-		const accepted = [];
-		const rejectedWorkerSources = [];
-		const existingUris = new Set(index.sources.flatMap((source) => typeof source.metadata?.originalUri === "string" ? [source.metadata.originalUri] : []));
-		for (const proposedSource of workerContribution.sources ?? []) {
-			const source = snapshotSourceTextInput(proposedSource);
-			if (isDuplicate(source, existingUris, accepted)) {
-				rejectedWorkerSources.push({
-					source,
-					reason: "duplicate: already in the knowledge base"
-				});
-				continue;
-			}
-			const verdict = await options.driver.verifySource(source, {
-				root: options.root,
-				goal: options.goal,
-				round,
-				index,
-				gaps,
-				acceptedThisRound: accepted,
-				signal: options.signal
-			});
-			assertActive();
-			if (verdict.accept) accepted.push(source);
-			else rejectedWorkerSources.push({
-				source,
-				reason: verdict.reason
-			});
-		}
-		const acceptedWorkerSources = await registerSources(options, accepted);
-		assertActive();
-		await confirmRegisteredSources(options.driver, acceptedWorkerSources);
-		assertActive();
-		const writtenPages = [];
-		writtenPages.push(...await applyPages(options.root, workerContribution, acceptedWorkerSources));
-		assertActive();
-		index = await buildKnowledgeIndex(options.root);
-		assertActive();
-		readiness = readinessFor(options, index);
-		let driverSources = [];
-		let driverNotes;
-		if (options.driverResearches && options.driver.research) {
-			const remainingGaps = gapsFromReadiness(readiness);
-			const driverContribution = await options.driver.research({
-				root: options.root,
-				goal: options.goal,
-				round,
-				index,
-				remainingGaps,
-				readiness: requireReadiness(readiness, options),
-				signal: options.signal
-			});
-			assertActive();
-			driverNotes = driverContribution.notes;
-			driverSources = await registerSources(options, driverContribution.sources ?? []);
-			assertActive();
-			await confirmRegisteredSources(options.driver, driverSources);
-			assertActive();
-			writtenPages.push(...await applyPages(options.root, driverContribution, driverSources));
-			assertActive();
-			index = await buildKnowledgeIndex(options.root);
-			assertActive();
-			readiness = readinessFor(options, index);
-		}
-		const driverComplete = options.driver.isComplete?.() ?? true;
-		ready = isReady(readiness?.report) && driverComplete;
-		const remainingGaps = gapsFromReadiness(readiness);
-		if (ready || remainingGaps.length === 0 && driverComplete) steer = void 0;
-		else {
-			await options.driver.prepareFold?.();
-			assertActive();
-			steer = foldGaps(options.driver, remainingGaps);
-		}
-		const step = {
-			round,
-			gaps,
-			acceptedWorkerSources,
-			rejectedWorkerSources,
-			driverSources,
-			writtenPages,
-			readiness,
-			ready,
-			event: createKnowledgeEvent({
-				type: "research.iteration",
-				actor: options.actor,
-				target: options.root,
-				metadata: {
-					goal: options.goal,
-					round,
-					ready,
-					acceptedWorkerSourceCount: acceptedWorkerSources.length,
-					rejectedWorkerSourceCount: rejectedWorkerSources.length,
-					driverSourceCount: driverSources.length,
-					writtenPageCount: writtenPages.length,
-					remainingGapCount: remainingGaps.length
-				}
-			}),
-			notes: {
-				worker: workerContribution.notes,
-				driver: driverNotes
-			}
-		};
-		await options.driver.checkpoint?.();
-		assertActive();
-		await store.putEvent(step.event);
-		assertActive();
-		steps.push(step);
-		await options.onRound?.(step);
-		assertActive();
-	}
-	assertActive();
-	return {
-		root: options.root,
-		goal: options.goal,
-		rounds: steps.length,
-		ready,
-		index,
-		readiness,
-		steps
-	};
-}
-function isReady(report) {
-	if (!report) return false;
-	return report.blockingMissingRequirements.length === 0;
-}
-function gapsFromReadiness(readiness) {
-	if (!readiness) return [];
-	const blocking = readiness.report.blockingMissingRequirements.map((requirement) => gapFor(requirement, readiness, true));
-	const nonBlocking = readiness.report.nonBlockingGaps.map((requirement) => gapFor(requirement, readiness, false));
-	return [...blocking, ...nonBlocking];
-}
-function gapFor(requirement, readiness, blocking) {
-	const spec = readiness.requirements.find((entry) => entry.id === requirement.id);
-	const query = typeof spec?.metadata?.query === "string" ? spec.metadata.query : requirement.description;
-	return {
-		id: requirement.id,
-		description: requirement.description,
-		query,
-		blocking
-	};
-}
-function foldGaps(driver, gaps) {
-	if (driver.foldGaps) return driver.foldGaps(gaps);
-	if (gaps.length === 0) return void 0;
-	return ["The knowledge base is still missing the following. Prioritise these next round:", ...gaps.map((gap) => `- (${gap.blocking ? "blocking" : "soft"}) ${gap.description} [${gap.id}]`)].join("\n");
-}
-function isDuplicate(source, existingUris, accepted) {
-	return existingUris.has(source.uri) || accepted.some((candidate) => candidate.uri === source.uri);
-}
-async function registerSources(options, sources) {
-	const records = [];
-	for (const candidate of sources) {
-		options.signal?.throwIfAborted();
-		const source = snapshotSourceTextInput(candidate);
-		records.push(await addSourceText(options.root, source, options.sourceOptions));
-		options.signal?.throwIfAborted();
-	}
-	return records;
-}
-async function confirmRegisteredSources(driver, sources) {
-	if (!driver.commitSources) return;
-	const textSources = sources.filter((source) => typeof source.metadata?.originalUri === "string");
-	if (textSources.length === 0) return;
-	await driver.commitSources(textSources);
-}
-/**
-* Apply a contribution's curated pages. Static `proposalText` plus a
-* `buildPages(acceptedSources)` result are concatenated and run through the safe
-* write protocol — but ONLY when at least one source survived verification, so a
-* page never cites a rejected (or absent) source.
-*/
-async function applyPages(root, contribution, acceptedSources) {
-	if (acceptedSources.length === 0) return [];
-	const parts = [];
-	if (contribution.proposalText) parts.push(contribution.proposalText);
-	const built = contribution.buildPages?.(acceptedSources);
-	if (built) parts.push(built);
-	if (parts.length === 0) return [];
-	return (await applyKnowledgeWriteBlocks(root, parts.join("\n"))).written;
-}
-function requireReadiness(readiness, options) {
-	if (readiness) return readiness;
-	return buildEvalKnowledgeBundle({
-		...options.readiness ?? {},
-		taskId: options.readinessTaskId ?? options.goal,
-		index: emptyIndex(options.root),
-		specs: []
-	});
-}
-function emptyIndex(root) {
-	return {
-		root,
-		generatedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
-		sources: [],
-		pages: [],
-		graph: {
-			nodes: [],
-			edges: []
-		}
-	};
-}
-/**
-* Helper for verifiers: does the candidate source's text/title overlap any page
-* the readiness search returns for a gap query? A cheap relevance heuristic the
-* driver can compose into `verifySource` (real verifiers can do more).
-*/
-function sourceMatchesGaps(source, index, gaps) {
-	const haystack = `${source.title ?? ""}\n${source.text}`.toLowerCase();
-	const hits = [];
-	for (const gap of gaps) for (const token of gap.query.toLowerCase().split(/\s+/).filter(Boolean)) if (haystack.includes(token)) {
-		hits.push(...searchKnowledge(index, gap.query, 1));
-		break;
-	}
-	return hits;
-}
-//#endregion
-//#region src/investment-thesis-task.ts
-/**
-* 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.
-*/
-/**
-* The generic analyst-lens readiness specs every company gets. They are the ONLY
-* thing the loop is told about WHAT to look for, and they name the LENSES a
-* thorough analyst checks (balance-sheet risk, concentration, leverage, margins,
-* liquidity, governance, regulatory) and where they live (the latest SEC 10-K) —
-* NOT the answers. They steer the worker's web/EDGAR search toward the filing,
-* not toward the held-out facts (which the loop never sees).
-*
-* `minSources` is set above 1 so the readiness gate stays UNMET after a single
-* fetch and the loop runs multiple rounds — the depth-driving driver needs >1
-* round to steer, exactly as the ML-exam multi-round probe established.
-*/
-function thesisReadinessSpecs(input) {
-	const c = input.company;
-	const t = input.ticker;
-	const filing = `${c} ${t} SEC 10-K annual report SEC.gov EDGAR filing`;
-	return [
-		defineReadinessSpec({
-			id: "thesis/filing",
-			description: `the most recent SEC 10-K annual report for ${c} (${t}) filed on or before ${input.cutoff}, from SEC EDGAR`,
-			query: filing,
-			requiredFor: ["ResearchAgent"],
-			importance: "blocking",
-			minSources: 2,
-			minHits: 1
-		}),
-		defineReadinessSpec({
-			id: "thesis/balance-sheet",
-			description: `${c} balance-sheet risks: securities marked below cost, unrealized losses, leverage / total debt, debt maturities, interest expense`,
-			query: `${c} ${t} 10-K balance sheet total debt unrealized losses interest expense leverage`,
-			requiredFor: ["ResearchAgent"],
-			importance: "blocking",
-			minSources: 2,
-			minHits: 1
-		}),
-		defineReadinessSpec({
-			id: "thesis/concentration-liquidity",
-			description: `${c} concentration + liquidity: customer / deposit / revenue concentration, uninsured deposits, operating cash flow, net loss, inventory, equity erosion`,
-			query: `${c} ${t} 10-K customer deposit concentration operating cash flow net loss inventory`,
-			requiredFor: ["ResearchAgent"],
-			importance: "blocking",
-			minSources: 2,
-			minHits: 1
-		}),
-		defineReadinessSpec({
-			id: "thesis/governance-regulatory",
-			description: `${c} governance + regulatory: related-party transactions, dual-class / super-voting control, buybacks / dividends, recalls, regulatory or legal exposure, margin trends`,
-			query: `${c} ${t} 10-K related party dual class share repurchase recall regulatory gross margin`,
-			requiredFor: ["ResearchAgent"],
-			importance: "blocking",
-			minSources: 2,
-			minHits: 1
-		})
-	];
-}
-/**
-* The thesis-writer prompt. After the loop has fetched + curated the filings, we
-* ask the model to SYNTHESIZE a thesis page from the curated KB text — a
-* judgment, the key drivers, and the material risks, grounded ONLY in the fetched
-* evidence. The held-out checklist is NOT in this prompt; the model writes from
-* what the loop actually pulled, so a fact only appears if the research surfaced
-* the underlying evidence.
-*/
-function thesisSynthesisMessages(input, kbText) {
-	const system = "You are a buy-side investment analyst writing a thesis memo. You are given the raw research your team gathered from public filings (SEC 10-K) and the web. Write a thesis that a thorough analyst would write: lead with your JUDGMENT, then the KEY DRIVERS, then the MATERIAL RISKS. Be specific and quantitative — name the actual figures, balance-sheet items, concentrations, leverage, margin trends, governance items, and regulatory exposures that appear in the research. Surface the buried, non-obvious drivers a one-line ticker summary misses. Ground every claim in the research provided; do NOT invent figures. If the research does not contain a figure, do not state it.";
-	const user = [
-		`Company: ${input.company} (${input.ticker})`,
-		`As-of date (reason as if it is this date): ${input.cutoff}`,
-		input.sector ? `Sector: ${input.sector}` : "",
-		"",
-		"Research gathered (filings + web excerpts):",
-		"\"\"\"",
-		kbText.slice(0, 24e3),
-		"\"\"\"",
-		"",
-		"Write the investment thesis now. Structure:",
-		"## Judgment",
-		"## Key drivers",
-		"## Material risks"
-	].filter(Boolean).join("\n");
-	return [{
-		role: "system",
-		content: system
-	}, {
-		role: "user",
-		content: user
-	}];
-}
-/** Write the synthesis thesis page into the KB so the index + metric pick it up. */
-async function writeThesisPage(root, input, thesis) {
-	return withKnowledgeMutation(root, async () => {
-		const relativePath = `knowledge/thesis-${slugify(input.ticker)}.md`;
-		const body = [
-			"---",
-			`title: Investment thesis — ${input.company} (${input.ticker})`,
-			`ticker: ${input.ticker}`,
-			`cutoff: ${input.cutoff}`,
-			"kind: investment-thesis",
-			"---",
-			`# Investment thesis — ${input.company} (${input.ticker}), as of ${input.cutoff}`,
-			"",
-			thesis.trim(),
-			""
-		].join("\n");
-		await writeFileDurableWithinRoot(root, relativePath, body, { encoding: "utf8" });
-		return join(root, relativePath);
-	});
+	async retrieve(query, options = {}) {
+		return (await this.search(query, options)).map(hitFromSearchResult);
+	}
+	asRetrievalEvalRetriever() {
+		return async ({ config, scenario, k }) => ({ hits: await this.retrieve(scenario.query, {
+			limit: k,
+			refresh: config.refresh === true
+		}) });
+	}
+	invalidate() {
+		this.index = void 0;
+		this.lexicalIndex = void 0;
+	}
+};
+function createFileSystemSearchProvider(options) {
+	return new FileSystemSearchProvider(options);
 }
-/**
-* Run the full thesis task: drive the two-agent loop to research the company AS
-* OF the cutoff, then synthesize + write the thesis page. Returns the loop result
-* + the thesis text + the page path. The caller grades the KB with
-* `materialFactsSurfaced(root, checklist)` — the checklist is never passed here.
-*/
-async function runInvestmentThesisTask(input, options) {
-	const worker = createWebResearchWorker({
-		...options.workerOptions,
-		router: options.router
-	});
-	const goal = `${input.company} (${input.ticker}) investment thesis as of ${input.cutoff}`;
-	const loop = await runVerifiedResearchLoop({
-		root: options.root,
-		goal,
-		worker,
-		driver: options.driver,
-		readinessSpecs: thesisReadinessSpecs(input),
-		maxRounds: options.maxRounds ?? 3,
-		signal: options.signal
-	});
-	const messages = thesisSynthesisMessages(input, kbIndexToText(await buildKnowledgeIndex(options.root)));
-	const thesis = await options.router.chat(messages, options.synthesisMaxTokens ?? 1600);
+function hitFromSearchResult(result) {
 	return {
-		loop,
-		thesis,
-		thesisPath: await writeThesisPage(options.root, input, thesis)
+		pageId: result.page.id,
+		path: result.page.path,
+		title: result.page.title,
+		rank: result.rank,
+		score: result.score,
+		normalizedScore: result.normalizedScore,
+		sourceIds: result.page.sourceIds,
+		snippet: result.snippet
 	};
 }
 //#endregion
@@ -7398,227 +5201,6 @@ async function evaluateKnowledgeBaseReadiness(options) {
 	};
 }
 //#endregion
-//#region src/relation-graph.ts
-/** A relation graph input or query that cannot be honored exactly. */
-var KnowledgeRelationGraphError = class extends Error {
-	code;
-	constructor(code, message) {
-		super(message);
-		this.name = "KnowledgeRelationGraphError";
-		this.code = code;
-	}
-};
-/**
-* Build a labeled multi-edge graph from caller relations.
-*
-* The graph keeps one edge per `(sourceId, targetId, predicate)`, in first-seen
-* order. A repeated triple is accepted only when its weight and metadata are
-* identical in canonical JSON; any other repeat is a conflict and is refused.
-* Node and relation metadata must be finite, acyclic JSON so the graph
-* round-trips through `KnowledgeRelationGraphSchema` unchanged.
-*/
-function buildKnowledgeRelationGraph(input) {
-	const declared = input.nodes === void 0 ? void 0 : /* @__PURE__ */ new Map();
-	const nodes = [];
-	if (declared !== void 0) for (const [position, node] of input.nodes.entries()) {
-		const normalized = normalizeNode(node, position);
-		if (declared.has(normalized.id)) throw new KnowledgeRelationGraphError("duplicate-node", `node "${normalized.id}" is declared more than once`);
-		declared.set(normalized.id, normalized);
-		nodes.push(normalized);
-	}
-	const edges = [];
-	const canonicalByTriple = /* @__PURE__ */ new Map();
-	for (const [position, relation] of input.relations.entries()) {
-		const normalized = normalizeRelation(relation, position);
-		if (declared !== void 0) {
-			for (const endpoint of [normalized.sourceId, normalized.targetId]) if (!declared.has(endpoint)) throw new KnowledgeRelationGraphError("undeclared-endpoint", `relation ${describeTriple(normalized)} names undeclared node "${endpoint}"`);
-		}
-		const canonical = canonicalRelationJson(normalized);
-		const key = tripleKey(normalized);
-		const prior = canonicalByTriple.get(key);
-		if (prior !== void 0) {
-			if (prior === canonical) continue;
-			throw new KnowledgeRelationGraphError("duplicate-relation", `relation ${describeTriple(normalized)} is repeated with different weight or metadata`);
-		}
-		canonicalByTriple.set(key, canonical);
-		edges.push(normalized);
-	}
-	return {
-		nodes,
-		edges
-	};
-}
-/** Relations touching `id`, each with the node at the other end, in graph order. */
-function neighbors(graph, id, query) {
-	const index = indexOf(graph);
-	validateQuery(query);
-	assertKnownNode(index, id);
-	return neighborsOf(index, id, query);
-}
-/**
-* Breadth-first traversal from `id` over matching relations. Each reachable
-* node is reported once, at the depth where the search first reached it; the
-* start node is never reported, so a cycle back to it adds no step.
-*/
-function walk(graph, id, options) {
-	const index = indexOf(graph);
-	validateQuery(options);
-	validateMaxDepth(options.maxDepth);
-	assertKnownNode(index, id);
-	const steps = [];
-	for (const step of traverse(index, id, options, options.maxDepth)) steps.push(step);
-	return steps;
-}
-/**
-* Whether `to` is `from` or lies on a path of matching relations out of `from`.
-*/
-function isReachable(graph, from, to, query) {
-	const index = indexOf(graph);
-	validateQuery(query);
-	assertKnownNode(index, from);
-	assertKnownNode(index, to);
-	if (from === to) return true;
-	for (const step of traverse(index, from, query, void 0)) if (step.nodeId === to) return true;
-	return false;
-}
-const indexes = /* @__PURE__ */ new WeakMap();
-function indexOf(graph) {
-	const cached = indexes.get(graph);
-	if (cached !== void 0) return cached;
-	const outgoing = /* @__PURE__ */ new Map();
-	const incoming = /* @__PURE__ */ new Map();
-	const known = /* @__PURE__ */ new Set();
-	for (const node of graph.nodes) known.add(node.id);
-	for (const relation of graph.edges) {
-		known.add(relation.sourceId);
-		known.add(relation.targetId);
-		push(outgoing, relation.sourceId, relation);
-		push(incoming, relation.targetId, relation);
-	}
-	const index = {
-		outgoing,
-		incoming,
-		known
-	};
-	indexes.set(graph, index);
-	return index;
-}
-function push(map, key, relation) {
-	const list = map.get(key);
-	if (list === void 0) map.set(key, [relation]);
-	else list.push(relation);
-}
-function neighborsOf(index, id, query) {
-	const matches = (relation) => query.predicate === void 0 || relation.predicate === query.predicate;
-	const result = [];
-	if (query.direction !== "in") {
-		for (const relation of index.outgoing.get(id) ?? []) if (matches(relation)) result.push({
-			nodeId: relation.targetId,
-			relation
-		});
-	}
-	if (query.direction !== "out") for (const relation of index.incoming.get(id) ?? []) {
-		if (query.direction === "both" && relation.sourceId === id) continue;
-		if (matches(relation)) result.push({
-			nodeId: relation.sourceId,
-			relation
-		});
-	}
-	return result;
-}
-function* traverse(index, start, query, maxDepth) {
-	const visited = /* @__PURE__ */ new Set([start]);
-	const queue = [{
-		nodeId: start,
-		depth: 0
-	}];
-	for (let head = 0; head < queue.length; head++) {
-		const current = queue[head];
-		if (maxDepth !== void 0 && current.depth >= maxDepth) continue;
-		for (const neighbor of neighborsOf(index, current.nodeId, query)) {
-			if (visited.has(neighbor.nodeId)) continue;
-			visited.add(neighbor.nodeId);
-			const depth = current.depth + 1;
-			yield {
-				nodeId: neighbor.nodeId,
-				depth,
-				from: current.nodeId,
-				relation: neighbor.relation
-			};
-			queue.push({
-				nodeId: neighbor.nodeId,
-				depth
-			});
-		}
-	}
-}
-function assertKnownNode(index, id) {
-	if (!index.known.has(id)) throw new KnowledgeRelationGraphError("unknown-node", `node "${id}" is not in the graph`);
-}
-function validateQuery(query) {
-	if (query.direction !== "out" && query.direction !== "in" && query.direction !== "both") throw new KnowledgeRelationGraphError("invalid-query", `direction must be "out", "in", or "both", got ${JSON.stringify(query.direction)}`);
-	if (query.predicate !== void 0 && !isNonEmptyString(query.predicate)) throw new KnowledgeRelationGraphError("invalid-query", "predicate must be a non-empty string");
-}
-function validateMaxDepth(maxDepth) {
-	if (maxDepth === void 0) return;
-	if (!Number.isInteger(maxDepth) || maxDepth < 0) throw new KnowledgeRelationGraphError("invalid-query", `maxDepth must be a non-negative integer, got ${JSON.stringify(maxDepth)}`);
-}
-function normalizeNode(node, position) {
-	if (!isNonEmptyString(node.id)) throw new KnowledgeRelationGraphError("invalid-node", `node at ${position} has no id`);
-	if (!isNonEmptyString(node.kind)) throw new KnowledgeRelationGraphError("invalid-node", `node "${node.id}" has no kind`);
-	if (node.label !== void 0 && typeof node.label !== "string") throw new KnowledgeRelationGraphError("invalid-node", `node "${node.id}" label is not a string`);
-	if (node.metadata !== void 0) assertCanonicalMetadata(node.metadata, `node "${node.id}"`, "invalid-node");
-	return {
-		id: node.id,
-		kind: node.kind,
-		...node.label !== void 0 ? { label: node.label } : {},
-		...node.metadata !== void 0 ? { metadata: node.metadata } : {}
-	};
-}
-function normalizeRelation(relation, position) {
-	for (const field of [
-		"sourceId",
-		"targetId",
-		"predicate"
-	]) if (!isNonEmptyString(relation[field])) throw new KnowledgeRelationGraphError("invalid-relation", `relation at ${position} has no ${field}`);
-	if (relation.weight !== void 0 && !Number.isFinite(relation.weight)) throw new KnowledgeRelationGraphError("invalid-relation", `relation ${describeTriple(relation)} weight must be a finite number`);
-	return {
-		sourceId: relation.sourceId,
-		targetId: relation.targetId,
-		predicate: relation.predicate,
-		...relation.weight !== void 0 ? { weight: relation.weight } : {},
-		...relation.metadata !== void 0 ? { metadata: relation.metadata } : {}
-	};
-}
-function canonicalRelationJson(relation) {
-	if (relation.metadata !== void 0) assertCanonicalMetadata(relation.metadata, `relation ${describeTriple(relation)}`, "invalid-relation");
-	return canonicalCandidateJson({
-		...relation.weight !== void 0 ? { weight: relation.weight } : {},
-		...relation.metadata !== void 0 ? { metadata: relation.metadata } : {}
-	});
-}
-function assertCanonicalMetadata(metadata, subject, code) {
-	if (metadata === null || typeof metadata !== "object" || Array.isArray(metadata)) throw new KnowledgeRelationGraphError(code, `${subject} metadata must be an object`);
-	try {
-		canonicalCandidateJson(metadata);
-	} catch (error) {
-		throw new KnowledgeRelationGraphError(code, `${subject} metadata must be finite, acyclic JSON: ${error instanceof Error ? error.message : String(error)}`);
-	}
-}
-function tripleKey(relation) {
-	return JSON.stringify([
-		relation.sourceId,
-		relation.targetId,
-		relation.predicate
-	]);
-}
-function describeTriple(relation) {
-	return `${relation.sourceId} -[${relation.predicate}]-> ${relation.targetId}`;
-}
-function isNonEmptyString(value) {
-	return typeof value === "string" && value.length > 0;
-}
-//#endregion
 //#region src/release.ts
 function knowledgeReleaseReport(input) {
 	const baselineRuns = input.baselineRuns ?? [];
@@ -7655,680 +5237,6 @@ function knowledgeReleaseReport(input) {
 	};
 }
 //#endregion
-//#region src/research-driving-driver.ts
-/**
-* 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, `claim-ledger.ts` (claim identity, independent-source identity, and
-* the merge rule), and the `RouterClient` chat surface; it reinvents none of
-* them.
-*/
-/**
-* The in-memory driver. Its belief state lives for exactly as long as the
-* process does — use `createPersistentResearchDrivingDriver` when the run must
-* survive a crash or resume.
-*/
-function createResearchDrivingDriver(options = {}) {
-	return buildDriver(options);
-}
-/**
-* The durable driver: same behaviour, plus its claim ledger is read from the
-* store at construction and written back after every claim and every round.
-*
-* Construction is asynchronous because loading is I/O, and loading has to happen
-* before the caller can read `researchState()` or `isComplete()` — a driver that
-* loaded lazily would answer "nothing researched, not complete" for a run that
-* had already corroborated everything.
-*/
-async function createPersistentResearchDrivingDriver(options) {
-	const ledgerId = assertClaimLedgerId(options.ledgerId);
-	const existing = await options.store.getClaimLedger(ledgerId);
-	const driver = buildDriver(options, {
-		store: options.store,
-		ledgerId
-	}, existing ?? void 0);
-	if (existing && (existing.preparedRounds ?? existing.rounds) > existing.rounds) await driver.checkpoint();
-	return driver;
-}
-function buildDriver(options, persistence, restored) {
-	const minIndependentSources = Math.max(2, options.minIndependentSources ?? 2);
-	const maxQuestionsPerRound = Math.max(1, options.maxQuestionsPerRound ?? 6);
-	const maxClaimsPerSource = Math.max(1, options.maxClaimsPerSource ?? 3);
-	const deterministicFallback = options.deterministicFallback ?? true;
-	const claims = new Map((restored?.claims ?? []).map((claim) => [claim.id, fromRecord(claim)]));
-	const claimEvidence = new Map((restored?.claimEvidence ?? []).map((evidence) => [evidence.id, evidence]));
-	const registeredSources = new Map((restored?.registeredSources ?? []).map((source) => [source.sourceId, source]));
-	const questions = new Map((restored?.questions ?? []).map((question) => [question.id, question]));
-	let rounds = restored?.rounds ?? 0;
-	let preparedRounds = Math.max(rounds, restored?.preparedRounds ?? rounds);
-	let goal = restored?.goal;
-	let lastSteer;
-	if (preparedRounds > rounds) {
-		for (let round = rounds + 1; round <= preparedRounds; round += 1) for (const question of synthesizeDeepQuestions([...claims.values()], round).slice(0, maxQuestionsPerRound)) if (!questions.has(question.id)) questions.set(question.id, question);
-		rounds = preparedRounds;
-	}
-	function toLedger() {
-		return {
-			schemaVersion: 2,
-			id: persistence?.ledgerId ?? "in-memory",
-			...goal === void 0 ? {} : { goal },
-			updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			rounds,
-			...preparedRounds > rounds ? { preparedRounds } : {},
-			claimEvidence: [...claimEvidence.values()].sort((left, right) => left.id.localeCompare(right.id)),
-			registeredSources: [...registeredSources.values()].sort((left, right) => left.sourceId.localeCompare(right.sourceId)),
-			claims: [...claims.values()].map((claim) => ({
-				...claim,
-				supportingHosts: [...new Set(claim.supportingHosts)].sort(),
-				supportingUris: [...new Set(claim.supportingUris)].sort(),
-				contradicts: [...new Set(claim.contradicts)].sort()
-			})).sort((a, b) => a.id.localeCompare(b.id)),
-			questions: [...questions.values()].map((question) => ({
-				...question,
-				claimIds: [...new Set(question.claimIds)].sort()
-			})).sort((a, b) => a.id.localeCompare(b.id))
-		};
-	}
-	/**
-	* Write this driver's belief state into the stored ledger and adopt the
-	* result.
-	*
-	* It merges rather than overwrites, and then rehydrates from the merged
-	* record, which is the whole of what makes knowledge compound across
-	* workers. Two drivers on one ledger id — a resumed run beside a still-live
-	* one, or two workers researching one goal in parallel — would otherwise each
-	* write a whole record built from what it read before the other wrote, and
-	* the later write would erase the earlier writer's claims. Rehydrating means
-	* a claim another worker corroborated counts toward THIS driver's completion
-	* oracle from the next round onward.
-	*/
-	async function persist() {
-		if (!persistence) return;
-		const mine = toLedger();
-		const merged = await persistence.store.mergeClaimLedger(persistence.ledgerId, (current) => current === null ? mine : mergeClaimLedgers(current, mine));
-		claims.clear();
-		for (const claim of merged.claims) claims.set(claim.id, fromRecord(claim));
-		claimEvidence.clear();
-		for (const evidence of merged.claimEvidence) claimEvidence.set(evidence.id, evidence);
-		registeredSources.clear();
-		for (const source of merged.registeredSources) registeredSources.set(source.sourceId, source);
-		questions.clear();
-		for (const question of merged.questions) questions.set(question.id, question);
-		rounds = Math.max(rounds, merged.rounds);
-		preparedRounds = Math.max(rounds, merged.preparedRounds ?? merged.rounds);
-		goal = merged.goal ?? goal;
-	}
-	async function prepareFold() {
-		if (!persistence) return;
-		preparedRounds = Math.max(preparedRounds, rounds + 1);
-		await persist();
-	}
-	/**
-	* A ledger accumulates evidence FOR a goal. Reusing one id across two goals
-	* merges two runs' beliefs into one corroboration count, which is worse than
-	* losing them, so it fails rather than merging.
-	*/
-	function bindGoal(nextGoal) {
-		if (goal === void 0) {
-			goal = nextGoal;
-			return;
-		}
-		if (goal !== nextGoal) throw new Error(`claim ledger '${persistence?.ledgerId ?? "in-memory"}' accumulated evidence for goal '${goal}' and cannot be reused for '${nextGoal}'`);
-	}
-	function resolveRouter(signal) {
-		if (options.router) return options.router;
-		const configuredSignal = options.router_options?.signal;
-		const requestSignal = configuredSignal && signal ? AbortSignal.any([configuredSignal, signal]) : configuredSignal ?? signal;
-		return createTangleRouterClient({
-			...options.router_options,
-			signal: requestSignal
-		});
-	}
-	function throwIfRouterAborted(signal) {
-		signal?.throwIfAborted();
-		if (!options.router) options.router_options?.signal?.throwIfAborted();
-	}
-	/** Record a claim from a source, growing its independent-source support. */
-	function recordClaim(extracted, sourceUri, round) {
-		const id = claimId(extracted.text);
-		const host = claimSourceHost(sourceUri);
-		const existing = claims.get(id);
-		if (existing) {
-			if (host) existing.supportingHosts.add(host);
-			addUnique(existing.supportingUris, sourceUri);
-			linkContradiction(existing, extracted.contradictsExistingId);
-			return existing;
-		}
-		const tracked = {
-			id,
-			text: extracted.text.trim(),
-			supportingHosts: new Set(host ? [host] : []),
-			supportingUris: [sourceUri],
-			contradicts: /* @__PURE__ */ new Set(),
-			contested: false,
-			firstSeenRound: round
-		};
-		linkContradiction(tracked, extracted.contradictsExistingId);
-		claims.set(id, tracked);
-		return tracked;
-	}
-	/** Persist an extraction observation without treating its source as registered. */
-	function recordEvidence(extracted, sourceVersion, round) {
-		const text = extracted.text.trim();
-		const observedClaimId = claimId(text);
-		const contradictsClaimId = extracted.contradictsExistingId === observedClaimId ? void 0 : extracted.contradictsExistingId;
-		const evidence = {
-			id: claimEvidenceId({
-				claimId: observedClaimId,
-				sourceId: sourceVersion.sourceId,
-				sourceUri: sourceVersion.uri,
-				sourceContentHash: sourceVersion.contentHash,
-				contradictsClaimId
-			}),
-			claimId: observedClaimId,
-			text,
-			sourceId: sourceVersion.sourceId,
-			sourceUri: sourceVersion.uri,
-			sourceContentHash: sourceVersion.contentHash,
-			...contradictsClaimId === void 0 ? {} : { contradictsClaimId },
-			firstSeenRound: round
-		};
-		const existing = claimEvidence.get(evidence.id);
-		if (!existing) {
-			claimEvidence.set(evidence.id, evidence);
-			return evidence;
-		}
-		const merged = {
-			...evidence.firstSeenRound < existing.firstSeenRound || evidence.firstSeenRound === existing.firstSeenRound && evidence.text < existing.text ? evidence : existing,
-			firstSeenRound: Math.min(existing.firstSeenRound, evidence.firstSeenRound)
-		};
-		claimEvidence.set(merged.id, merged);
-		return merged;
-	}
-	/** Materialize evidence for newly confirmed exact source versions into live claims. */
-	function materializeEvidenceFor(sourceVersions) {
-		const evidence = [...claimEvidence.values()].filter((item) => sourceVersions.has(sourceVersionKeyOfEvidence(item)));
-		const texts = [];
-		for (const item of evidence) {
-			recordClaim({
-				text: item.text,
-				contradictsExistingId: item.contradictsClaimId
-			}, item.sourceUri, item.firstSeenRound);
-			texts.push(item.text);
-		}
-		for (const item of evidence) {
-			const claim = claims.get(item.claimId);
-			if (claim) linkContradiction(claim, item.contradictsClaimId);
-		}
-		return texts;
-	}
-	async function commitSources(sources) {
-		const versions = sources.map(sourceVersionOfRecord);
-		const nextRegistered = new Map(registeredSources);
-		const newlyRegistered = /* @__PURE__ */ new Set();
-		for (const version of versions) {
-			const key = researchSourceVersionKey(version);
-			const existing = nextRegistered.get(version.sourceId);
-			if (existing && researchSourceVersionKey(existing) !== key) throw new Error(`registered source '${version.sourceId}' has conflicting immutable content`);
-			if (existing) continue;
-			nextRegistered.set(version.sourceId, version);
-			newlyRegistered.add(key);
-		}
-		registeredSources.clear();
-		for (const [sourceId, version] of nextRegistered) registeredSources.set(sourceId, version);
-		if (newlyRegistered.size > 0) markAddressed(materializeEvidenceFor(newlyRegistered));
-		await persist();
-	}
-	/** Wire a bidirectional contradiction edge and mark BOTH claims contested. */
-	function linkContradiction(claim, otherId) {
-		if (!otherId || otherId === claim.id) return;
-		const other = claims.get(otherId);
-		if (!other) return;
-		claim.contradicts.add(otherId);
-		other.contradicts.add(claim.id);
-		claim.contested = true;
-		other.contested = true;
-	}
-	/** A claim's independent-source count = distinct canonical hosts. */
-	function independentSupport(claim) {
-		return claim.supportingHosts.size;
-	}
-	function isCorroborated(claim) {
-		return independentSupport(claim) >= minIndependentSources;
-	}
-	/** Weakly-supported = NOT corroborated AND NOT contested → an invalidation target. */
-	function isWeak(claim) {
-		return !isCorroborated(claim) && !claim.contested;
-	}
-	function snapshot() {
-		const all = [...claims.values()];
-		const allQuestions = [...questions.values()];
-		return {
-			claims: all,
-			questions: allQuestions,
-			weaklySupported: all.filter(isWeak),
-			corroborated: all.filter(isCorroborated),
-			contested: all.filter((claim) => claim.contested),
-			openQuestions: allQuestions.filter((question) => !question.addressed),
-			rounds
-		};
-	}
-	/**
-	* Mark deep questions addressed when later evidence speaks to them. A question
-	* is addressed once a NEW claim's text shares enough content words with the
-	* question — i.e. the worker brought back evidence on the thing we asked about.
-	* Cheap and deterministic; the LLM is reserved for GENERATING questions, not
-	* grading them, so the oracle stays a non-model check.
-	*/
-	function markAddressed(newClaimTexts) {
-		for (const question of questions.values()) {
-			if (question.addressed) continue;
-			if (question.kind === "contradiction") {
-				if (question.claimIds.some((id) => {
-					const claim = claims.get(id);
-					return claim ? isCorroborated(claim) || claim.contested : false;
-				})) question.addressed = true;
-				continue;
-			}
-			const qWords = contentWordSet(question.text);
-			if (qWords.size === 0) continue;
-			for (const text of newClaimTexts) if (overlapFraction(qWords, contentWordSet(text)) >= .5) {
-				question.addressed = true;
-				break;
-			}
-		}
-	}
-	return {
-		/**
-		* `verifySource` — the per-source hook. This driver does NOT filter for
-		* relevance/dedup (other drivers do that, and the loop already dedups exact
-		* uris). Its job here is to EXTRACT the source's claims and grow the ledger.
-		* It accepts every source that yields at least one extractable claim; it
-		* only rejects a source with NO extractable signal at all (empty/unusable),
-		* because such a source cannot drive the research and pollutes the KB.
-		*/
-		async verifySource(source, ctx) {
-			throwIfRouterAborted(ctx.signal);
-			const sourceSnapshot = snapshotSourceTextInput(source);
-			const goalSnapshot = ctx.goal;
-			const roundSnapshot = ctx.round;
-			const sourceVersion = sourceVersionOfProposal(sourceSnapshot);
-			bindGoal(goalSnapshot);
-			const extracted = await extractClaims(sourceSnapshot, goalSnapshot, ctx.signal);
-			throwIfRouterAborted(ctx.signal);
-			if (extracted.length === 0) return {
-				accept: false,
-				reason: "no extractable claim: source yields nothing to drive the research deeper"
-			};
-			for (const claim of extracted) recordEvidence(claim, sourceVersion, roundSnapshot);
-			if (!persistence) {
-				const key = researchSourceVersionKey(sourceVersion);
-				registeredSources.set(sourceVersion.sourceId, sourceVersion);
-				markAddressed(materializeEvidenceFor(/* @__PURE__ */ new Set([key])));
-			} else {
-				const registered = registeredSources.get(sourceVersion.sourceId);
-				if (registered && researchSourceVersionKey(registered) === researchSourceVersionKey(sourceVersion)) markAddressed(materializeEvidenceFor(/* @__PURE__ */ new Set([researchSourceVersionKey(sourceVersion)])));
-			}
-			await persist();
-			throwIfRouterAborted(ctx.signal);
-			return { accept: true };
-		},
-		/**
-		* `foldGaps` — the DEPTH driver. Runs after the worker's contribution is
-		* applied each round. It builds the next round's steer from (1) the readiness
-		* gaps the loop still reports, (2) freshly generated DEEP sub-questions, and
-		* (3) INVALIDATION challenges for weakly-supported / contradicted claims.
-		*/
-		foldGaps(gaps) {
-			if (persistence && preparedRounds <= rounds) throw new Error("persistent research driver must prepareFold before foldGaps");
-			rounds += 1;
-			const round = rounds;
-			const ledger = [...claims.values()];
-			const invalidationTargets = ledger.filter((claim) => isWeak(claim) || claim.contradicts.size > 0);
-			const deepQuestions = synthesizeDeepQuestions(ledger, round).slice(0, maxQuestionsPerRound);
-			for (const question of deepQuestions) if (!questions.has(question.id)) questions.set(question.id, question);
-			const text = buildSteerText(gaps, deepQuestions, invalidationTargets, minIndependentSources);
-			lastSteer = {
-				round,
-				deepQuestions,
-				invalidationTargets,
-				gaps,
-				text
-			};
-			options.onSteer?.(lastSteer);
-			return text;
-		},
-		researchState: snapshot,
-		isComplete() {
-			const all = [...claims.values()];
-			if (all.length === 0) return false;
-			const everyClaimSettled = all.every((claim) => isCorroborated(claim) || claim.contested);
-			const everyQuestionAddressed = [...questions.values()].every((question) => question.addressed);
-			return everyClaimSettled && everyQuestionAddressed;
-		},
-		lastSteer() {
-			return lastSteer;
-		},
-		checkpoint: persist,
-		prepareFold,
-		commitSources,
-		toLedger
-	};
-	async function extractClaims(source, goal, signal) {
-		const fromLlm = await extractClaimsWithLlm(source, goal, claimsForExtraction(), signal);
-		throwIfRouterAborted(signal);
-		if (fromLlm.length > 0) return fromLlm.slice(0, maxClaimsPerSource);
-		if (deterministicFallback) return deterministicClaims(source).slice(0, maxClaimsPerSource);
-		return [];
-	}
-	function claimsForExtraction() {
-		const known = new Map(claims);
-		for (const evidence of claimEvidence.values()) {
-			if (known.has(evidence.claimId)) continue;
-			known.set(evidence.claimId, {
-				id: evidence.claimId,
-				text: evidence.text,
-				supportingHosts: /* @__PURE__ */ new Set(),
-				supportingUris: [],
-				contradicts: /* @__PURE__ */ new Set(),
-				contested: false,
-				firstSeenRound: evidence.firstSeenRound
-			});
-		}
-		return [...known.values()];
-	}
-	async function extractClaimsWithLlm(source, goal, ledger, signal) {
-		let router;
-		try {
-			router = resolveRouter(signal);
-		} catch (error) {
-			throwIfRouterAborted(signal);
-			if (error?.name === "AbortError") throw error;
-			return [];
-		}
-		const excerpt = source.text.slice(0, 1800);
-		const ledgerLines = ledger.slice(0, 20).map((claim) => `- [${claim.id}] ${claim.text}`).join("\n");
-		const system = `You extract the KEY factual claims a researcher would cite a page for, and flag CONTRADICTIONS with claims already on the ledger. A claim is one concrete, checkable assertion using the page's own terms and numbers. Return ONLY a JSON array; each item is {"claim": string, "contradicts": string|null} where contradicts is the bracketed [id] of a ledger claim this page DIRECTLY contradicts, else null. Return at most ${maxClaimsPerSource} claims. No prose.`;
-		const user = [
-			`Research goal: ${goal}`,
-			`Page title: ${source.title ?? "(none)"}`,
-			ledgerLines ? `Claims already on the ledger:\n${ledgerLines}` : "Ledger is empty.",
-			`Page excerpt:\n${excerpt}`,
-			"Key claims as JSON [{\"claim\": \"...\", \"contradicts\": \"[id]\"|null}]:"
-		].join("\n\n");
-		let raw = "";
-		try {
-			raw = await router.chat([{
-				role: "system",
-				content: system
-			}, {
-				role: "user",
-				content: user
-			}], 1200);
-		} catch (error) {
-			throwIfRouterAborted(signal);
-			if (error?.name === "AbortError") throw error;
-			return [];
-		}
-		throwIfRouterAborted(signal);
-		return parseExtractedClaims(raw, ledger);
-	}
-	/**
-	* Deterministic fallback: pull the leading sentences as candidate claims. Used
-	* only when the model is unavailable, so the driver still drives (and the
-	* offline test runs with no creds). Each sentence becomes a checkable claim.
-	*/
-	function deterministicClaims(source) {
-		return source.text.split(/(?<=[.!?])\s+/).map((sentence) => sentence.trim()).filter((sentence) => contentWordSet(sentence).size >= 3).slice(0, maxClaimsPerSource).map((text) => ({ text }));
-	}
-	/**
-	* Build the four deep-question kinds from the actual ledger claims. This is
-	* intentionally deterministic (not an LLM call): the loop's `foldGaps` contract
-	* is synchronous (`foldGaps(gaps): string`), and a template grounded in the
-	* real claim text gives a faithful, non-fabricated sub-question every round —
-	* comparative, mechanism, gap, and contradiction. Claim EXTRACTION, which runs
-	* inside the awaited `verifySource`, is where the model does the open-ended
-	* work; question generation just interrogates what was extracted.
-	*/
-	function synthesizeDeepQuestions(ledger, round) {
-		if (ledger.length === 0) return [];
-		const out = [];
-		for (const claim of ledger) for (const otherId of claim.contradicts) {
-			const other = ledger.find((entry) => entry.id === otherId);
-			if (!other || other.id < claim.id) continue;
-			out.push(makeQuestion("contradiction", `Does any independent source resolve the contradiction between "${truncate(claim.text)}" and "${truncate(other.text)}"? Find evidence that confirms or refutes one of them.`, [claim.id, other.id], round));
-		}
-		for (const claim of ledger.filter((entry) => !entry.contested)) if (claim.supportingHosts.size < minIndependentSources) out.push(makeQuestion("gap", `Only one independent source supports "${truncate(claim.text)}". What specific corroborating result, dataset, or independent measurement is missing to confirm it?`, [claim.id], round));
-		for (const claim of [...ledger].sort((a, b) => b.supportingHosts.size - a.supportingHosts.size).slice(0, 2)) out.push(makeQuestion("mechanism", `Under what precise condition does "${truncate(claim.text)}" stop holding? Find a source that states the mechanism, limit, or failure mode.`, [claim.id], round));
-		const ranked = [...ledger].sort((a, b) => b.supportingHosts.size - a.supportingHosts.size);
-		if (ranked.length >= 2 && ranked[0] && ranked[1]) out.push(makeQuestion("comparative", `How does the tradeoff in "${truncate(ranked[0].text)}" differ from "${truncate(ranked[1].text)}"? Find a source that compares them directly.`, [ranked[0].id, ranked[1].id], round));
-		const priority = {
-			contradiction: 0,
-			gap: 1,
-			mechanism: 2,
-			comparative: 3
-		};
-		return out.sort((a, b) => priority[a.kind] - priority[b.kind]);
-	}
-}
-function sourceVersionOfProposal(source) {
-	const contentHash = sha256(source.text);
-	return {
-		sourceId: textSourceId(source.uri, contentHash),
-		uri: source.uri,
-		contentHash
-	};
-}
-function sourceVersionOfRecord(source) {
-	const originalUri = source.metadata?.originalUri;
-	if (typeof originalUri !== "string" || originalUri.length === 0) throw new Error(`registered source '${source.id}' has no originalUri`);
-	if (!/^[a-f0-9]{64}$/.test(source.contentHash)) throw new Error(`registered source '${source.id}' contentHash is not a SHA-256 digest`);
-	const expectedSourceId = textSourceId(originalUri, source.contentHash);
-	if (source.id !== expectedSourceId) throw new Error(`registered source '${source.id}' does not match URI-and-content identity '${expectedSourceId}'`);
-	return {
-		sourceId: source.id,
-		uri: originalUri,
-		contentHash: source.contentHash
-	};
-}
-function sourceVersionKeyOfEvidence(evidence) {
-	return researchSourceVersionKey({
-		sourceId: evidence.sourceId,
-		uri: evidence.sourceUri,
-		contentHash: evidence.sourceContentHash
-	});
-}
-function makeQuestion(kind, text, claimIds, raisedRound) {
-	return {
-		kind,
-		text,
-		id: deepQuestionId(kind, text),
-		claimIds: [...new Set(claimIds)].sort(),
-		addressed: false,
-		raisedRound
-	};
-}
-function fromRecord(claim) {
-	return {
-		...claim,
-		supportingHosts: new Set(claim.supportingHosts),
-		supportingUris: [...claim.supportingUris],
-		contradicts: new Set(claim.contradicts)
-	};
-}
-/**
-* Set-like insert into the array form. The ledger's collections are arrays so
-* they survive `JSON.stringify`; dedup is enforced here instead of by the type.
-*/
-function addUnique(values, value) {
-	if (!values.includes(value)) values.push(value);
-}
-const stopwords = /* @__PURE__ */ new Set([
-	"the",
-	"a",
-	"an",
-	"and",
-	"or",
-	"but",
-	"of",
-	"to",
-	"in",
-	"on",
-	"for",
-	"with",
-	"as",
-	"by",
-	"at",
-	"from",
-	"that",
-	"this",
-	"these",
-	"those",
-	"it",
-	"its",
-	"is",
-	"are",
-	"was",
-	"were",
-	"be",
-	"been",
-	"being",
-	"has",
-	"have",
-	"had",
-	"can",
-	"will",
-	"would",
-	"should",
-	"may",
-	"might",
-	"not",
-	"no",
-	"than",
-	"then",
-	"over",
-	"under",
-	"about",
-	"into",
-	"their",
-	"they",
-	"them"
-]);
-function contentWordSet(text) {
-	return new Set(normalizeClaimText(text).split(" ").filter((word) => word.length >= 3 && !stopwords.has(word)));
-}
-function overlapFraction(a, b) {
-	if (a.size === 0) return 0;
-	let hits = 0;
-	for (const word of a) if (b.has(word)) hits += 1;
-	return hits / a.size;
-}
-function truncate(text, max = 140) {
-	const t = text.trim().replace(/\s+/g, " ");
-	return t.length <= max ? t : `${t.slice(0, max - 1)}…`;
-}
-/**
-* Parse the extractor's JSON array of `{claim, contradicts}` items, tolerant of
-* code fences / surrounding prose. `contradicts` is mapped from a `[id]` token to
-* a ledger claim id only when that id is actually on the ledger.
-*/
-function parseExtractedClaims(raw, ledger) {
-	const text = raw.trim();
-	if (!text) return [];
-	const arrayMatch = text.match(/\[[\s\S]*\]/);
-	if (!arrayMatch) return [];
-	let parsed;
-	try {
-		parsed = JSON.parse(arrayMatch[0]);
-	} catch {
-		return [];
-	}
-	if (!Array.isArray(parsed)) return [];
-	const ledgerIds = new Set(ledger.map((claim) => claim.id));
-	const out = [];
-	for (const item of parsed) {
-		if (!item || typeof item !== "object") continue;
-		const record = item;
-		if (typeof record.claim !== "string" || !record.claim.trim()) continue;
-		const contradictsId = extractBracketId(record.contradicts);
-		out.push({
-			text: record.claim.trim(),
-			contradictsExistingId: contradictsId && ledgerIds.has(contradictsId) ? contradictsId : void 0
-		});
-	}
-	return out;
-}
-/** Pull a ledger id out of a `contradicts` field: `"[c_abc]"` or `"c_abc"`. */
-function extractBracketId(value) {
-	if (typeof value !== "string") return void 0;
-	const trimmed = value.trim();
-	if (!trimmed || trimmed.toLowerCase() === "null") return void 0;
-	const id = (trimmed.match(/\[([^\]]+)\]/)?.[1] ?? trimmed).trim();
-	return id.startsWith("c_") ? id : void 0;
-}
-/**
-* Build the steer string handed to the worker's next prompt. Interleaves the
-* readiness gaps the loop still reports with the deep sub-questions and the
-* invalidation challenges — the part that drives DEPTH + VALIDATION.
-*/
-function buildSteerText(gaps, deepQuestions, invalidationTargets, minIndependentSources) {
-	const lines = [];
-	lines.push("Do NOT just add more sources. Go DEEPER and VALIDATE. Address the following before adding breadth:");
-	if (deepQuestions.length > 0) {
-		lines.push("", "Deep sub-questions to answer this round:");
-		for (const question of deepQuestions) lines.push(`- (${question.kind}) ${question.text}`);
-	}
-	if (invalidationTargets.length > 0) {
-		lines.push("", `Claims needing corroboration or refutation (each must reach >= ${minIndependentSources} INDEPENDENT sources, or be shown contested):`);
-		for (const claim of invalidationTargets) {
-			const reason = claim.contradicts.size > 0 ? "CONTRADICTED by another source — find evidence that resolves it" : `only ${claim.supportingHosts.size} independent source — find a SECOND, independent corroborating source`;
-			lines.push(`- "${truncate(claim.text)}" — ${reason}`);
-		}
-	}
-	if (gaps.length > 0) {
-		lines.push("", "Readiness gaps still open:");
-		for (const gap of gaps) lines.push(`- (${gap.blocking ? "blocking" : "soft"}) ${gap.description} [${gap.id}]`);
-	}
-	return lines.join("\n");
-}
-//#endregion
-export { AgentMemoryHitSchema, AgentMemoryKindSchema, AgentMemoryLifecycleTimeoutError, AgentMemoryLifecycleUnsafeError, AgentMemoryScopeSchema, AgentMemoryWriteInputSchema, CHECKABLE_RUNG_THRESHOLD, CITES_INVALIDATED_FIELD, ClaimLedgerGoalConflictError, ClaimLedgerMigrationRequiredError, DEADLINE_EXIT_CODE, DEFAULT_KNOWLEDGE_BRIEF_LIMIT, DEFAULT_MEMORY_CLEANUP_TIMEOUT_MS, DEFAULT_PAGES_DIRECTORY, DeepQuestionSchema, FileSystemKbStore, FileSystemSearchProvider, HindsightOperationUnknownError, INDUSTRY_MEMORY_BENCHMARKS, INDUSTRY_RAG_BENCHMARKS, IRS_DIMENSION_HINTS, KB_CLAIM_LEDGER_DIR, KB_EVENTS_PATH, KB_INDEX_PATH, KB_STORE_DIR, KNOWLEDGE_EVENT_TYPES, KNOWLEDGE_PROMOTIONS_DIRECTORY, KNOWLEDGE_PROMOTION_DIGEST_ALGORITHM, KNOWLEDGE_PROMOTION_SCHEMA_VERSION, KNOWLEDGE_RECEIPT_DIGEST_ALGORITHM, KNOWLEDGE_SEARCH_RETRIEVER_ID, KNOWLEDGE_USE_RECEIPT_SCHEMA_VERSION, KnowledgeBaseCandidateSchema, KnowledgeCitationAuditError, KnowledgeCitationResolutionError, KnowledgeDuplicateIntakeError, KnowledgeEventSchema, KnowledgeGraphEdgeSchema, KnowledgeGraphNodeSchema, KnowledgeImprovementCandidateRefSchema, KnowledgeImprovementEvidenceSchema, KnowledgeImprovementRunStateSchema, KnowledgeIndexSchema, KnowledgePageInvalidationSchema, KnowledgePageSchema, KnowledgePromotionError, KnowledgeProposalParseError, KnowledgeRelationGraphError, KnowledgeRelationGraphSchema, KnowledgeRelationNodeSchema, KnowledgeRelationSchema, KnowledgeVisibilityUnavailableError, MAX_RESPONSE_BYTES, MIN_REQUEST_GAP_MS, MemoryKbStore, POLITE_USER_AGENT, READINESS_SPEC_DEFAULTS, RUN_LINEAGE_BASENAME, ResearchClaimEvidenceSchema, ResearchClaimLedgerSchema, ResearchClaimRecordSchema, ResearchSourceVersionSchema, RouterError, SCAFFOLD_PAGE_BASENAMES, SourceAnchorSchema, SourceRecordSchema, UncheckableClaimError, WIKILINK_REGEX, __resetHttpThrottle, acquireAgentMemoryRunLease, addSourcePath, addSourceText, agentMemorySequenceJudge, applyKnowledgeWriteBlocks, applyKnowledgeWriteBlocksFile, applyRetrievalHoldout, applySessionStickyRetrievalHoldout, assertClaimLedgerId, assertCurrentRunCitationsResolved, assertDeepQuestionIntegrity, assertGradeableEvidence, assertKnowledgeCitationAudit, assertKnowledgeCitationsResolved, assertKnowledgeRetrievalMatchesVisibility, assertKnowledgeRetrievalMatchesVisibilityArtifact, assertKnowledgeWriteIntake, assertResearchClaimEvidenceIntegrity, assertResearchClaimLedgerIntegrity, assertRunScopedCitationsResolved, assertTrackedClaimIntegrity, auditCurrentRunCitations, auditKnowledgeCitations, buildAgentMemorySequenceScenarios, buildAgentMemorySequencesFromBenchmarkCases, buildEvalKnowledgeBundle, buildFirstPartyMemoryLifecycleBenchmarkCases, buildIndustryMemoryBenchmarkSmokeCases, buildIndustryRagBenchmarkSmokeCases, buildKnowledgeBenchmarkScenarios, buildKnowledgeBrief, buildKnowledgeGraph, buildKnowledgeIndex, buildKnowledgeLexicalIndex, buildKnowledgeRelationGraph, buildRetrievalBenchmarkCasesFromQrels, buildRetrievalEvalDispatch, calibrateRagAnswerJudge, canonicalPathsEqual, canonicalRelativeWithinRoot, canonicalizeUrl, chunkMarkdown, citedClaimKey, citedClaimOf, claimCheckKey, claimEvidenceId, claimId, claimSourceHost, compareAgentMemoryLearning, contentKey, createAdaptiveResearchDriver, createAgentMemoryBranch, createClaimDecorator, createClaimGroundingVerifier, createCollectionResearchDriver, createCornellLiiSource, createD1FreshnessStoreStub, createFileRunLineageAuthority, createFileSystemFreshnessStore, createFileSystemSearchProvider, createGraphitiMemoryAdapter, createHindsightMemoryAdapter, createInMemoryBenchmarkAdapter, createIrsPublicationsSource, createKnowledgeControlLoopAdapter, createKnowledgeEvent, createKnowledgeRetrievalDisposition, createKnowledgeRetrievalReceipt, createKnowledgeTools, createKnowledgeUseReceipt, createKnowledgeVisibilitySnapshot, createLocalDiscoveryDispatcher, createMem0MemoryAdapter, createMemoryExecutionPool, createNeo4jAgentMemoryAdapter, createNoopMemoryBenchmarkAdapter, createPersistentResearchDrivingDriver, createPlayMemoryTools, createQmdKnowledgeTools, createQmdSearchProvider, createRagAnswerQualityHook, createResearchDrivingDriver, createRunScopedStores, createStateSosSource, createTangleRouterClient, createVerifyingResearchDriver, createWebResearchWorker, decodeKnowledgeVisibilitySnapshot, deepQuestionId, defaultGetMemoryContext, defineReadinessSpec, detectChanges, detectNearDuplicatePages, deterministicRng, diagnoseRagAnswerFailure, emitRetrievalHoldoutBypass, emptyClaimLedger, encodeKnowledgeVisibilitySnapshot, evaluateKnowledgeBaseReadiness, explainKnowledgeTarget, extractLinks, extractWikilinks, firstMatch, forkAgentMemoryBranchSnapshot, formatFrontmatter, formatKnowledgeCitationReference, formatKnowledgeInvalidationProposal, fromAgentCandidateKnowledgeRef, gradeClaims, gradeCompanyAgainstText, gradeFactAgainstText, gradeFor, graphitiMemoryAdapterIdentity, groundClaimInText, hashKnowledgeBase, hindsightMemoryBankId, htmlToText, improveKnowledgeBase, improveSelectedKnowledgeCandidate, initKnowledgeBase, innerHtmlById, inspectKnowledgeIndex, inspectPendingKnowledgeMutation, investmentThesisSet, isKernelAnchoredPath, isKnowledgeMemoryBenchmarkCase, isKnowledgeMutationHeld, isKnowledgePagePath, isMissingFile, isReachable, isSafeKnowledgePath, isScaffoldPath, jsonCandidateCodec, jsonObjectCandidateCodec, kbIndexToText, knowledgeBenchmarkJudge, knowledgeCitationAuditFindings, knowledgeImprovementCandidateRef, knowledgeImprovementRunDir, knowledgeImprovementRunId, knowledgePageDigest, knowledgePageFromMarkdown, knowledgePageRelations, knowledgeReleaseReport, knowledgeVisibilityArtifactRef, layoutFor, lensDistribution, linkClaimContradictions, lintCurrentRunCitations, lintKnowledgeIndex, listRegularFilesWithinRoot, loadKnowledgeImprovementActivationResult, loadKnowledgeImprovementEvents, loadKnowledgeImprovementState, loadKnowledgePages, loadKnowledgePromotionRecord, loadSourceRegistry, looksLikeBlockPage, materialFactsSurfaced, materialFactsSurfacedInText, materializeRegisteredClaimEvidence, mediaTypeFor, mem0MemoryAdapterIdentity, memoryHitToSourceRecord, memoryRecoveryDelayMs, memoryWriteResultToSourceRecord, mergeClaimLedgers, mergeTrackedClaims, neighbors, normalizeClaimText, normalizeExternalRagScores, normalizeKnowledgeStateScope, normalizeLinkTarget, normalizePageText, normalizePagesDirectory, optimizeKnowledgeBasePolicy, originatedPages, parseFrontmatter, parseKnowledgeBenchmarkJsonl, parseKnowledgeBenchmarkQrels, parseKnowledgeCitationReference, parseKnowledgeWriteBlocks, partitionRetrievalScenarios, planInvalidationPropagation, politeFetch, promoteKnowledgeCandidate, promoteRunScopedPages, proposeFromFinding, proposeFromFindings, ragAnswerQualityJudge, readRegularFileNoFollow, readRegularFileWithinRoot, reciprocalRankFusion, recoverPendingKnowledgeMutation, relativeWithinRoot, removeDurable, renameDurable, renderKnowledgeBenchmarkReportMarkdown, renderMemoryContext, researchSourceVersionKey, resetRetrievalHoldoutRegistry, resolveKnowledgeCitation, resolveKnowledgeCitations, resolveMemoryCleanupTimeoutMs, resolveRunScopedCitation, resolveRunScopedCitations, respondToIndustryMemoryBenchmarkSmokeCase, respondToIndustryRagBenchmarkSmokeCase, restoreKnowledgeCandidateBaseline, retrievalConfigFromSurface, retrievalConfigSurface, retrievalHoldoutConfigHash, retrievalRecallJudge, runAgentMemoryExperiment, runAgentMemoryImprovement, runAgentMemoryLearningExperiment, runBoundedMemoryLifecycle, runDiscoveryLoop, runInKnowledgeMutationScope, runInvestmentThesisTask, runKnowledgeBenchmarkSuite, runKnowledgeResearchLoop, runMemoryAdapterBenchmark, runRagKnowledgeImprovementLoop, runRagOptimization, runRetrievalImprovementLoop, runSerializedKnowledgeOptimization, runVerifiedResearchLoop, scenarioContentFingerprint, scoreBm25, scoreKnowledgeBaseIndex, scoreKnowledgeBenchmarkArtifact, scoreMemoryBenchmarkArtifact, scoreRagAnswerArtifact, scoreRetrievalArtifact, searchKnowledge, searchKnowledgePages, sha256, sleepForMemoryRecovery, slugify, snapshotSourceTextInput, sourceMatchesGaps, sourceRegistryPath, stableId, stripFrontmatter, summarizeKnowledgeBenchmarkCampaign, syncDirectory, textSourceAdapter, textSourceId, thesisReadinessSpecs, toAgentCandidateKnowledgeRef, toDeepEvalTestCases, toOffPolicyTrajectory, toRagCheckerRecords, toRagasEvaluationRows, toTruLensRecords, tokenizeQuery, tokenizeText, totalMaterialFacts, triageSource, validateKnowledgeIndex, verdictFor, verifyGradeableEvidence, verifyKnowledgeRetrievalDisposition, verifyKnowledgeRetrievalReceipt, verifyKnowledgeUseReceipt, verifyKnowledgeVisibilitySnapshot, walk, withCitedClaim, withKnowledgeImprovementCandidate, withKnowledgeImprovementComparison, withKnowledgeMutation, withKnowledgeRead, withSafeDescendant, withSafeDirectory, writeFileDurable, writeFileDurableWithinRoot, writeJson, writeJsonDurable, writeJsonDurableWithinRoot, writeKnowledgeIndex, writeSourceRegistry };
+export { AgentMemoryHitSchema, AgentMemoryKindSchema, AgentMemoryLifecycleTimeoutError, AgentMemoryLifecycleUnsafeError, AgentMemoryScopeSchema, AgentMemoryWriteInputSchema, CHECKABLE_RUNG_THRESHOLD, ClaimLedgerGoalConflictError, ClaimLedgerMigrationRequiredError, DEADLINE_EXIT_CODE, DEFAULT_KNOWLEDGE_BRIEF_LIMIT, DEFAULT_MEMORY_CLEANUP_TIMEOUT_MS, DEFAULT_PAGES_DIRECTORY, DeepQuestionSchema, FileSystemKbStore, FileSystemSearchProvider, HindsightOperationUnknownError, KB_CLAIM_LEDGER_DIR, KB_EVENTS_PATH, KB_INDEX_PATH, KB_STORE_DIR, KNOWLEDGE_EVENT_TYPES, KNOWLEDGE_PROMOTIONS_DIRECTORY, KNOWLEDGE_PROMOTION_DIGEST_ALGORITHM, KNOWLEDGE_PROMOTION_SCHEMA_VERSION, KNOWLEDGE_RECEIPT_DIGEST_ALGORITHM, KNOWLEDGE_SEARCH_RETRIEVER_ID, KNOWLEDGE_USE_RECEIPT_SCHEMA_VERSION, KnowledgeBaseCandidateSchema, KnowledgeCitationAuditError, KnowledgeCitationResolutionError, KnowledgeDuplicateIntakeError, KnowledgeEventSchema, KnowledgeGraphEdgeSchema, KnowledgeGraphNodeSchema, KnowledgeImprovementCandidateRefSchema, KnowledgeImprovementEvidenceSchema, KnowledgeImprovementRunStateSchema, KnowledgeIndexSchema, KnowledgePageInvalidationSchema, KnowledgePageSchema, KnowledgePromotionError, KnowledgeProposalParseError, KnowledgeRelationSchema, KnowledgeVisibilityUnavailableError, MemoryKbStore, READINESS_SPEC_DEFAULTS, RUN_LINEAGE_BASENAME, ResearchClaimEvidenceSchema, ResearchClaimLedgerSchema, ResearchClaimRecordSchema, ResearchSourceVersionSchema, SCAFFOLD_PAGE_BASENAMES, SourceAnchorSchema, SourceRecordSchema, UncheckableClaimError, WIKILINK_REGEX, addSourcePath, addSourceText, applyKnowledgeWriteBlocks, applyKnowledgeWriteBlocksFile, applyRetrievalHoldout, applySessionStickyRetrievalHoldout, assertClaimLedgerId, assertCurrentRunCitationsResolved, assertDeepQuestionIntegrity, assertGradeableEvidence, assertKnowledgeCitationAudit, assertKnowledgeCitationsResolved, assertKnowledgeRetrievalMatchesVisibility, assertKnowledgeRetrievalMatchesVisibilityArtifact, assertKnowledgeWriteIntake, assertResearchClaimEvidenceIntegrity, assertResearchClaimLedgerIntegrity, assertRunScopedCitationsResolved, assertTrackedClaimIntegrity, auditCurrentRunCitations, auditKnowledgeCitations, buildEvalKnowledgeBundle, buildKnowledgeBrief, buildKnowledgeGraph, buildKnowledgeIndex, buildKnowledgeLexicalIndex, buildRetrievalEvalDispatch, canonicalPathsEqual, canonicalRelativeWithinRoot, chunkMarkdown, claimCheckKey, claimEvidenceId, claimId, claimSourceHost, createAgentMemoryBranch, createFileRunLineageAuthority, createFileSystemSearchProvider, createGraphitiMemoryAdapter, createHindsightMemoryAdapter, createInMemoryBenchmarkAdapter, createKnowledgeControlLoopAdapter, createKnowledgeEvent, createKnowledgeRetrievalDisposition, createKnowledgeRetrievalReceipt, createKnowledgeTools, createKnowledgeUseReceipt, createKnowledgeVisibilitySnapshot, createLocalDiscoveryDispatcher, createMem0MemoryAdapter, createMemoryExecutionPool, createNeo4jAgentMemoryAdapter, createNoopMemoryBenchmarkAdapter, createPlayMemoryTools, createQmdKnowledgeTools, createQmdSearchProvider, createRunScopedStores, decodeKnowledgeVisibilitySnapshot, deepQuestionId, defaultGetMemoryContext, defineReadinessSpec, detectNearDuplicatePages, deterministicRng, diagnoseRagAnswerFailure, emitRetrievalHoldoutBypass, emptyClaimLedger, encodeKnowledgeVisibilitySnapshot, evaluateKnowledgeBaseReadiness, explainKnowledgeTarget, extractWikilinks, forkAgentMemoryBranchSnapshot, formatFrontmatter, formatKnowledgeCitationReference, fromAgentCandidateKnowledgeRef, gradeClaims, gradeFor, graphitiMemoryAdapterIdentity, groundClaimInText, hashKnowledgeBase, hindsightMemoryBankId, improveKnowledgeBase, initKnowledgeBase, inspectKnowledgeIndex, inspectPendingKnowledgeMutation, isKernelAnchoredPath, isKnowledgeMutationHeld, isKnowledgePagePath, isMissingFile, isSafeKnowledgePath, isScaffoldPath, jsonCandidateCodec, jsonObjectCandidateCodec, knowledgeImprovementCandidateRef, knowledgeImprovementRunDir, knowledgeImprovementRunId, knowledgePageDigest, knowledgePageFromMarkdown, knowledgePageRelations, knowledgeReleaseReport, knowledgeVisibilityArtifactRef, layoutFor, linkClaimContradictions, lintKnowledgeIndex, listRegularFilesWithinRoot, loadKnowledgeImprovementActivationResult, loadKnowledgeImprovementEvents, loadKnowledgeImprovementState, loadKnowledgePages, loadKnowledgePromotionRecord, loadSourceRegistry, materializeRegisteredClaimEvidence, mediaTypeFor, mem0MemoryAdapterIdentity, memoryHitToSourceRecord, memoryRecoveryDelayMs, memoryWriteResultToSourceRecord, mergeClaimLedgers, mergeTrackedClaims, normalizeClaimText, normalizeExternalRagScores, normalizeKnowledgeStateScope, normalizeLinkTarget, normalizePageText, normalizePagesDirectory, originatedPages, parseFrontmatter, parseKnowledgeCitationReference, parseKnowledgeWriteBlocks, partitionRetrievalScenarios, promoteKnowledgeCandidate, promoteRunScopedPages, proposeFromFinding, proposeFromFindings, ragAnswerQualityJudge, readRegularFileNoFollow, readRegularFileWithinRoot, reciprocalRankFusion, recoverPendingKnowledgeMutation, relativeWithinRoot, removeDurable, renameDurable, renderMemoryContext, researchSourceVersionKey, resetRetrievalHoldoutRegistry, resolveKnowledgeCitation, resolveKnowledgeCitations, resolveMemoryCleanupTimeoutMs, resolveRunScopedCitation, resolveRunScopedCitations, restoreKnowledgeCandidateBaseline, retrievalConfigFromSurface, retrievalConfigSurface, retrievalHoldoutConfigHash, retrievalRecallJudge, runBoundedMemoryLifecycle, runDiscoveryLoop, runInKnowledgeMutationScope, runKnowledgeResearchLoop, runRagKnowledgeImprovementLoop, runRagOptimization, runRetrievalImprovementLoop, runSerializedKnowledgeOptimization, scenarioContentFingerprint, scoreBm25, scoreKnowledgeBaseIndex, scoreRagAnswerArtifact, scoreRetrievalArtifact, searchKnowledge, searchKnowledgePages, sha256, sleepForMemoryRecovery, slugify, snapshotSourceTextInput, sourceRegistryPath, stableId, stripFrontmatter, syncDirectory, textSourceAdapter, textSourceId, toAgentCandidateKnowledgeRef, toDeepEvalTestCases, toOffPolicyTrajectory, toRagCheckerRecords, toRagasEvaluationRows, toTruLensRecords, tokenizeQuery, tokenizeText, validateKnowledgeIndex, verdictFor, verifyGradeableEvidence, verifyKnowledgeRetrievalDisposition, verifyKnowledgeRetrievalReceipt, verifyKnowledgeUseReceipt, verifyKnowledgeVisibilitySnapshot, withKnowledgeImprovementCandidate, withKnowledgeImprovementComparison, withKnowledgeMutation, withKnowledgeRead, withSafeDescendant, withSafeDirectory, writeFileDurable, writeFileDurableWithinRoot, writeJson, writeJsonDurable, writeJsonDurableWithinRoot, writeKnowledgeIndex, writeSourceRegistry };
 
 //# sourceMappingURL=index.js.map