@tangle-network/agent-knowledge 8.0.10 → 10.7.0

package/dist/{inspect-0tmv3xV8.js → inspect-DALsvG10.js}

@@ -1,5 +1,5 @@
 import { i as textSourceId, n as slugify, r as stableId, t as sha256 } from "./ids-Bevz_pXV.js";
-import { n as searchKnowledge } from "./search-CtVJ0PKX.js";
+import { r as searchKnowledge } from "./search-Cw6eYfSd.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, sep } from "node:path";
@@ -273,10 +273,52 @@ function normalizeRelativePath(path) {
 	return normalized;
 }
 //#endregion
+//#region src/pages-directory.ts
+/** Root-relative directory that holds Markdown pages when a caller names none. */
+const DEFAULT_PAGES_DIRECTORY = "knowledge";
+/**
+* Validate a pages directory and return its canonical root-relative form.
+*
+* The result is a write allowlist prefix as well as a read location, so the
+* check refuses every value that could reach outside the pages tree: absolute
+* paths, drive letters, `..` or `.` segments, empty segments, control
+* characters, and the package-owned `.agent-knowledge` and `raw` trees.
+*/
+function normalizePagesDirectory(value = DEFAULT_PAGES_DIRECTORY) {
+	if (typeof value !== "string") throw new Error("pagesDirectory must be a string");
+	const normalized = value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+	if (normalized.length === 0 || normalized === ".") throw new Error("pagesDirectory must name a root-relative directory");
+	if (new RegExp(`[${String.fromCharCode(0)}-${String.fromCharCode(31)}]`).test(normalized)) throw new Error("pagesDirectory must not contain control characters");
+	if (normalized.startsWith("/") || /^[A-Za-z]:/.test(normalized)) throw new Error(`pagesDirectory must be root-relative, not absolute: ${value}`);
+	const segments = normalized.split("/");
+	if (segments.some((segment) => segment === "" || segment === "." || segment === "..")) throw new Error(`pagesDirectory must not contain empty or dot segments: ${value}`);
+	if (segments[0] === ".agent-knowledge" || segments[0] === "raw") throw new Error(`pagesDirectory must not name the package-owned ${segments[0]} tree: ${value}`);
+	return normalized;
+}
+//#endregion
 //#region src/file-transaction.ts
 const digestSchema = z.string().regex(/^[a-f0-9]{64}$/);
 const fileModeSchema = z.number().int().min(0).max(511);
 const DEFAULT_FILE_MODE = 420;
