@tangle-network/agent-knowledge 19.1.5 → 20.0.1

package/dist/{inspect-C6c4zuKp.js → inspect-CMigdsD5.js}

@@ -1,12 +1,11 @@
 import { i as textSourceId, n as slugify, r as stableId, t as sha256 } from "./ids-Bevz_pXV.js";
-import { r as searchKnowledge } from "./search-BBr5eUyT.js";
-import { createHash, randomUUID } from "node:crypto";
-import { lstat, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm } from "node:fs/promises";
-import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { canonicalCandidateBytes, canonicalCandidateDigest, sha256Bytes, sha256DigestSchema } from "@tangle-network/agent-interface";
 import { contentHash } from "@tangle-network/agent-eval";
 import { z } from "zod";
+import { createHash, randomUUID } from "node:crypto";
 import { constants, lstatSync } from "node:fs";
+import { lstat, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/adapters.ts
 const textSourceAdapter = {
@@ -1390,9 +1389,8 @@ function unquote(value) {
 * The algebra of a research claim ledger: claim identity, and how two ledgers
 * that accumulated evidence for the same goal combine into one.
 *
-* This lives apart from `research-driving-driver.ts` because it is no longer
-* that driver's private business. A ledger is a durable record now, and a
-* durable record addressed by id is a record two writers can reach: two rounds
+* A ledger is a durable record, and a durable record addressed by id is a
+* record two writers can reach: two rounds
 * of one run resuming from disk, or two workers researching one goal in
 * parallel. `putClaimLedger` writes the whole record, so the second writer's
 * write erases the first writer's claims — the ledger persists and the
@@ -1722,9 +1720,8 @@ function mergeSourceVersions(base, incoming) {
 * of it: the worker that found the refuting source records "X contradicts Y" and
 * knows nothing about Y's record. Left one-sided, Y reads as an uncontested
 * claim, and the completion oracle would settle a question two sources disagree
-* about. `createResearchDrivingDriver` does this pairwise as it records; this is
-* the same rule stated over a whole ledger, for writers that assemble one from
-* events rather than from a live loop.
+* about. This rule applies over a whole ledger, for writers that assemble one
+* from events.
 *
 * One-sided observations stay in `claimEvidence` until both claims are backed
 * by registered source versions. The materialized claim projection contains
@@ -1776,8 +1773,7 @@ function sameStrings(left, right) {
 /**
 * The event vocabulary, as a value so the runtime schema is DERIVED from it
 * rather than restated. A restated copy in `schemas.ts` drifted: it omitted
-* `research.iteration`, which is the only event `runVerifiedResearchLoop`
-* produces, so every attempt to store one would have been rejected. Nothing
+* `research.iteration`, which the research loop produces, so every attempt to store one would have been rejected. Nothing
 * caught it because nothing ever stored an event. Add a type here and the
 * schema accepts it in the same edit.
 */
@@ -1861,16 +1857,6 @@ const KnowledgeRelationSchema = z.object({
 	weight: z.number().optional(),
 	metadata: z.record(z.string(), z.unknown()).optional()
 });
-const KnowledgeRelationNodeSchema = z.object({
-	id: z.string(),
-	kind: z.string(),
-	label: z.string().optional(),
-	metadata: z.record(z.string(), z.unknown()).optional()
-});
-const KnowledgeRelationGraphSchema = z.object({
-	nodes: z.array(KnowledgeRelationNodeSchema),
-	edges: z.array(KnowledgeRelationSchema)
-});
 const KnowledgeIndexSchema = z.object({
 	root: z.string(),
 	generatedAt: z.string(),
@@ -4570,6 +4556,278 @@ function stringMetadata(metadata, key) {
 	return typeof value === "string" ? value : void 0;
 }
 //#endregion
+//#region src/lexical-postings.ts
+const DEFAULT_FIELD_BOOSTS = Object.freeze({
+	title: 3,
+	path: 2,
+	text: 1
+});
+function lexicalPageTerms(page, tokenize, fieldBoosts) {
+	const frequencies = /* @__PURE__ */ new Map();
+	let length = 0;
+	for (const [text, boost] of [
+		[page.title, fieldBoosts.title],
+		[page.path.replace(/\.md$/, ""), fieldBoosts.path],
+		[page.text, fieldBoosts.text]
+	]) {
+		if (boost === 0) continue;
+		for (const token of tokenize(text)) {
+			frequencies.set(token, (frequencies.get(token) ?? 0) + boost);
+			length += boost;
+		}
+	}
+	return {
+		frequencies,
+		length
+	};
+}
+/** Inverted index from per-page terms already computed with `tokenize` and `fieldBoosts`. */
+function assembleLexicalIndex(pages, terms, tokenize, fieldBoosts) {
+	const postings = /* @__PURE__ */ new Map();
+	const documentLengths = [];
+	let totalLength = 0;
+	terms.forEach(({ frequencies, length }, ordinal) => {
+		documentLengths.push(length);
+		totalLength += length;
+		for (const [term, tf] of frequencies) {
+			let list = postings.get(term);
+			if (!list) {
+				list = [];
+				postings.set(term, list);
+			}
+			list.push({
+				ordinal,
+				tf
+			});
+		}
+	});
+	return {
+		pages,
+		postings,
+		documentLengths,
+		averageDocumentLength: pages.length > 0 ? totalLength / pages.length : 0,
+		documentCount: pages.length,
+		tokenize,
+		fieldBoosts
+	};
+}
+//#endregion
+//#region src/lexical-index.ts
+const STOP_WORDS = /* @__PURE__ */ new Set([
+	"the",
+	"is",
+	"a",
+	"an",
+	"what",
+	"how",
+	"are",
+	"was",
+	"were",
+	"to",
+	"for",
+	"of",
+	"with",
+	"by",
+	"in",
+	"on",
+	"and"
+]);
+/**
+* The token stream of one text: lower-cased, split on whitespace and
+* punctuation, single characters and stop words removed, and a CJK run
+* expanded into its bigrams and characters. Repeats are kept so a term
+* frequency can be counted. Indexing and querying share this function, so the
+* two vocabularies cannot drift.
+*/
+function tokenizeText(text) {
+	const raw = text.toLowerCase().split(/[\s,，。！？、；：""''（）()\-_/\\·~～…]+/).filter((token) => token.length > 1 && !STOP_WORDS.has(token));
+	const tokens = [];
+	for (const token of raw) {
+		if (/[\u4e00-\u9fff\u3400-\u4dbf]/.test(token) && token.length > 2) {
+			const chars = [...token];
+			for (let i = 0; i < chars.length - 1; i++) tokens.push(chars[i] + chars[i + 1]);
+			tokens.push(...chars);
+		}
+		tokens.push(token);
+	}
+	return tokens;
+}
+/** The distinct query terms, in first-occurrence order. */
+function tokenizeQuery(query) {
+	return [...new Set(tokenizeText(query))];
+}
+function buildKnowledgeLexicalIndex(pages, options = {}) {
+	const tokenize = options.tokenize ?? tokenizeText;
+	const fieldBoosts = resolveFieldBoosts(options.fieldBoosts);
+	return assembleLexicalIndex(pages, pages.map((page) => lexicalPageTerms(page, tokenize, fieldBoosts)), tokenize, fieldBoosts);
+}
+/**
+* Okapi BM25 over the distinct query terms, with the Lucene inverse document
+* frequency `ln(1 + (N - df + 0.5) / (df + 0.5))`, which is positive for every
+* indexed term. Pages with no matching term are absent. The result is ordered
+* by score, then by path, so it does not depend on page order.
+*/
+function scoreBm25(index, tokens, options = {}) {
+	const k1 = options.k1 ?? 1.2;
+	const b = options.b ?? .75;
+	if (!Number.isFinite(k1) || k1 < 0) throw new Error(`bm25 k1 must be >= 0, got ${String(k1)}`);
+	if (!Number.isFinite(b) || b < 0 || b > 1) throw new Error(`bm25 b must lie in [0, 1], got ${String(b)}`);
+	const scores = /* @__PURE__ */ new Map();
+	const { documentCount, averageDocumentLength, documentLengths } = index;
+	for (const term of new Set(tokens)) {
+		const list = index.postings.get(term);
+		if (!list) continue;
+		const df = list.length;
+		const idf = Math.log(1 + (documentCount - df + .5) / (df + .5));
+		for (const { ordinal, tf } of list) {
+			const lengthRatio = averageDocumentLength > 0 ? documentLengths[ordinal] / averageDocumentLength : 1;
+			const saturated = tf * (k1 + 1) / (tf + k1 * (1 - b + b * lengthRatio));
+			scores.set(ordinal, (scores.get(ordinal) ?? 0) + idf * saturated);
+		}
+	}
+	return [...scores.entries()].map(([ordinal, score]) => ({
+		page: index.pages[ordinal],
+		score
+	})).sort((left, right) => right.score - left.score || left.page.path.localeCompare(right.page.path));
+}
+function resolveFieldBoosts(boosts) {
+	const resolved = {
+		...DEFAULT_FIELD_BOOSTS,
+		...boosts
+	};
+	for (const [field, boost] of Object.entries(resolved)) if (!Number.isFinite(boost) || boost < 0) throw new Error(`lexical field boost ${field} must be >= 0, got ${String(boost)}`);
+	return Object.freeze(resolved);
+}
+//#endregion
+//#region src/search.ts
+const RRF_K = 60;
+/**
+* Identity of the ranking `searchKnowledge` performs: BM25 over title, path,
+* and body, exact-title and phrase matches ahead of bag-of-words matches, and
+* reciprocal rank fusion with link and shared-source structure. Declare it as
+* the retriever id of a retrieval receipt minted from these results.
+*/
+const KNOWLEDGE_SEARCH_RETRIEVER_ID = "bm25-rrf-v1";
+function searchKnowledge(index, query, limitOrOptions = 10) {
+	return searchKnowledgePages(index.pages, query, limitOrOptions);
+}
+/**
+* Rank a page set that is not a built index, such as the chain a run can see.
+*
+* `searchKnowledge` is this function over `index.pages`, so both entry points
+* rank identically and neither can drift from the other.
+*/
+function searchKnowledgePages(pages, query, limitOrOptions = 10) {
+	const trimmed = query.trim();
+	if (trimmed === "") return [];
+	const options = typeof limitOrOptions === "number" ? { limit: limitOrOptions } : { ...limitOrOptions };
+	const limit = options.limit ?? 10;
+	if (!Number.isInteger(limit) || limit < 0) throw new Error(`search limit must be a non-negative integer, got ${String(limit)}`);
+	const matched = filterPages(pages, options);
+	const lexicalRanked = rankLexical(matched, trimmed, options.lexicalIndex ? assertLexicalIndexMatches(options.lexicalIndex, pages) : buildKnowledgeLexicalIndex(pages));
+	const ranked = [...fuseRanks([lexicalRanked, rankByGraph(matched, lexicalRanked, pages)]).entries()].map(([page, score]) => ({
+		page,
+		score
+	})).sort((a, b) => b.score - a.score || comparePages(a.page, b.page)).slice(0, limit);
+	const topScore = ranked[0]?.score ?? 0;
+	return ranked.map((item, i) => ({
+		citationId: item.page.id,
+		page: item.page,
+		score: item.score,
+		rrfScore: item.score,
+		normalizedScore: topScore > 0 ? item.score / topScore : 0,
+		rank: i + 1,
+		snippet: buildSnippet(item.page.text, trimmed),
+		reasons: reasonsFor(item.page, trimmed)
+	}));
+}
+function reciprocalRankFusion(rankLists, k = RRF_K) {
+	return fuseRanks(rankLists, k);
+}
+function fuseRanks(rankLists, k = RRF_K) {
+	const scores = /* @__PURE__ */ new Map();
+	for (const list of rankLists) list.forEach((id, idx) => {
+		scores.set(id, (scores.get(id) ?? 0) + 1 / (k + idx + 1));
+	});
+	return scores;
+}
+function filterPages(pages, options) {
+	const pageIds = options.pageIds ? new Set(options.pageIds) : null;
+	const tags = options.tags ? new Set(options.tags) : null;
+	const kinds = options.kinds ? new Set(options.kinds) : null;
+	return pages.filter((page) => {
+		if (options.excludeInvalidated && page.invalidation !== void 0) return false;
+		if (pageIds && !pageIds.has(page.id)) return false;
+		if (tags && !page.tags.some((tag) => tags.has(tag))) return false;
+		if (kinds) {
+			const kind = page.frontmatter.kind;
+			if (typeof kind !== "string" || !kinds.has(kind)) return false;
+		}
+		return options.predicate?.(page) ?? true;
+	});
+}
+function assertLexicalIndexMatches(lexicalIndex, pages) {
+	if (lexicalIndex.pages.length !== pages.length || lexicalIndex.pages.some((page, ordinal) => page !== pages[ordinal])) throw new Error("lexical index was not built from the searched pages");
+	return lexicalIndex;
+}
+/**
+* The lexical rank list. An exact title or path match outranks a title that
+* contains the query, which outranks a body that contains the query, which
+* outranks a bag-of-words match; BM25 orders pages inside each of those tiers.
+* The tiers are an ordering, not a score, so a strong bag-of-words page cannot
+* overtake an exact match by term repetition alone.
+*/
+function rankLexical(pages, query, lexicalIndex) {
+	const tokens = [...new Set(lexicalIndex.tokenize(query))];
+	const bm25 = new Map(scoreBm25(lexicalIndex, tokens).map((hit) => [hit.page, hit.score]));
+	const phrase = query.toLowerCase();
+	return pages.flatMap((page) => {
+		const score = bm25.get(page) ?? 0;
+		if (score === 0 && tokens.length > 0) return [];
+		const tier = phraseTier(page, phrase);
+		if (score === 0 && tier === 0) return [];
+		return [{
+			page,
+			tier,
+			score
+		}];
+	}).sort((a, b) => b.tier - a.tier || b.score - a.score || comparePages(a.page, b.page)).map((item) => item.page);
+}
+function phraseTier(page, phrase) {
+	const title = page.title.toLowerCase();
+	if (title === phrase || page.path.toLowerCase().endsWith(`${phrase}.md`)) return 3;
+	if (title.includes(phrase)) return 2;
+	if (page.text.toLowerCase().includes(phrase)) return 1;
+	return 0;
+}
+function rankByGraph(pages, lexicalRanked, visiblePages) {
+	if (lexicalRanked.length === 0) return [];
+	const counts = /* @__PURE__ */ new Map();
+	for (const page of visiblePages) counts.set(page.id, (counts.get(page.id) ?? 0) + 1);
+	const seeds = new Set(lexicalRanked.slice(0, 5).filter((page) => counts.get(page.id) === 1).map((page) => page.id));
+	return pages.map((page) => ({
+		page,
+		score: page.outLinks.filter((link) => seeds.has(link)).length + page.sourceIds.filter((source) => lexicalRanked.some((seed) => seed.sourceIds.includes(source))).length
+	})).filter((item) => item.score > 0).sort((a, b) => b.score - a.score || comparePages(a.page, b.page)).map((item) => item.page);
+}
+function comparePages(a, b) {
+	return a.path.localeCompare(b.path) || a.id.localeCompare(b.id);
+}
+function buildSnippet(text, query) {
+	const compact = text.replace(/\s+/g, " ").trim();
+	const idx = compact.toLowerCase().indexOf(query.toLowerCase());
+	if (idx < 0) return compact.slice(0, 180);
+	return compact.slice(Math.max(0, idx - 80), Math.min(compact.length, idx + query.length + 100));
+}
+function reasonsFor(page, query) {
+	const lower = `${page.title}\n${page.text}`.toLowerCase();
+	const reasons = [];
+	if (lower.includes(query.toLowerCase())) reasons.push("phrase");
+	if (page.sourceIds.length > 0) reasons.push("sourced");
+	if (page.outLinks.length > 0) reasons.push("linked");
+	return reasons;
+}
+//#endregion
 //#region src/inspect.ts
 function inspectKnowledgeIndex(index, options = {}) {
 	const now = options.now ?? /* @__PURE__ */ new Date();
@@ -4633,6 +4891,6 @@ function explainKnowledgeTarget(index, target) {
 	};
 }
 //#endregion
-export { snapshotSourceTextInput as $, mediaTypeFor$1 as $n, SourceRecordSchema as $t, validateKnowledgePage as A, finishKnowledgeFileTransaction as An, knowledgePageFromMarkdown as At, DEADLINE_EXIT_CODE as B, listRegularFilesWithinRoot as Bn, KnowledgeGraphEdgeSchema as Bt, immutablePageDigest as C, recoverPendingKnowledgeMutation as Cn, resolveKnowledgeCitations as Ct, normalizeVisibilityArtifact as D, applyKnowledgeFileTransaction as Dn, initKnowledgeBase as Dt, nonEmpty as E, withKnowledgeRead as En, SCAFFOLD_PAGE_BASENAMES as Et, detectNearDuplicatePages as F, normalizePagesDirectory as Fn, extractWikilinks as Ft, gradeFor as G, renameDurable as Gn, KnowledgeRelationGraphSchema as Gt, assertGradeableEvidence as H, readRegularFileWithinRoot as Hn, KnowledgeIndexSchema as Ht, normalizePageText as I, canonicalPathsEqual as In, normalizeLinkTarget as It, buildKnowledgeIndex as J, withSafeDirectory as Jn, ResearchClaimEvidenceSchema as Jt, verdictFor as K, syncDirectory as Kn, KnowledgeRelationNodeSchema as Kt, validateKnowledgeIndex as L, canonicalRelativeWithinRoot as Ln, DeepQuestionSchema as Lt, verifyKnowledgeVisibilitySnapshot as M, prepareKnowledgeFileTransaction as Mn, loadKnowledgePages as Mt, visibilityIdentity as N, rollbackKnowledgeFileTransaction as Nn, writeJson as Nt, normalizeVisibilityRef as O, assertKnowledgeMutationPath as On, isKnowledgePagePath as Ot, visibilityIndexOf as P, DEFAULT_PAGES_DIRECTORY as Pn, WIKILINK_REGEX as Pt, loadSourceRegistry as Q, writeJsonDurableWithinRoot as Qn, SourceAnchorSchema as Qt, lintKnowledgeIndex as R, isKernelAnchoredPath as Rn, KnowledgeBaseCandidateSchema as Rt, encodeKnowledgeVisibilitySnapshot as S, measureKnowledgeMutation as Sn, resolveKnowledgeCitation as St, knowledgeVisibilityArtifactRef as T, withKnowledgeMutation as Tn, resolveRunScopedCitations as Tt, claimCheckKey as U, relativeWithinRoot as Un, KnowledgePageInvalidationSchema as Ut, UncheckableClaimError as V, readRegularFileNoFollow as Vn, KnowledgeGraphNodeSchema as Vt, gradeClaims as W, removeDurable as Wn, KnowledgePageSchema as Wt, addSourcePath as X, writeFileDurableWithinRoot as Xn, ResearchClaimRecordSchema as Xt, writeKnowledgeIndex as Y, writeFileDurable as Yn, ResearchClaimLedgerSchema as Yt, addSourceText as Z, writeJsonDurable as Zn, ResearchSourceVersionSchema as Zt, KNOWLEDGE_USE_RECEIPT_SCHEMA_VERSION as _, formatFrontmatter as _n, assertRunScopedCitationsResolved as _t, applyKnowledgeWriteBlocksFile as a, assertTrackedClaimIntegrity as an, KB_EVENTS_PATH as at, decodeKnowledgeVisibilitySnapshot as b, inspectPendingKnowledgeMutation as bn, formatKnowledgeCitationReference as bt, KnowledgeDuplicateIntakeError as c, claimSourceHost as cn, MemoryKbStore as ct, createFileRunLineageAuthority as d, linkClaimContradictions as dn, knowledgePageRelations as dt, KNOWLEDGE_EVENT_TYPES as en, textSourceAdapter as er, sourceRegistryPath as et, createRunScopedStores as f, materializeRegisteredClaimEvidence as fn, KnowledgeCitationAuditError as ft, KNOWLEDGE_RECEIPT_DIGEST_ALGORITHM as g, researchSourceVersionKey as gn, assertKnowledgeCitationsResolved as gt, originatedPages as h, normalizeClaimText as hn, assertKnowledgeCitationAudit as ht, applyKnowledgeWriteBlocks as i, assertResearchClaimLedgerIntegrity as in, KB_CLAIM_LEDGER_DIR as it, validateOrigin as j, knowledgeFileTransactionPlanHash as jn, layoutFor as jt, snapshotImmutableVisibility as k, commitKnowledgeFileMutations as kn, isScaffoldPath as kt, assertKnowledgeWriteIntake as l, deepQuestionId as ln, assertClaimLedgerId as lt, loadKnowledgeToolChain as m, mergeTrackedClaims as mn, assertCurrentRunCitationsResolved as mt, inspectKnowledgeIndex as n, assertDeepQuestionIntegrity as nn, ClaimLedgerMigrationRequiredError as nt, isSafeKnowledgePath as o, claimEvidenceId as on, KB_INDEX_PATH as ot, isKnowledgeToolChain as p, mergeClaimLedgers as pn, KnowledgeCitationResolutionError as pt, verifyGradeableEvidence as q, withSafeDescendant as qn, KnowledgeRelationSchema as qt, stringMetadata as r, assertResearchClaimEvidenceIntegrity as rn, FileSystemKbStore as rt, parseKnowledgeWriteBlocks as s, claimId as sn, KB_STORE_DIR as st, explainKnowledgeTarget as t, ClaimLedgerGoalConflictError as tn, writeSourceRegistry as tt, RUN_LINEAGE_BASENAME as u, emptyClaimLedger as un, buildKnowledgeGraph as ut, assertSchemaVersion as v, parseFrontmatter as vn, auditCurrentRunCitations as vt, knowledgePageDigest as w, runInKnowledgeMutationScope as wn, resolveRunScopedCitation as wt, digest as x, isKnowledgeMutationHeld as xn, parseKnowledgeCitationReference as xt, createKnowledgeVisibilitySnapshot as y, acquireDurableFileLock as yn, auditKnowledgeCitations as yt, CHECKABLE_RUNG_THRESHOLD as z, isMissingFile as zn, KnowledgeEventSchema as zt };
+export { assertGradeableEvidence as $, removeDurable as $n, KnowledgeIndexSchema as $t, createKnowledgeVisibilitySnapshot as A, isKnowledgeMutationHeld as An, auditKnowledgeCitations as At, snapshotImmutableVisibility as B, knowledgeFileTransactionPlanHash as Bn, isScaffoldPath as Bt, createRunScopedStores as C, mergeTrackedClaims as Cn, KnowledgeCitationAuditError as Ct, KNOWLEDGE_RECEIPT_DIGEST_ALGORITHM as D, parseFrontmatter as Dn, assertKnowledgeCitationsResolved as Dt, originatedPages as E, formatFrontmatter as En, assertKnowledgeCitationAudit as Et, knowledgePageDigest as F, withKnowledgeRead as Fn, resolveRunScopedCitation as Ft, visibilityIndexOf as G, canonicalPathsEqual as Gn, WIKILINK_REGEX as Gt, validateOrigin as H, rollbackKnowledgeFileTransaction as Hn, layoutFor as Ht, knowledgeVisibilityArtifactRef as I, applyKnowledgeFileTransaction as In, resolveRunScopedCitations as It, validateKnowledgeIndex as J, isMissingFile as Jn, DeepQuestionSchema as Jt, detectNearDuplicatePages as K, canonicalRelativeWithinRoot as Kn, extractWikilinks as Kt, nonEmpty as L, assertKnowledgeMutationPath as Ln, SCAFFOLD_PAGE_BASENAMES as Lt, digest as M, recoverPendingKnowledgeMutation as Mn, parseKnowledgeCitationReference as Mt, encodeKnowledgeVisibilitySnapshot as N, runInKnowledgeMutationScope as Nn, resolveKnowledgeCitation as Nt, KNOWLEDGE_USE_RECEIPT_SCHEMA_VERSION as O, acquireDurableFileLock as On, assertRunScopedCitationsResolved as Ot, immutablePageDigest as P, withKnowledgeMutation as Pn, resolveKnowledgeCitations as Pt, UncheckableClaimError as Q, relativeWithinRoot as Qn, KnowledgeGraphNodeSchema as Qt, normalizeVisibilityArtifact as R, commitKnowledgeFileMutations as Rn, initKnowledgeBase as Rt, createFileRunLineageAuthority as S, mergeClaimLedgers as Sn, knowledgePageRelations as St, loadKnowledgeToolChain as T, researchSourceVersionKey as Tn, assertCurrentRunCitationsResolved as Tt, verifyKnowledgeVisibilitySnapshot as U, DEFAULT_PAGES_DIRECTORY as Un, loadKnowledgePages as Ut, validateKnowledgePage as V, prepareKnowledgeFileTransaction as Vn, knowledgePageFromMarkdown as Vt, visibilityIdentity as W, normalizePagesDirectory as Wn, writeJson as Wt, CHECKABLE_RUNG_THRESHOLD as X, readRegularFileNoFollow as Xn, KnowledgeEventSchema as Xt, lintKnowledgeIndex as Y, listRegularFilesWithinRoot as Yn, KnowledgeBaseCandidateSchema as Yt, DEADLINE_EXIT_CODE as Z, readRegularFileWithinRoot as Zn, KnowledgeGraphEdgeSchema as Zt, isSafeKnowledgePath as _, claimSourceHost as _n, KB_INDEX_PATH as _t, searchKnowledge as a, ResearchClaimRecordSchema as an, writeFileDurableWithinRoot as ar, buildKnowledgeIndex as at, assertKnowledgeWriteIntake as b, linkClaimContradictions as bn, assertClaimLedgerId as bt, scoreBm25 as c, SourceRecordSchema as cn, mediaTypeFor$1 as cr, addSourceText as ct, DEFAULT_FIELD_BOOSTS as d, assertDeepQuestionIntegrity as dn, sourceRegistryPath as dt, KnowledgePageInvalidationSchema as en, renameDurable as er, claimCheckKey as et, assembleLexicalIndex as f, assertResearchClaimEvidenceIntegrity as fn, writeSourceRegistry as ft, applyKnowledgeWriteBlocksFile as g, claimId as gn, KB_EVENTS_PATH as gt, applyKnowledgeWriteBlocks as h, claimEvidenceId as hn, KB_CLAIM_LEDGER_DIR as ht, reciprocalRankFusion as i, ResearchClaimLedgerSchema as in, writeFileDurable as ir, verifyGradeableEvidence as it, decodeKnowledgeVisibilitySnapshot as j, measureKnowledgeMutation as jn, formatKnowledgeCitationReference as jt, assertSchemaVersion as k, inspectPendingKnowledgeMutation as kn, auditCurrentRunCitations as kt, tokenizeQuery as l, KNOWLEDGE_EVENT_TYPES as ln, textSourceAdapter as lr, loadSourceRegistry as lt, stringMetadata as m, assertTrackedClaimIntegrity as mn, FileSystemKbStore as mt, inspectKnowledgeIndex as n, KnowledgeRelationSchema as nn, withSafeDescendant as nr, gradeFor as nt, searchKnowledgePages as o, ResearchSourceVersionSchema as on, writeJsonDurable as or, writeKnowledgeIndex as ot, lexicalPageTerms as p, assertResearchClaimLedgerIntegrity as pn, ClaimLedgerMigrationRequiredError as pt, normalizePageText as q, isKernelAnchoredPath as qn, normalizeLinkTarget as qt, KNOWLEDGE_SEARCH_RETRIEVER_ID as r, ResearchClaimEvidenceSchema as rn, withSafeDirectory as rr, verdictFor as rt, buildKnowledgeLexicalIndex as s, SourceAnchorSchema as sn, writeJsonDurableWithinRoot as sr, addSourcePath as st, explainKnowledgeTarget as t, KnowledgePageSchema as tn, syncDirectory as tr, gradeClaims as tt, tokenizeText as u, ClaimLedgerGoalConflictError as un, snapshotSourceTextInput as ut, parseKnowledgeWriteBlocks as v, deepQuestionId as vn, KB_STORE_DIR as vt, isKnowledgeToolChain as w, normalizeClaimText as wn, KnowledgeCitationResolutionError as wt, RUN_LINEAGE_BASENAME as x, materializeRegisteredClaimEvidence as xn, buildKnowledgeGraph as xt, KnowledgeDuplicateIntakeError as y, emptyClaimLedger as yn, MemoryKbStore as yt, normalizeVisibilityRef as z, finishKnowledgeFileTransaction as zn, isKnowledgePagePath as zt };
 
-//# sourceMappingURL=inspect-C6c4zuKp.js.map
+//# sourceMappingURL=inspect-CMigdsD5.js.map