+const SOURCE_REGISTRY_PATH = ".agent-knowledge/sources.json";
+/**
+* A journal states the pages directory it was prepared under, already in
+* canonical form, so replay and recovery enforce the same allowlist as the
+* prepare step without any caller-supplied value.
+*/
+const pagesDirectorySchema = z.string().superRefine((value, context) => {
+	try {
+		if (normalizePagesDirectory(value) !== value) context.addIssue({
+			code: "custom",
+			message: "pagesDirectory is not in canonical form"
+		});
+	} catch (error) {
+		context.addIssue({
+			code: "custom",
+			message: error instanceof Error ? error.message : String(error)
+		});
+	}
+});
 const transactionEntrySchema = z.object({
 	index: z.number().int().nonnegative(),
 	path: z.string().min(1),
@@ -290,6 +332,7 @@ const transactionSchema = z.object({
 	transactionId: z.string().uuid(),
 	purpose: z.string().min(1),
 	recoveryOwner: z.string().min(1).max(256).optional(),
+	pagesDirectory: pagesDirectorySchema.optional(),
 	createdAt: z.string().min(1),
 	entries: z.array(transactionEntrySchema).min(1)
 }).strict();
@@ -304,12 +347,13 @@ function knowledgeFileTransactionPlanHash(entries) {
 }
 async function prepareKnowledgeFileTransaction(input) {
 	if (input.mutations.length === 0) throw new Error("knowledge file transaction has no mutations");
+	const pagesDirectory = input.pagesDirectory === void 0 ? void 0 : normalizePagesDirectory(input.pagesDirectory);
 	return withTransactionRoot(input.root, input.transactionRoot, true, async (transactionRoot) => {
 		const activeTransactions = await activeTransactionDirectoryNames(transactionRoot);
 		if (activeTransactions.length > 0) throw new Error(`knowledge file transaction is already active: ${activeTransactions.join(", ")}`);
 		const paths = /* @__PURE__ */ new Set();
 		const changed = (await Promise.all(input.mutations.map(async (mutation, index) => {
-			const path = assertKnowledgeMutationPath(mutation.path);
+			const path = assertKnowledgeMutationPath(mutation.path, pagesDirectory);
 			if (paths.has(path)) throw new Error(`knowledge file transaction repeats path: ${path}`);
 			if (mutation.content === null && mutation.mode !== void 0) throw new Error(`deleted knowledge file cannot declare a mode: ${path}`);
 			paths.add(path);
@@ -343,6 +387,7 @@ async function prepareKnowledgeFileTransaction(input) {
 				transactionId: randomUUID(),
 				purpose: input.purpose,
 				...input.recoveryOwner ? { recoveryOwner: input.recoveryOwner } : {},
+				...pagesDirectory === void 0 ? {} : { pagesDirectory },
 				createdAt: (input.now ?? (() => /* @__PURE__ */ new Date()))().toISOString(),
 				entries: changed.map((item) => item.entry)
 			});
@@ -377,6 +422,7 @@ async function commitKnowledgeFileMutations(input) {
 		transactionRoot: input.transactionRoot,
 		purpose: input.purpose,
 		mutations: input.mutations,
+		...input.pagesDirectory === void 0 ? {} : { pagesDirectory: input.pagesDirectory },
 		now: input.now
 	});
 	if (!transaction) return false;
@@ -600,7 +646,7 @@ function assertTransactionEntries(transaction) {
 	const indexes = /* @__PURE__ */ new Set();
 	const paths = /* @__PURE__ */ new Set();
 	for (const entry of transaction.entries) {
-		const normalized = assertKnowledgeMutationPath(entry.path);
+		const normalized = assertKnowledgeMutationPath(entry.path, transaction.pagesDirectory);
 		if (entry.path !== normalized || indexes.has(entry.index) || paths.has(entry.path)) throw new Error("knowledge file transaction has duplicate or unsafe entries");
 		assertHashModePair(entry.path, "before", entry.beforeHash, entry.beforeMode);
 		assertHashModePair(entry.path, "after", entry.afterHash, entry.afterMode);
@@ -624,9 +670,17 @@ function assertHashModePair(path, side, hash, mode) {
 	if (hash === null !== (mode === void 0)) throw new Error(`knowledge transaction ${side} hash and mode disagree: ${path}`);
 	if (mode !== void 0) fileModeSchema.parse(mode);
 }
-function assertKnowledgeMutationPath(path) {
+/**
+* Root-relative prefixes a knowledge transaction may write under. The pages
+* directory is the only caller-selected member; the source registry file and
+* the `raw/` evidence tree are package-owned and always present.
+*/
+function knowledgeMutationPathPrefixes(pagesDirectory) {
+	return [`${normalizePagesDirectory(pagesDirectory)}/`, "raw/"];
+}
+function assertKnowledgeMutationPath(path, pagesDirectory) {
 	const normalized = normalizeTransactionPath(path);
-	if (normalized === ".agent-knowledge/sources.json" || normalized.startsWith("knowledge/") || normalized.startsWith("raw/")) return normalized;
+	if (normalized === SOURCE_REGISTRY_PATH || knowledgeMutationPathPrefixes(pagesDirectory).some((prefix) => normalized.startsWith(prefix))) return normalized;
 	throw new Error(`knowledge transaction contains an unsupported path: ${path}`);
 }
 function normalizeTransactionPath(path) {
@@ -1492,6 +1546,23 @@ const KnowledgeGraphEdgeSchema = z.object({
 	weight: z.number(),
 	reasons: z.array(z.string())
 });
+const KnowledgeRelationSchema = z.object({
+	sourceId: z.string(),
+	targetId: z.string(),
+	predicate: z.string(),
+	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(),
@@ -1600,13 +1671,7 @@ const KnowledgeBaseCandidateSchema = z.object({
 			]).optional(),
 			metadata: z.record(z.string(), z.unknown()).optional()
 		})).optional(),
-		relations: z.array(z.object({
-			sourceId: z.string(),
-			targetId: z.string(),
-			predicate: z.string(),
-			weight: z.number().optional(),
-			metadata: z.record(z.string(), z.unknown()).optional()
-		})).optional(),
+		relations: z.array(KnowledgeRelationSchema).optional(),
 		sourceIds: z.array(z.string()).optional(),
 		tags: z.array(z.string()).optional(),
 		metadata: z.record(z.string(), z.unknown()).optional(),
@@ -1691,7 +1756,7 @@ async function loadKnowledgePages(root, options = {}) {
 	return withKnowledgeRead(root, () => loadKnowledgePagesUnlocked(root, options));
 }
 async function loadKnowledgePagesUnlocked(root, options) {
-	const pagesDirectory = normalizePagesDirectory(options.pagesDirectory ?? "knowledge");
+	const pagesDirectory = normalizePagesDirectory(options.pagesDirectory);
 	let files;
 	try {
 		files = await listRegularFilesWithinRoot(root, pagesDirectory);
@@ -1700,36 +1765,48 @@ async function loadKnowledgePagesUnlocked(root, options) {
 		throw error;
 	}
 	const pages = [];
-	const pagesPrefix = `${pagesDirectory}/`;
 	for (const file of files) {
 		const rel = file.path.replace(/\\/g, "/");
-		if (!rel.endsWith(".md")) continue;
-		if (isScaffoldPath(rel)) continue;
-		const { frontmatter, body } = parseFrontmatter(file.bytes.toString("utf8"));
-		const title = stringField(frontmatter.title) ?? firstHeading(body) ?? rel.split("/").pop().replace(/\.md$/, "");
-		const sourceIds = arrayField(frontmatter.sources);
-		const tags = arrayField(frontmatter.tags);
-		const cites = idListField(frontmatter.cites);
-		const contradicts = idListField(frontmatter.contradicts);
-		const invalidation = KnowledgePageInvalidationSchema.safeParse(frontmatter.invalidation);
-		const pageRelativePath = rel.startsWith(pagesPrefix) ? rel.slice(pagesPrefix.length) : rel;
-		pages.push({
-			id: stringField(frontmatter.id) ?? slugify(pageRelativePath.replace(/\.md$/, "")),
-			path: rel,
-			title,
-			text: body,
-			frontmatter,
-			sourceIds,
-			tags,
-			outLinks: extractWikilinks(body).map(normalizeLinkTarget),
-			...cites.length > 0 ? { cites } : {},
-			...contradicts.length > 0 ? { contradicts } : {},
-			...invalidation.success ? { invalidation: invalidation.data } : {}
-		});
+		if (!isKnowledgePagePath(rel)) continue;
+		pages.push(knowledgePageFromMarkdown(rel, file.bytes.toString("utf8"), pagesDirectory));
 	}
 	pages.sort((a, b) => a.path.localeCompare(b.path));
 	return pages;
 }
+/** True when a root-relative path names authored Markdown rather than scaffolding. */
+function isKnowledgePagePath(path) {
+	const normalized = path.replace(/\\/g, "/");
+	return normalized.endsWith(".md") && !isScaffoldPath(normalized);
+}
+/**
+* Build a page from the bytes of one Markdown file.
+*
+* The reader and every gate that inspects a page before it is written share
+* this constructor, so what a gate judges is exactly what the store loads back.
+*/
+function knowledgePageFromMarkdown(path, content, pagesDirectory) {
+	const rel = path.replace(/\\/g, "/");
+	const pagesPrefix = `${normalizePagesDirectory(pagesDirectory)}/`;
+	const { frontmatter, body } = parseFrontmatter(content);
+	const title = stringField(frontmatter.title) ?? firstHeading(body) ?? rel.split("/").pop().replace(/\.md$/, "");
+	const cites = idListField(frontmatter.cites);
+	const contradicts = idListField(frontmatter.contradicts);
+	const invalidation = KnowledgePageInvalidationSchema.safeParse(frontmatter.invalidation);
+	const pageRelativePath = rel.startsWith(pagesPrefix) ? rel.slice(pagesPrefix.length) : rel;
+	return {
+		id: stringField(frontmatter.id) ?? slugify(pageRelativePath.replace(/\.md$/, "")),
+		path: rel,
+		title,
+		text: body,
+		frontmatter,
+		sourceIds: arrayField(frontmatter.sources),
+		tags: arrayField(frontmatter.tags),
+		outLinks: extractWikilinks(body).map(normalizeLinkTarget),
+		...cites.length > 0 ? { cites } : {},
+		...contradicts.length > 0 ? { contradicts } : {},
+		...invalidation.success ? { invalidation: invalidation.data } : {}
+	};
+}
 async function writeJson(path, value) {
 	await writeJsonDurable(path, value);
 }
@@ -1755,11 +1832,6 @@ async function knowledgeBaseInitialized(layout) {
 		throw error;
 	}
 }
-function normalizePagesDirectory(value) {
-	const normalized = value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
-	if (normalized.length === 0 || normalized === ".") throw new Error("pagesDirectory must name a root-relative directory");
-	return normalized;
-}
 function stringField(value) {
 	return typeof value === "string" && value.trim() !== "" ? value.trim() : void 0;
 }
@@ -1927,7 +1999,18 @@ function isPageOrigin(value) {
 }
 //#endregion
 //#region src/graph.ts
-function buildKnowledgeGraph(pages) {
+/**
+* The labeled relations between pages, one per `(sourceId, targetId, predicate)`.
+*
+* `wikilink`, `citation`, and `contradicts` follow an authored link, `cites`
+* entry, or `contradicts` entry to the one page it resolves to; a missing,
+* ambiguous, or self-referencing target emits nothing. `shared-source` joins
+* every pair of pages that registers a common source, in page order, weighted
+* 0.5 per shared source id, with the shared ids in `metadata.sourceIds`. It is
+* implicit, so it is listed after the authored relations and never counts
+* toward a page's degree in `buildKnowledgeGraph`.
+*/
+function knowledgePageRelations(pages) {
 	const bySlug = /* @__PURE__ */ new Map();
 	const byId = /* @__PURE__ */ new Map();
 	for (const page of pages) {
@@ -1936,26 +2019,93 @@ function buildKnowledgeGraph(pages) {
 		bySlug.set(normalizeLinkTarget(page.title), page);
 		bySlug.set(normalizeLinkTarget(page.path.split("/").pop().replace(/\.md$/, "")), page);
 	}
+	const authored = /* @__PURE__ */ new Map();
+	const count = (source, target, predicate) => {
+		const key = JSON.stringify([
+			source.id,
+			target.id,
+			predicate
+		]);
+		const relation = authored.get(key);
+		if (relation) relation.weight += 1;
+		else authored.set(key, {
+			sourceId: source.id,
+			targetId: target.id,
+			predicate,
+			weight: 1
+		});
+	};
+	const uniqueTarget = (id) => {
+		const targets = byId.get(id) ?? [];
+		return targets.length === 1 ? targets[0] : void 0;
+	};
+	for (const page of pages) {
+		for (const raw of page.outLinks) {
+			const target = bySlug.get(normalizeLinkTarget(raw));
+			if (!target || target.id === page.id) continue;
+			count(page, target, "wikilink");
+		}
+		for (const persisted of page.cites ?? []) {
+			const target = uniqueTarget(citedPageId(persisted));
+			if (!target || target.id === page.id) continue;
+			count(page, target, "citation");
+		}
+		for (const contradicted of page.contradicts ?? []) {
+			const target = uniqueTarget(contradicted);
+			if (!target || target.id === page.id) continue;
+			count(page, target, "contradicts");
+		}
+	}
+	const relations = [...authored.values()];
+	for (let i = 0; i < pages.length; i++) for (let j = i + 1; j < pages.length; j++) {
+		const a = pages[i];
+		const b = pages[j];
+		const overlap = a.sourceIds.filter((source) => b.sourceIds.includes(source));
+		if (overlap.length === 0) continue;
+		relations.push({
+			sourceId: a.id,
+			targetId: b.id,
+			predicate: "shared-source",
+			weight: overlap.length * .5,
+			metadata: { sourceIds: overlap }
+		});
+	}
+	return relations;
+}
+/**
+* The weighted page graph: `knowledgePageRelations` collapsed to one edge per
+* ordered page pair, with the predicates merged into `reasons` and the weights
+* summed. `contradicts` stays out of this projection; read it from the relation
+* list. Node degrees count the authored `wikilink` and `citation` occurrences.
+*/
+function buildKnowledgeGraph(pages) {
 	const incoming = /* @__PURE__ */ new Map();
 	const outgoing = /* @__PURE__ */ new Map();
-	const edgesByKey = /* @__PURE__ */ new Map();
 	for (const page of pages) {
 		outgoing.set(page.id, 0);
 		incoming.set(page.id, 0);
 	}
-	for (const page of pages) {
-		for (const raw of page.outLinks) {
-			const target = bySlug.get(normalizeLinkTarget(raw));
-			if (!target || target.id === page.id) continue;
-			addDirectedEdge(page, target, "wikilink", edgesByKey, incoming, outgoing);
+	const edgesByKey = /* @__PURE__ */ new Map();
+	for (const relation of knowledgePageRelations(pages)) {
+		if (relation.predicate === "contradicts") continue;
+		const key = `${relation.sourceId}->${relation.targetId}`;
+		let edge = edgesByKey.get(key);
+		if (!edge) {
+			edge = {
+				source: relation.sourceId,
+				target: relation.targetId,
+				weight: 0,
+				reasons: []
+			};
+			edgesByKey.set(key, edge);
 		}
-		for (const persisted of page.cites ?? []) {
-			const targets = byId.get(citedPageId(persisted)) ?? [];
-			if (targets.length !== 1 || targets[0].id === page.id) continue;
-			addDirectedEdge(page, targets[0], "citation", edgesByKey, incoming, outgoing);
+		edge.weight += relation.weight;
+		if (!edge.reasons.includes(relation.predicate)) edge.reasons.push(relation.predicate);
+		if (relation.predicate === "wikilink" || relation.predicate === "citation") {
+			outgoing.set(relation.sourceId, (outgoing.get(relation.sourceId) ?? 0) + relation.weight);
+			incoming.set(relation.targetId, (incoming.get(relation.targetId) ?? 0) + relation.weight);
 		}
 	}
-	addSourceOverlapEdges(pages, edgesByKey);
 	return {
 		nodes: pages.map((page) => ({
 			id: page.id,
@@ -1982,40 +2132,6 @@ function citedPageId(persisted) {
 		return persisted;
 	}
 }
-function addDirectedEdge(source, target, reason, edges, incoming, outgoing) {
-	const key = `${source.id}->${target.id}`;
-	const edge = edges.get(key);
-	if (edge) {
-		edge.weight += 1;
-		if (!edge.reasons.includes(reason)) edge.reasons.push(reason);
-	} else edges.set(key, {
-		source: source.id,
-		target: target.id,
-		weight: 1,
-		reasons: [reason]
-	});
-	outgoing.set(source.id, (outgoing.get(source.id) ?? 0) + 1);
-	incoming.set(target.id, (incoming.get(target.id) ?? 0) + 1);
-}
-function addSourceOverlapEdges(pages, edges) {
-	for (let i = 0; i < pages.length; i++) for (let j = i + 1; j < pages.length; j++) {
-		const a = pages[i];
-		const b = pages[j];
-		const overlap = a.sourceIds.filter((source) => b.sourceIds.includes(source));
-		if (overlap.length === 0) continue;
-		const key = `${a.id}->${b.id}`;
-		const edge = edges.get(key);
-		if (edge) {
-			edge.weight += overlap.length * .5;
-			if (!edge.reasons.includes("shared-source")) edge.reasons.push("shared-source");
-		} else edges.set(key, {
-			source: a.id,
-			target: b.id,
-			weight: overlap.length * .5,
-			reasons: ["shared-source"]
-		});
-	}
-}
 //#endregion
 //#region src/kb-store.ts
 /**
@@ -2546,11 +2662,11 @@ function textPreview(fileName, bytes) {
 }
 //#endregion
 //#region src/indexer.ts
-async function buildKnowledgeIndex(root) {
-	return withKnowledgeRead(root, () => buildKnowledgeIndexUnlocked(root));
+async function buildKnowledgeIndex(root, options = {}) {
+	return withKnowledgeRead(root, () => buildKnowledgeIndexUnlocked(root, options));
 }
-async function buildKnowledgeIndexUnlocked(root) {
-	const [pages, sourceRegistry] = await Promise.all([loadKnowledgePages(root), loadSourceRegistry(root)]);
+async function buildKnowledgeIndexUnlocked(root, options) {
+	const [pages, sourceRegistry] = await Promise.all([loadKnowledgePages(root, options), loadSourceRegistry(root)]);
 	return {
 		root,
 		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -2568,9 +2684,9 @@ async function buildKnowledgeIndexUnlocked(root) {
 * a store-based reader saw none of the indexer's work. One writer now, and it
 * validates through `KnowledgeIndexSchema` on the way out.
 */
-async function writeKnowledgeIndex(root) {
+async function writeKnowledgeIndex(root, options = {}) {
 	return withKnowledgeMutation(root, async () => {
-		const index = await buildKnowledgeIndexUnlocked(root);
+		const index = await buildKnowledgeIndexUnlocked(root, options);
 		await new FileSystemKbStore({ root }).putIndex(index);
 		return index;
 	});
@@ -2765,9 +2881,11 @@ function lintKnowledgeIndex(index) {
 	const sourceIds = new Set(index.sources.map((source) => source.id));
 	const anchorIds = new Map(index.sources.map((source) => [source.id, new Set((source.anchors ?? []).map((anchor) => anchor.id))]));
 	const pageIds = /* @__PURE__ */ new Map();
+	const invalidatedIds = /* @__PURE__ */ new Set();
 	const sourceHashes = /* @__PURE__ */ new Map();
 	for (const page of index.pages) {
 		pageIds.set(page.id, [...pageIds.get(page.id) ?? [], page.path]);
+		if (page.invalidation !== void 0) invalidatedIds.add(page.id);
 		byTarget.add(normalizeLinkTarget(page.id));
 		byTarget.add(normalizeLinkTarget(page.title));
 		byTarget.add(normalizeLinkTarget(page.path.split("/").pop().replace(/\.md$/, "")));
@@ -2829,6 +2947,7 @@ function lintKnowledgeIndex(index) {
 		findings.push(...lintPageEvidence(page));
 		findings.push(...lintPageContradictions(page, pageIds));
 		findings.push(...lintPageInvalidation(page));
+		findings.push(...lintPageInvalidatedCitations(page, pageIds, invalidatedIds));
 	}
 	for (const [title, paths] of titles) if (title && paths.length > 1) findings.push({
 		type: "duplicate-title",
@@ -2915,6 +3034,24 @@ function lintPageContradictions(page, pageIds) {
 	}
 	return findings;
 }
+/**
+* A citation into a page its own evidence refuted.
+*
+* The verdict lives on the cited page, so a reader arriving through the
+* citation never meets it. Ambiguous ids are left to the citation audit, which
+* owns that verdict.
+*/
+function lintPageInvalidatedCitations(page, pageIds, invalidatedIds) {
+	const targetIds = [...new Set((page.cites ?? []).map((persisted) => parseKnowledgeCitationReference(persisted).pageId))].filter((targetId) => targetId !== page.id && pageIds.get(targetId)?.length === 1 && invalidatedIds.has(targetId)).sort();
+	if (targetIds.length === 0) return [];
+	return [{
+		type: "cites-invalidated",
+		severity: "warning",
+		page: page.path,
+		message: `Page cites invalidated ${targetIds.length === 1 ? "page" : "pages"} ${targetIds.join(", ")}.`,
+		metadata: { targetIds }
+	}];
+}
 function lintPageInvalidation(page) {
 	if (page.frontmatter.invalidation === void 0) return [];
 	const parsed = KnowledgePageInvalidationSchema.safeParse(page.frontmatter.invalidation);
@@ -2973,6 +3110,420 @@ function validateKnowledgeIndex(index, options = {}) {
 	};
 }
 //#endregion
+//#region src/rag-eval/near-duplicates.ts
+/**
+* Detect exact and near-duplicate pages without a model, embedding service, or clock.
+*
+* The detector uses word shingles when prose has enough tokens and Unicode
+* character shingles otherwise. An inverted index proposes candidate pairs;
+* high-document-frequency shingles are ignored so common boilerplate cannot
+* make candidate generation quadratic. Exact normalized copies are always
+* proposed before ordinary shingle candidates, even when every shingle is
+* common. Every limit and sort order is explicit so the same corpus produces
+* the same report on every run.
+*/
+function detectNearDuplicatePages(pages, options = {}) {
+	const threshold = finiteUnitInterval(options.threshold ?? .82, "threshold");
+	const minCharacters = nonNegativeInteger(options.minCharacters ?? 80, "minCharacters");
+	const wordShingleSize = positiveInteger(options.wordShingleSize ?? 5, "wordShingleSize");
+	const characterShingleSize = positiveInteger(options.characterShingleSize ?? 16, "characterShingleSize");
+	const maxDocumentFrequency = positiveInteger(options.maxDocumentFrequency ?? 64, "maxDocumentFrequency");
+	const maxCandidatePairs = positiveInteger(options.maxCandidatePairs ?? 25e4, "maxCandidatePairs");
+	const maxReportedPairs = nonNegativeInteger(options.maxReportedPairs ?? 1e3, "maxReportedPairs");
+	const prepared = pages.map((page) => preparePage(page, wordShingleSize, characterShingleSize)).filter((item) => item !== null && item.normalized.length >= minCharacters).sort((left, right) => left.page.path.localeCompare(right.page.path));
+	const candidateKeys = /* @__PURE__ */ new Set();
+	const exactGroups = /* @__PURE__ */ new Map();
+	const byShingle = /* @__PURE__ */ new Map();
+	for (const [index, item] of prepared.entries()) {
+		exactGroups.set(item.normalized, [...exactGroups.get(item.normalized) ?? [], index]);
+		for (const shingle of item.shingles) byShingle.set(shingle, [...byShingle.get(shingle) ?? [], index]);
+	}
+	let truncated = false;
+	const addPair = (left, right) => {
+		if (left === right) return true;
+		const key = pairKey(Math.min(left, right), Math.max(left, right));
+		if (candidateKeys.has(key)) return true;
+		if (candidateKeys.size >= maxCandidatePairs) {
+			truncated = true;
+			return false;
+		}
+		candidateKeys.add(key);
+		return true;
+	};
+	for (const normalized of [...exactGroups.keys()].sort()) if (!addGroupPairs(exactGroups.get(normalized), addPair)) break;
+	if (!truncated) for (const shingle of [...byShingle.keys()].sort()) {
+		const group = byShingle.get(shingle);
+		if (group.length > maxDocumentFrequency) continue;
+		if (!addGroupPairs(group, addPair)) break;
+	}
+	const duplicatePageIndices = /* @__PURE__ */ new Set();
+	const pairs = [];
+	let duplicatePairCount = 0;
+	let comparedPairCount = 0;
+	for (const key of [...candidateKeys].sort(pairKeyOrder)) {
+		const [leftIndex, rightIndex] = parsePairKey(key);
+		const left = prepared[leftIndex];
+		const right = prepared[rightIndex];
+		comparedPairCount += 1;
+		const exact = left.normalized === right.normalized;
+		const overlap = jaccard(left.shingles, right.shingles);
+		if (!exact && overlap.similarity < threshold) continue;
+		duplicatePairCount += 1;
+		duplicatePageIndices.add(leftIndex);
+		duplicatePageIndices.add(rightIndex);
+		if (pairs.length >= maxReportedPairs) {
+			truncated = true;
+			continue;
+		}
+		pairs.push({
+			leftPageId: left.page.id,
+			leftPath: left.page.path,
+			rightPageId: right.page.id,
+			rightPath: right.page.path,
+			similarity: exact ? 1 : round(overlap.similarity),
+			intersectionSize: overlap.intersectionSize,
+			unionSize: overlap.unionSize,
+			exact
+		});
+	}
+	pairs.sort((left, right) => right.similarity - left.similarity || left.leftPath.localeCompare(right.leftPath) || left.rightPath.localeCompare(right.rightPath));
+	return {
+		algorithm: "deterministic-shingle-jaccard-v1",
+		threshold,
+		pageCount: pages.length,
+		eligiblePageCount: prepared.length,
+		candidatePairCount: candidateKeys.size,
+		comparedPairCount,
+		duplicatePairCount,
+		duplicatePageCount: duplicatePageIndices.size,
+		duplicatePageRate: prepared.length === 0 ? 0 : round(duplicatePageIndices.size / prepared.length),
+		truncated,
+		pairs
+	};
+}
+function preparePage(page, wordShingleSize, characterShingleSize) {
+	const normalized = normalizePageText(`${page.title}\n${page.text}`);
+	if (normalized.length === 0) return null;
+	const words = normalized.match(/[\p{L}\p{N}]+/gu) ?? [];
+	const shingles = words.length >= wordShingleSize + 2 ? sequenceShingles(words, wordShingleSize) : characterShingles(normalized.replace(/\s+/g, ""), characterShingleSize);
+	if (shingles.size === 0) shingles.add(normalized);
+	return {
+		page,
+		normalized,
+		shingles
+	};
+}
+function normalizePageText(value) {
+	return value.normalize("NFKC").toLowerCase().replace(/https?:\/\/\S+/g, "<url>").replace(/\s+/g, " ").trim();
+}
+function sequenceShingles(items, width) {
+	const out = /* @__PURE__ */ new Set();
+	if (items.length < width) return out;
+	for (let index = 0; index <= items.length - width; index += 1) out.add(items.slice(index, index + width).join(""));
+	return out;
+}
+function characterShingles(value, width) {
+	const chars = [...value];
+	const out = /* @__PURE__ */ new Set();
+	if (chars.length < width) return out;
+	for (let index = 0; index <= chars.length - width; index += 1) out.add(chars.slice(index, index + width).join(""));
+	return out;
+}
+function addGroupPairs(group, add) {
+	for (let left = 0; left < group.length; left += 1) for (let right = left + 1; right < group.length; right += 1) if (!add(group[left], group[right])) return false;
+	return true;
+}
+function jaccard(left, right) {
+	const [small, large] = left.size <= right.size ? [left, right] : [right, left];
+	let intersectionSize = 0;
+	for (const item of small) if (large.has(item)) intersectionSize += 1;
+	const unionSize = left.size + right.size - intersectionSize;
+	return {
+		similarity: unionSize === 0 ? 1 : intersectionSize / unionSize,
+		intersectionSize,
+		unionSize
+	};
+}
+function pairKey(left, right) {
+	return `${left}:${right}`;
+}
+function parsePairKey(value) {
+	const [left, right] = value.split(":");
+	return [Number(left), Number(right)];
+}
+function pairKeyOrder(left, right) {
+	const [leftA, leftB] = parsePairKey(left);
+	const [rightA, rightB] = parsePairKey(right);
+	return leftA - rightA || leftB - rightB;
+}
+function finiteUnitInterval(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 positiveInteger(value, name) {
+	if (!Number.isInteger(value) || value < 1) throw new Error(`${name} must be a positive integer`);
+	return value;
+}
+function nonNegativeInteger(value, name) {
+	if (!Number.isInteger(value) || value < 0) throw new Error(`${name} must be a non-negative integer`);
+	return value;
+}
+function round(value) {
+	return Math.round(value * 1e6) / 1e6;
+}
+//#endregion
+//#region src/run-scoped.ts
+/**
+* Run-scoped knowledge stores with lineage-chain reads.
+*
+* One store exists per run, physically isolated, with inheritance only through
+* declared ancestry. Reads expose the current store, every declared ancestor,
+* and an optional curated shared store with an explicit origin label.
+*/
+/**
+* Present plain pages as a visibility chain of one origin.
+*
+* A store read directly is the `here` origin of a chain with no ancestry, so
+* the chain-shaped APIs — citation resolution, the write intake gate,
+* invalidation propagation — take one page shape whether or not the caller
+* runs run-scoped stores.
+*/
+function originatedPages(pages, origin = "here") {
+	return pages.map((page) => ({
+		page,
+		origin
+	}));
+}
+const RUN_LINEAGE_BASENAME = "lineage.json";
+/** Ancestry beyond this bound is invalid durable state. */
+const MAX_LINEAGE_HOPS = 64;
+function createRunScopedStores(options) {
+	if (!options || typeof options !== "object") throw new TypeError("createRunScopedStores options are required");
+	if (typeof options.root !== "string" || options.root.trim().length === 0) throw new TypeError("createRunScopedStores root must be a non-empty string");
+	if (options.runStorePath !== void 0 && typeof options.runStorePath !== "function") throw new TypeError("createRunScopedStores runStorePath must be a function when present");
+	if (options.lineageAuthority !== void 0) validateLineageAuthority(options.lineageAuthority);
+	const pagesDirectory = normalizePagesDirectory(options.pagesDirectory);
+	const storePath = options.runStorePath ?? ((runId) => join(options.root, runId, "knowledge-base"));
+	const internalAuthority = createFileRunLineageAuthority(storePath);
+	const authority = options.lineageAuthority ?? internalAuthority;
+	const resolveLineage = async (runId) => {
+		assertRunId(runId);
+		const chain = [];
+		const seen = /* @__PURE__ */ new Set([runId]);
+		let current = runId;
+		for (let hop = 0; hop <= MAX_LINEAGE_HOPS; hop += 1) {
+			const parent = await authority.parentOf(current);
+			if (parent === null) return chain;
+			assertRunId(parent, `parent of '${current}'`);
+			if (seen.has(parent)) throw new Error(`run lineage cycle: ${parent} is its own ancestor (via ${runId})`);
+			seen.add(parent);
+			chain.push(parent);
+			current = parent;
+		}
+		throw new Error(`run lineage for '${runId}' exceeds ${MAX_LINEAGE_HOPS} ancestors`);
+	};
+	return {
+		storePath(runId) {
+			assertRunId(runId);
+			return storePath(runId);
+		},
+		async init(runId, initOptions = {}) {
+			assertRunId(runId);
+			const parentRunId = initOptions.parentRunId ?? null;
+			if (parentRunId !== null) assertRunId(parentRunId, `parent of '${runId}'`);
+			if (!authority.record) {
+				const existingParent = await authority.parentOf(runId);
+				if (existingParent !== parentRunId) throw new Error(`external lineage authority disagrees for '${runId}': expected ${renderParent(parentRunId)}, observed ${renderParent(existingParent)}`);
+			}
+			const layout = await initKnowledgeBase(storePath(runId));
+			if (authority.record) await authority.record(Object.freeze({
+				runId,
+				parentRunId,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString()
+			}));
+			return layout;
+		},
+		lineage: resolveLineage,
+		async loadChain(runId) {
+			assertRunId(runId);
+			const out = [];
+			const readInto = async (root, origin) => {
+				let pages;
+				try {
+					pages = await loadKnowledgePages(root, { pagesDirectory });
+				} catch (error) {
+					if (isMissingFile(error)) return;
+					throw error;
+				}
+				for (const page of pages) out.push({
+					page,
+					origin
+				});
+			};
+			await readInto(storePath(runId), "here");
+			for (const ancestor of await resolveLineage(runId)) await readInto(storePath(ancestor), `inherited:${ancestor}`);
+			if (options.sharedRoot) await readInto(options.sharedRoot, "shared");
+			return out;
+		}
+	};
+}
+/** File-backed authority used when the product has no separate run manifest. */
+function createFileRunLineageAuthority(runStorePath) {
+	if (typeof runStorePath !== "function") throw new TypeError("createFileRunLineageAuthority requires a runStorePath function");
+	const readRecord = async (runId) => {
+		assertRunId(runId);
+		const root = runStorePath(runId);
+		try {
+			return parseLineageRecord((await readRegularFileWithinRoot(root, RUN_LINEAGE_BASENAME)).bytes.toString("utf8"), runId);
+		} catch (error) {
+			if (isMissingFile(error)) return null;
+			throw error;
+		}
+	};
+	return {
+		async parentOf(runId) {
+			return (await readRecord(runId))?.parentRunId ?? null;
+		},
+		async record(record) {
+			const validated = validateLineageRecord(record);
+			const root = runStorePath(validated.runId);
+			await withKnowledgeMutation(root, async () => {
+				const existing = await readRecord(validated.runId);
+				if (existing) {
+					if (existing.parentRunId !== validated.parentRunId) throw new Error(`run lineage conflict for '${validated.runId}': existing parent ${renderParent(existing.parentRunId)}, requested ${renderParent(validated.parentRunId)}`);
+					return;
+				}
+				await writeJson(join(root, RUN_LINEAGE_BASENAME), validated);
+			});
+		}
+	};
+}
+function validateLineageAuthority(authority) {
+	if (!authority || typeof authority !== "object") throw new TypeError("lineageAuthority must be an object");
+	if (typeof authority.parentOf !== "function") throw new TypeError("lineageAuthority.parentOf must be a function");
+	if (authority.record !== void 0 && typeof authority.record !== "function") throw new TypeError("lineageAuthority.record must be a function when present");
+}
+function parseLineageRecord(text, expectedRunId) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch (cause) {
+		throw new Error(`invalid lineage JSON for '${expectedRunId}'`, { cause });
+	}
+	const record = validateLineageRecord(parsed);
+	if (record.runId !== expectedRunId) throw new Error(`lineage record identity mismatch: expected '${expectedRunId}', found '${record.runId}'`);
+	return record;
+}
+function validateLineageRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("run lineage record must be an object");
+	const record = value;
+	assertRunId(record.runId, "lineage record runId");
+	if (record.parentRunId !== null) assertRunId(record.parentRunId, `parent of '${record.runId}'`);
+	if (typeof record.createdAt !== "string" || record.createdAt.trim().length === 0 || !Number.isFinite(Date.parse(record.createdAt))) throw new TypeError("run lineage record createdAt must be an ISO timestamp");
+	return {
+		runId: record.runId,
+		parentRunId: record.parentRunId,
+		createdAt: record.createdAt
+	};
+}
+function assertRunId(value, label = "runId") {
+	if (typeof value !== "string" || value.trim().length === 0) throw new TypeError(`${label} must be a non-empty string`);
+	const trimmed = value.trim();
+	if (trimmed === "." || trimmed === ".." || /[/\\\0]/.test(value)) throw new TypeError(`${label} must not contain path separators or dot segments`);
+}
+function renderParent(parentRunId) {
+	return parentRunId === null ? "none" : `'${parentRunId}'`;
+}
+//#endregion
+//#region src/write-intake.ts
+/**
+* Write-time intake gate.
+*
+* A store degrades in two ways that no post-hoc report reverses: a page lands
+* that restates knowledge already present without relating itself to it, and a
+* page lands citing an id that exists nowhere. Both are cheap to refuse at the
+* moment of the write and expensive to repair afterwards, so the gate runs
+* before bytes are committed.
+*/
+/**
+* A write duplicates visible knowledge and declares no relation to it.
+*
+* Every listed pair is cleared by one authoring action: cite the matched page,
+* name it in `contradicts`, or give the candidate the matched page's id so the
+* write is an update of it.
+*/
+var KnowledgeDuplicateIntakeError = class extends Error {
+	pairs;
+	threshold;
+	constructor(pairs, threshold) {
+		const summary = pairs.map((pair) => `${pair.candidatePath} ~ ${pair.matchedPath} (${pair.exact ? "exact copy" : pair.similarity.toFixed(3)})`).join("; ");
+		super(`knowledge write intake refused ${pairs.length} duplicate ${pairs.length === 1 ? "pair" : "pairs"}: ${summary}. Cite the matched page, name it in contradicts, or reuse its id to update it.`);
+		this.name = "KnowledgeDuplicateIntakeError";
+		this.pairs = Object.freeze([...pairs]);
+		this.threshold = threshold;
+	}
+};
+/**
+* Refuse a write that duplicates visible knowledge or cites a page that exists
+* nowhere.
+*
+* The candidates are part of the corpus both checks see, so a batch may cite a
+* page it writes in the same call, and two candidates that duplicate each other
+* are caught before either lands.
+*
+* Returns the resolved citation candidates in the order the candidates declare
+* them.
+*/
+function assertKnowledgeWriteIntake(candidates, options) {
+	if (!Array.isArray(candidates)) throw new TypeError("knowledge write intake candidates must be an array");
+	if (!options || typeof options !== "object" || !Array.isArray(options.visiblePages)) throw new TypeError("knowledge write intake requires the visible pages of the target chain");
+	const candidatePaths = new Set(candidates.map((candidate) => candidate.path));
+	const corpus = [...options.visiblePages.filter((entry) => !(entry.origin === "here" && candidatePaths.has(entry.page.path))), ...candidates.map((page) => ({
+		page,
+		origin: "here"
+	}))];
+	assertNoUnrelatedDuplicate(candidatePaths, corpus, options.nearDuplicates ?? {});
+	if (options.citations === false) return Object.freeze([]);
+	return assertKnowledgeCitationsResolved(corpus, candidates.flatMap((candidate) => (candidate.cites ?? []).map((persisted) => parseKnowledgeCitationReference(persisted))));
+}
+function assertNoUnrelatedDuplicate(candidatePaths, corpus, nearDuplicates) {
+	if (candidatePaths.size === 0) return;
+	const report = detectNearDuplicatePages(corpus.map((entry) => entry.page), nearDuplicates);
+	const byIdentity = /* @__PURE__ */ new Map();
+	for (const entry of corpus) {
+		const key = identityKey(entry.page.path, entry.page.id);
+		if (!byIdentity.has(key)) byIdentity.set(key, entry.page);
+	}
+	const offending = [];
+	for (const pair of report.pairs) {
+		const leftIsCandidate = candidatePaths.has(pair.leftPath);
+		if (!leftIsCandidate && !candidatePaths.has(pair.rightPath)) continue;
+		if (pair.leftPageId === pair.rightPageId) continue;
+		const left = byIdentity.get(identityKey(pair.leftPath, pair.leftPageId));
+		const right = byIdentity.get(identityKey(pair.rightPath, pair.rightPageId));
+		if (declaresRelation(left, right.id) || declaresRelation(right, left.id)) continue;
+		const candidate = leftIsCandidate ? left : right;
+		const matched = leftIsCandidate ? right : left;
+		offending.push({
+			candidatePageId: candidate.id,
+			candidatePath: candidate.path,
+			matchedPageId: matched.id,
+			matchedPath: matched.path,
+			similarity: pair.similarity,
+			exact: pair.exact
+		});
+	}
+	if (offending.length > 0) throw new KnowledgeDuplicateIntakeError(offending, report.threshold);
+}
+function identityKey(path, id) {
+	return `${path}\u0000${id}`;
+}
+/** Whether `page` already relates itself to `targetId` through `cites` or `contradicts`. */
+function declaresRelation(page, targetId) {
+	for (const persisted of page.cites ?? []) if (parseKnowledgeCitationReference(persisted).pageId === targetId) return true;
+	return (page.contradicts ?? []).includes(targetId);
+}
+//#endregion
 //#region src/write-protocol.ts
 const OPENER_LINE = /^---\s*FILE:\s*(.+?)\s*---\s*$/i;
 const CLOSER_LINE = /^---\s*END\s+FILE\s*---\s*$/i;
@@ -3048,28 +3599,49 @@ function parseKnowledgeWriteBlocks(text, allowedPrefixes = ["knowledge/"]) {
 }
 //#endregion
 //#region src/proposals.ts
-async function applyKnowledgeWriteBlocks(root, proposalText) {
-	const parsed = parseKnowledgeWriteBlocks(proposalText);
+/**
+* Apply the FILE blocks of a proposal under the pages directory.
+*
+* A block whose path lies outside `<pagesDirectory>/` is refused by the parser
+* and again by the file transaction, so one option value bounds the whole
+* write.
+*/
+async function applyKnowledgeWriteBlocks(root, proposalText, options = {}) {
+	const pagesDirectory = normalizePagesDirectory(options.pagesDirectory);
+	const parsed = parseKnowledgeWriteBlocks(proposalText, [`${pagesDirectory}/`]);
 	const purpose = `knowledge-proposal:${contentHash(parsed.blocks)}`;
+	const intake = options.intake;
 	return withKnowledgeMutation(root, async (lock) => {
-		if (parsed.blocks.length > 0) await commitKnowledgeFileMutations({
-			root,
-			transactionRoot: lock.transactionRoot,
-			purpose,
-			mutations: parsed.blocks.map((block) => ({
+		if (parsed.blocks.length > 0) {
+			const mutations = parsed.blocks.map((block) => ({
 				path: block.path,
 				content: block.content.endsWith("\n") ? block.content : `${block.content}\n`
-			})),
-			assertOwned: lock.assertOwned
-		});
+			}));
+			if (intake) {
+				const { inheritedPages = [], ...settings } = intake;
+				const here = await loadKnowledgePages(root, { pagesDirectory });
+				assertKnowledgeWriteIntake(mutations.filter((mutation) => isKnowledgePagePath(mutation.path)).map((mutation) => knowledgePageFromMarkdown(mutation.path, mutation.content, pagesDirectory)), {
+					...settings,
+					visiblePages: [...originatedPages(here), ...inheritedPages]
+				});
+			}
+			await commitKnowledgeFileMutations({
+				root,
+				transactionRoot: lock.transactionRoot,
+				purpose,
+				mutations,
+				pagesDirectory,
+				assertOwned: lock.assertOwned
+			});
+		}
 		return {
 			written: parsed.blocks.map((block) => block.path),
 			warnings: parsed.warnings
 		};
 	}, { resumeTransaction: { purpose } });
 }
-async function applyKnowledgeWriteBlocksFile(root, proposalPath) {
-	return applyKnowledgeWriteBlocks(root, await readFile(proposalPath, "utf8"));
+async function applyKnowledgeWriteBlocksFile(root, proposalPath, options = {}) {
+	return applyKnowledgeWriteBlocks(root, await readFile(proposalPath, "utf8"), options);
 }
 //#endregion
 //#region src/metadata.ts
@@ -3149,6 +3721,6 @@ function explainKnowledgeTarget(index, target) {
 	};
 }
 //#endregion
-export { WIKILINK_REGEX as $, syncDirectory as $t, MemoryKbStore as A, mergeTrackedClaims as At, auditKnowledgeCitations as B, applyKnowledgeFileTransaction as Bt, writeSourceRegistry as C, claimId as Ct, KB_EVENTS_PATH as D, linkClaimContradictions as Dt, KB_CLAIM_LEDGER_DIR as E, emptyClaimLedger as Et, assertCurrentRunCitationsResolved as F, acquireDurableFileLock as Ft, resolveRunScopedCitation as G, rollbackKnowledgeFileTransaction as Gt, parseKnowledgeCitationReference as H, finishKnowledgeFileTransaction as Ht, assertKnowledgeCitationAudit as I, inspectPendingKnowledgeMutation as It, initKnowledgeBase as J, listRegularFilesWithinRoot as Jt, resolveRunScopedCitations as K, isKernelAnchoredPath as Kt, assertKnowledgeCitationsResolved as L, recoverPendingKnowledgeMutation as Lt, buildKnowledgeGraph as M, researchSourceVersionKey as Mt, KnowledgeCitationAuditError as N, formatFrontmatter as Nt, KB_INDEX_PATH as O, materializeRegisteredClaimEvidence as Ot, KnowledgeCitationResolutionError as P, parseFrontmatter as Pt, writeJson as Q, renameDurable as Qt, assertRunScopedCitationsResolved as R, withKnowledgeMutation as Rt, sourceRegistryPath as S, claimEvidenceId as St, FileSystemKbStore as T, deepQuestionId as Tt, resolveKnowledgeCitation as U, knowledgeFileTransactionPlanHash as Ut, formatKnowledgeCitationReference as V, assertKnowledgeMutationPath as Vt, resolveKnowledgeCitations as W, prepareKnowledgeFileTransaction as Wt, layoutFor as X, readRegularFileWithinRoot as Xt, isScaffoldPath as Y, readRegularFileNoFollow as Yt, loadKnowledgePages as Z, removeDurable as Zt, writeKnowledgeIndex as _, ClaimLedgerGoalConflictError as _t, applyKnowledgeWriteBlocksFile as a, writeJsonDurableWithinRoot as an, KnowledgeGraphEdgeSchema as at, loadSourceRegistry as b, assertResearchClaimLedgerIntegrity as bt, validateKnowledgeIndex as c, KnowledgePageInvalidationSchema as ct, UncheckableClaimError as d, ResearchClaimLedgerSchema as dt, withSafeDescendant as en, extractWikilinks as et, assertGradeableEvidence as f, ResearchClaimRecordSchema as ft, buildKnowledgeIndex as g, KNOWLEDGE_EVENT_TYPES as gt, verifyGradeableEvidence as h, SourceRecordSchema as ht, applyKnowledgeWriteBlocks as i, writeJsonDurable as in, KnowledgeEventSchema as it, assertClaimLedgerId as j, normalizeClaimText as jt, KB_STORE_DIR as k, mergeClaimLedgers as kt, lintKnowledgeIndex as l, KnowledgePageSchema as lt, verdictFor as m, SourceAnchorSchema as mt, inspectKnowledgeIndex as n, writeFileDurable as nn, DeepQuestionSchema as nt, isSafeKnowledgePath as o, mediaTypeFor$1 as on, KnowledgeGraphNodeSchema as ot, gradeFor as p, ResearchSourceVersionSchema as pt, SCAFFOLD_PAGE_BASENAMES as q, isMissingFile as qt, stringMetadata as r, writeFileDurableWithinRoot as rn, KnowledgeBaseCandidateSchema as rt, parseKnowledgeWriteBlocks as s, textSourceAdapter as sn, KnowledgeIndexSchema as st, explainKnowledgeTarget as t, withSafeDirectory as tn, normalizeLinkTarget as tt, CHECKABLE_RUNG_THRESHOLD as u, ResearchClaimEvidenceSchema as ut, addSourcePath as v, assertDeepQuestionIntegrity as vt, ClaimLedgerMigrationRequiredError as w, claimSourceHost as wt, snapshotSourceTextInput as x, assertTrackedClaimIntegrity as xt, addSourceText as y, assertResearchClaimEvidenceIntegrity as yt, auditCurrentRunCitations as z, withKnowledgeRead as zt };
+export { resolveKnowledgeCitations as $, withKnowledgeRead as $t, sourceRegistryPath as A, KNOWLEDGE_EVENT_TYPES as At, buildKnowledgeGraph as B, emptyClaimLedger as Bt, verifyGradeableEvidence as C, mediaTypeFor$1 as Cn, KnowledgeRelationSchema as Ct, addSourceText as D, ResearchSourceVersionSchema as Dt, addSourcePath as E, ResearchClaimRecordSchema as Et, KB_EVENTS_PATH as F, assertTrackedClaimIntegrity as Ft, assertKnowledgeCitationAudit as G, normalizeClaimText as Gt, KnowledgeCitationAuditError as H, materializeRegisteredClaimEvidence as Ht, KB_INDEX_PATH as I, claimEvidenceId as It, auditCurrentRunCitations as J, parseFrontmatter as Jt, assertKnowledgeCitationsResolved as K, researchSourceVersionKey as Kt, KB_STORE_DIR as L, claimId as Lt, ClaimLedgerMigrationRequiredError as M, assertDeepQuestionIntegrity as Mt, FileSystemKbStore as N, assertResearchClaimEvidenceIntegrity as Nt, loadSourceRegistry as O, SourceAnchorSchema as Ot, KB_CLAIM_LEDGER_DIR as P, assertResearchClaimLedgerIntegrity as Pt, resolveKnowledgeCitation as Q, withKnowledgeMutation as Qt, MemoryKbStore as R, claimSourceHost as Rt, verdictFor as S, writeJsonDurableWithinRoot as Sn, KnowledgeRelationNodeSchema as St, writeKnowledgeIndex as T, ResearchClaimLedgerSchema as Tt, KnowledgeCitationResolutionError as U, mergeClaimLedgers as Ut, knowledgePageRelations as V, linkClaimContradictions as Vt, assertCurrentRunCitationsResolved as W, mergeTrackedClaims as Wt, formatKnowledgeCitationReference as X, inspectPendingKnowledgeMutation as Xt, auditKnowledgeCitations as Y, acquireDurableFileLock as Yt, parseKnowledgeCitationReference as Z, recoverPendingKnowledgeMutation as Zt, lintKnowledgeIndex as _, withSafeDescendant as _n, KnowledgeGraphNodeSchema as _t, applyKnowledgeWriteBlocksFile as a, prepareKnowledgeFileTransaction as an, isScaffoldPath as at, assertGradeableEvidence as b, writeFileDurableWithinRoot as bn, KnowledgePageSchema as bt, KnowledgeDuplicateIntakeError as c, normalizePagesDirectory as cn, loadKnowledgePages as ct, createFileRunLineageAuthority as d, listRegularFilesWithinRoot as dn, extractWikilinks as dt, applyKnowledgeFileTransaction as en, resolveRunScopedCitation as et, createRunScopedStores as f, readRegularFileNoFollow as fn, normalizeLinkTarget as ft, validateKnowledgeIndex as g, syncDirectory as gn, KnowledgeGraphEdgeSchema as gt, normalizePageText as h, renameDurable as hn, KnowledgeEventSchema as ht, applyKnowledgeWriteBlocks as i, knowledgeFileTransactionPlanHash as in, isKnowledgePagePath as it, writeSourceRegistry as j, ClaimLedgerGoalConflictError as jt, snapshotSourceTextInput as k, SourceRecordSchema as kt, assertKnowledgeWriteIntake as l, isKernelAnchoredPath as ln, writeJson as lt, detectNearDuplicatePages as m, removeDurable as mn, KnowledgeBaseCandidateSchema as mt, inspectKnowledgeIndex as n, commitKnowledgeFileMutations as nn, SCAFFOLD_PAGE_BASENAMES as nt, isSafeKnowledgePath as o, rollbackKnowledgeFileTransaction as on, knowledgePageFromMarkdown as ot, originatedPages as p, readRegularFileWithinRoot as pn, DeepQuestionSchema as pt, assertRunScopedCitationsResolved as q, formatFrontmatter as qt, stringMetadata as r, finishKnowledgeFileTransaction as rn, initKnowledgeBase as rt, parseKnowledgeWriteBlocks as s, DEFAULT_PAGES_DIRECTORY as sn, layoutFor as st, explainKnowledgeTarget as t, assertKnowledgeMutationPath as tn, resolveRunScopedCitations as tt, RUN_LINEAGE_BASENAME as u, isMissingFile as un, WIKILINK_REGEX as ut, CHECKABLE_RUNG_THRESHOLD as v, withSafeDirectory as vn, KnowledgeIndexSchema as vt, buildKnowledgeIndex as w, textSourceAdapter as wn, ResearchClaimEvidenceSchema as wt, gradeFor as x, writeJsonDurable as xn, KnowledgeRelationGraphSchema as xt, UncheckableClaimError as y, writeFileDurable as yn, KnowledgePageInvalidationSchema as yt, assertClaimLedgerId as z, deepQuestionId as zt };
 
-//# sourceMappingURL=inspect-0tmv3xV8.js.map
+//# sourceMappingURL=inspect-DALsvG10.js.map