@tangle-network/agent-knowledge 22.0.18 → 23.0.1

package/dist/{inspect-tl0P7I7w.js → inspect-CKNcuqrY.js}

@@ -194,7 +194,8 @@ async function listRegularFileMetadataWithinRoot(root, relativeDirectory) {
 						stat.size,
 						stat.mtimeNs,
 						stat.ctimeNs
-					].join(":")
+					].join(":"),
+					changedNs: stat.ctimeNs
 				});
 			}
 		}
@@ -1210,6 +1211,10 @@ var KnowledgeLockLostError = class extends Error {
 function isKnowledgeMutationHeld(root) {
 	return activeRoots.getStore()?.get(resolve(root))?.active === true;
 }
+/** Whether this context already reads or mutates `root`, so it must never wait on another reader. */
+function isKnowledgeRootHeld(root) {
+	return isKnowledgeMutationHeld(root) || activeReadRoots.getStore()?.has(resolve(root)) === true;
+}
 async function withKnowledgeMutation(root, mutate, options = {}) {
 	const resolvedRoot = resolve(root);
 	const existing = activeRoots.getStore()?.get(resolvedRoot);
@@ -2354,25 +2359,132 @@ async function initKnowledgeBaseUnlocked(root) {
 	return layout;
 }
 async function loadKnowledgePages(root, options = {}) {
-	return withKnowledgeRead(root, () => loadKnowledgePagesUnlocked(root, options));
+	const { views } = await readKnowledgePageViews([root], options);
+	return views[0].pages.map((page) => structuredClone(page));
 }
-async function loadKnowledgePagesUnlocked(root, options) {
+const MAX_CACHED_ROOTS = 8;
+const MAX_CACHED_SOURCE_BYTES = 67108864;
+const RACY_NS = 1000000000n;
+const cachedViews = /* @__PURE__ */ new Map();
+const refreshes = /* @__PURE__ */ new Map();
+/**
+* Internal. Each root's pages under one pages directory; a file is read and parsed again only when
+* its identity (device, inode, size, mtime, ctime) changed, so a read of an unchanged store reads
+* no page. `pagesRead` counts the files this call's refreshes read from disk. Roots read together
+* stay cached together; other roots are evicted beyond a root and byte bound, oldest first.
+*/
+async function readKnowledgePageViews(roots, options = {}) {
 	const pagesDirectory = normalizePagesDirectory(options.pagesDirectory);
-	let files;
-	try {
-		files = await listRegularFilesWithinRoot(root, pagesDirectory);
-	} catch (error) {
-		if (isMissingFile(error)) return [];
-		throw error;
+	const keys = roots.map((root) => JSON.stringify([resolve(root), pagesDirectory]));
+	const loaded = await Promise.all(roots.map((root, index) => refreshView(keys[index], resolve(root), pagesDirectory)));
+	let bytes = 0;
+	for (const view of cachedViews.values()) bytes += view.bytes;
+	for (const [key, view] of cachedViews) {
+		if (cachedViews.size <= MAX_CACHED_ROOTS && bytes <= MAX_CACHED_SOURCE_BYTES) break;
+		if (keys.includes(key)) continue;
+		cachedViews.delete(key);
+		bytes -= view.bytes;
 	}
-	const pages = [];
-	for (const file of files) {
-		const rel = file.path.replace(/\\/g, "/");
-		if (!isKnowledgePagePath(rel)) continue;
-		pages.push(knowledgePageFromMarkdown(rel, file.bytes.toString("utf8"), pagesDirectory));
+	return {
+		views: loaded.map((item) => item.view),
+		pagesRead: loaded.reduce((sum, item) => sum + item.pagesRead, 0)
+	};
+}
+function refreshView(key, root, pagesDirectory) {
+	const start = () => loadView(root, pagesDirectory, cachedViews.get(key)).then((loaded) => {
+		cachedViews.delete(key);
+		cachedViews.set(key, loaded.view);
+		return loaded;
+	});
+	if (isKnowledgeRootHeld(root)) return start();
+	const state = refreshes.get(key) ?? {};
+	refreshes.set(key, state);
+	state.next ??= (state.running ?? Promise.resolve()).catch(() => void 0).then(() => {
+		state.next = void 0;
+		const running = start().finally(() => {
+			if (state.running === running) state.running = void 0;
+			if (!state.running && !state.next) refreshes.delete(key);
+		});
+		state.running = running;
+		return running;
+	});
+	return state.next;
+}
+function loadView(root, pagesDirectory, previous) {
+	return withKnowledgeRead(root, async () => {
+		const recent = BigInt(Date.now()) * 1000000n - RACY_NS;
+		let listed;
+		try {
+			listed = await listRegularFileMetadataWithinRoot(root, pagesDirectory);
+		} catch (error) {
+			if (!isMissingFile(error)) throw error;
+			listed = [];
+		}
+		const trusted = (file) => file.changedNs < recent ? file.generation : "";
+		const generation = listed.every((file) => trusted(file) !== "") ? JSON.stringify(listed.map((file) => [file.path, file.generation])) : void 0;
+		if (generation !== void 0 && previous?.generation === generation) return {
+			view: previous,
+			pagesRead: 0
+		};
+		const files = /* @__PURE__ */ new Map();
+		const changed = [];
+		for (const file of listed) {
+			const known = previous?.files.get(file.path);
+			if (known?.generation === file.generation) files.set(file.path, known);
+			else if (isKnowledgePagePath(file.path)) changed.push(file);
+		}
+		const parse = (file, bytes) => {
+			const page = knowledgePageFromMarkdown(file.path, bytes.toString("utf8"), pagesDirectory);
+			const known = previous?.files.get(file.path)?.page;
+			const same = known?.text === page.text && JSON.stringify(known.frontmatter) === JSON.stringify(page.frontmatter);
+			files.set(file.path, {
+				generation: trusted(file),
+				page: same ? known : freezeView(page)
+			});
+		};
+		let pagesRead = changed.length;
+		if (changed.length > listed.length / 2) {
+			const wanted = new Map(changed.map((file) => [file.path, file]));
+			const walked = await listRegularFilesWithinRoot(root, pagesDirectory);
+			for (const file of walked) {
+				const listedFile = wanted.get(file.path);
+				if (listedFile) parse(listedFile, file.bytes);
+			}
+			pagesRead = walked.length;
+		} else await mapFileIo(changed, async (file) => {
+			try {
+				parse(file, (await readRegularFileWithinRoot(root, file.path)).bytes);
+			} catch (error) {
+				if (!isMissingFile(error)) throw error;
+			}
+		});
+		const pages = [...files.values()].map((file) => file.page).sort((a, b) => a.path.localeCompare(b.path));
+		const bytes = listed.reduce((sum, file) => sum + file.bytes, 0);
+		if (previous?.pages.length === pages.length && pages.every((p, i) => p === previous.pages[i])) return {
+			view: Object.assign(previous, {
+				generation,
+				bytes,
+				files
+			}),
+			pagesRead
+		};
+		return {
+			view: {
+				pages: Object.freeze(pages),
+				generation,
+				bytes,
+				files
+			},
+			pagesRead
+		};
+	});
+}
+function freezeView(value) {
+	if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+		for (const child of Object.values(value)) freezeView(child);
+		Object.freeze(value);
 	}
-	pages.sort((a, b) => a.path.localeCompare(b.path));
-	return pages;
+	return value;
 }
 /** True when a root-relative path names authored Markdown rather than scaffolding. */
 function isKnowledgePagePath(path) {
@@ -4154,25 +4266,22 @@ function prepareKnowledgeValidation(index) {
 * 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 { threshold, minCharacters, wordShingleSize, characterShingleSize, maxDocumentFrequency } = settings(options);
 	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();
+	const group = (groups, key) => groups.get(key) ?? groups.set(key, []).get(key);
 	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]);
+		group(exactGroups, item.normalized).push(index);
+		for (const shingle of item.shingles) group(byShingle, shingle).push(index);
 	}
 	let truncated = false;
 	const addPair = (left, right) => {
 		if (left === right) return true;
-		const key = pairKey(Math.min(left, right), Math.max(left, right));
+		const key = Math.min(left, right) * prepared.length + Math.max(left, right);
 		if (candidateKeys.has(key)) return true;
 		if (candidateKeys.size >= maxCandidatePairs) {
 			truncated = true;
@@ -4191,8 +4300,9 @@ function detectNearDuplicatePages(pages, options = {}) {
 	const pairs = [];
 	let duplicatePairCount = 0;
 	let comparedPairCount = 0;
-	for (const key of [...candidateKeys].sort(pairKeyOrder)) {
-		const [leftIndex, rightIndex] = parsePairKey(key);
+	for (const key of [...candidateKeys].sort((left, right) => left - right)) {
+		const leftIndex = Math.floor(key / prepared.length);
+		const rightIndex = key % prepared.length;
 		const left = prepared[leftIndex];
 		const right = prepared[rightIndex];
 		comparedPairCount += 1;
@@ -4232,6 +4342,94 @@ function detectNearDuplicatePages(pages, options = {}) {
 		pairs
 	};
 }
+function settings(options) {
+	return {
+		threshold: finiteUnitInterval(options.threshold ?? .82, "threshold"),
+		minCharacters: nonNegativeInteger(options.minCharacters ?? 80, "minCharacters"),
+		wordShingleSize: positiveInteger(options.wordShingleSize ?? 5, "wordShingleSize"),
+		characterShingleSize: positiveInteger(options.characterShingleSize ?? 16, "characterShingleSize"),
+		maxDocumentFrequency: positiveInteger(options.maxDocumentFrequency ?? 64, "maxDocumentFrequency")
+	};
+}
+const sketches = /* @__PURE__ */ new Map();
+/**
+* Every pair between a candidate and another page of `pages` (which holds the candidates) at or
+* above the threshold. A pair qualifies as in `detectNearDuplicatePages`, an exact normalized copy
+* or a shared shingle held by at most `maxDocumentFrequency` pages, but no pair cap applies: only
+* the candidates' shingles index the corpus, as sorted 32-bit shingle hashes kept per frozen page.
+*/
+function detectCandidateNearDuplicates(candidates, pages, options = {}) {
+	const config = settings(options);
+	const key = `${config.wordShingleSize}:${config.characterShingleSize}`;
+	const cache = sketches.get(key) ?? sketches.set(key, /* @__PURE__ */ new WeakMap()).get(key);
+	const sketchOf = (page) => {
+		let sketch = cache.get(page);
+		if (sketch === void 0) {
+			const item = preparePage(page, config.wordShingleSize, config.characterShingleSize);
+			const sorted = Uint32Array.from(item?.shingles ?? [], hash32).sort();
+			sketch = item && {
+				length: item.normalized.length,
+				exact: hash32(item.normalized),
+				hashes: sorted.filter((value, index) => index === 0 || sorted[index - 1] !== value)
+			};
+			if (Object.isFrozen(page)) cache.set(page, sketch);
+		}
+		return sketch && sketch.length >= config.minCharacters ? sketch : null;
+	};
+	const eligible = pages.flatMap((page) => {
+		const sketch = sketchOf(page);
+		return sketch ? [{
+			page,
+			sketch
+		}] : [];
+	}).sort((left, right) => left.page.path.localeCompare(right.page.path));
+	const position = new Map(eligible.map((entry, index) => [entry.page, index]));
+	const holders = /* @__PURE__ */ new Map();
+	for (const candidate of candidates.filter((page) => position.has(page))) {
+		const sketch = eligible[position.get(candidate)].sketch;
+		for (const hash of [~sketch.exact, ...sketch.hashes]) holders.set(hash, []);
+	}
+	for (const [index, { sketch }] of eligible.entries()) {
+		holders.get(~sketch.exact)?.push(index);
+		for (const hash of sketch.hashes) {
+			const group = holders.get(hash);
+			if (group && group.length <= config.maxDocumentFrequency) group.push(index);
+		}
+	}
+	const text = (page) => normalizePageText(`${page.title}\n${page.text}`);
+	const pairs = candidates.flatMap((candidate) => {
+		const self = position.get(candidate);
+		if (self === void 0) return [];
+		const { sketch } = eligible[self];
+		const matches = new Set(holders.get(~sketch.exact));
+		for (const hash of sketch.hashes) {
+			const group = holders.get(hash);
+			if (group.length <= config.maxDocumentFrequency) for (const index of group) matches.add(index);
+		}
+		return [...matches].flatMap((index) => {
+			const matched = eligible[index];
+			if (index === self || index < self && candidates.includes(matched.page)) return [];
+			const exact = matched.sketch.exact === sketch.exact && text(matched.page) === text(candidate);
+			const { similarity } = sortedJaccard(sketch.hashes, matched.sketch.hashes);
+			if (!exact && similarity < config.threshold) return [];
+			return [{
+				candidate,
+				matched: matched.page,
+				similarity: exact ? 1 : round(similarity),
+				exact
+			}];
+		});
+	});
+	return {
+		threshold: config.threshold,
+		pairs
+	};
+}
+function hash32(value) {
+	let hash = 2166136261;
+	for (let index = 0; index < value.length; index += 1) hash = Math.imul(hash ^ value.charCodeAt(index), 16777619);
+	return hash >>> 0;
+}
 function preparePage(page, wordShingleSize, characterShingleSize) {
 	const normalized = normalizePageText(`${page.title}\n${page.text}`);
 	if (normalized.length === 0) return null;
@@ -4268,25 +4466,26 @@ 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 overlap(left.size, right.size, intersectionSize);
+}
+function sortedJaccard(left, right) {
+	let shared = 0;
+	for (let i = 0, j = 0; i < left.length && j < right.length;) {
+		if (left[i] === right[j]) shared += 1;
+		const step = left[i] - right[j];
+		if (step <= 0) i += 1;
+		if (step >= 0) j += 1;
+	}
+	return overlap(left.length, right.length, shared);
+}
+function overlap(left, right, intersectionSize) {
+	const unionSize = left + right - 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;
@@ -4573,11 +4772,12 @@ const toolViews = /* @__PURE__ */ new WeakSet();
 function isKnowledgeToolChain(chain) {
 	return toolViews.has(chain);
 }
-const MAX_CACHED_ROOTS = 8;
-const MAX_CACHED_SOURCE_BYTES = 67108864;
 /** Internal tool path. Custom stores retain their existing loadChain contract. */
-function loadKnowledgeToolChain(stores, runId) {
-	return toolViewLoaders.get(stores)?.(runId) ?? stores.loadChain(runId);
+async function loadKnowledgeToolChain(stores, runId) {
+	return await toolViewLoaders.get(stores)?.(runId) ?? {
+		chain: await stores.loadChain(runId),
+		timing: {}
+	};
 }
 function createRunScopedStores(options) {
 	if (!options || typeof options !== "object") throw new TypeError("createRunScopedStores options are required");
@@ -4629,118 +4829,14 @@ function createRunScopedStores(options) {
 		},
 		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;
-		}
-	};
-	const roots = /* @__PURE__ */ new Map();
-	let current;
-	const loadRoot = (root, previous) => withKnowledgeRead(root, async () => {
-		let listed;
-		try {
-			listed = await listRegularFileMetadataWithinRoot(root, pagesDirectory);
-		} catch (error) {
-			if (!isMissingFile(error)) throw error;
-			listed = [];
-		}
-		const generation = JSON.stringify(listed.map((file) => [file.path, file.generation]));
-		if (previous?.generation === generation) return previous;
-		const files = /* @__PURE__ */ new Map();
-		const changed = [];
-		for (const file of listed) {
-			const known = previous?.files.get(file.path);
-			if (known?.generation === file.generation) files.set(file.path, known);
-			else if (!isKnowledgePagePath(file.path)) files.set(file.path, {
-				generation: file.generation,
-				page: void 0
-			});
-			else changed.push(file);
-		}
-		const parse = (path, generation, bytes) => files.set(path, {
-			generation,
-			page: freezeView(knowledgePageFromMarkdown(path, bytes.toString("utf8"), pagesDirectory))
-		});
-		if (changed.length > 64) {
-			const wanted = new Map(changed.map((file) => [file.path, file.generation]));
-			for (const file of await listRegularFilesWithinRoot(root, pagesDirectory)) {
-				const generation = wanted.get(file.path);
-				if (generation !== void 0) parse(file.path, generation, file.bytes);
-			}
-		} else await Promise.all(changed.map(async (file) => {
-			try {
-				parse(file.path, file.generation, (await readRegularFileWithinRoot(root, file.path)).bytes);
-			} catch (error) {
-				if (!isMissingFile(error)) throw error;
-			}
-		}));
-		const pages = Object.freeze([...files.values()].flatMap((file) => file.page ? [file.page] : []).sort((a, b) => a.path.localeCompare(b.path)));
-		return {
-			generation,
-			bytes: listed.reduce((sum, file) => sum + file.bytes, 0),
-			files,
-			pages
-		};
-	});
-	const refreshes = /* @__PURE__ */ new Map();
-	const readRoot = (root) => {
-		let state = refreshes.get(root);
-		if (!state) {
-			state = {};
-			refreshes.set(root, state);
+			const { scopes, views } = await readChain(runId);
+			return views.flatMap((view, i) => view.pages.map((page) => ({
+				page: structuredClone(page),
+				origin: scopes[i].origin
+			})));
 		}
-		const slot = state;
-		const start = () => {
-			const running = loadRoot(root, roots.get(root)).then((loaded) => retain(root, loaded)).finally(() => {
-				if (slot.running === running) slot.running = void 0;
-				if (!slot.running && !slot.next && refreshes.get(root) === slot) refreshes.delete(root);
-			});
-			slot.running = running;
-			return running;
-		};
-		if (slot.next) return slot.next;
-		if (!slot.running) return start();
-		const next = slot.running.catch(() => void 0).then(() => {
-			slot.next = void 0;
-			return start();
-		});
-		slot.next = next;
-		return next;
 	};
-	const retain = (root, loaded) => {
-		const existing = roots.get(root);
-		if (existing?.generation === loaded.generation) return existing;
-		roots.delete(root);
-		roots.set(root, loaded);
-		const live = new Set(current?.identities.map((identity) => JSON.parse(identity)[0]));
-		live.add(root);
-		let bytes = 0;
-		for (const part of roots.values()) bytes += part.bytes;
-		for (const [candidate, part] of roots) {
-			if (roots.size <= MAX_CACHED_ROOTS && bytes <= MAX_CACHED_SOURCE_BYTES) break;
-			if (live.has(candidate)) continue;
-			roots.delete(candidate);
-			bytes -= part.bytes;
-		}
-		return loaded;
-	};
-	toolViewLoaders.set(stores, async (runId) => {
+	const readChain = async (runId) => {
 		assertRunId(runId);
 		const scopes = [{
 			root: storePath(runId),
@@ -4754,31 +4850,35 @@ function createRunScopedStores(options) {
 			root: options.sharedRoot,
 			origin: "shared"
 		});
-		const identities = scopes.map(({ root, origin }) => JSON.stringify([root, origin]));
-		const parts = await Promise.all(scopes.map((scope) => readRoot(scope.root)));
+		return {
+			scopes,
+			...await readKnowledgePageViews(scopes.map((scope) => scope.root), { pagesDirectory })
+		};
+	};
+	let current;
+	toolViewLoaders.set(stores, async (runId) => {
+		const { scopes, views: parts, pagesRead } = await readChain(runId);
+		const origins = scopes.map((scope) => scope.origin);
 		const latest = current;
-		if (latest && identities.length === latest.identities.length && identities.every((id, i) => id === latest.identities[i] && parts[i] === latest.parts[i])) return latest.chain;
-		const chain = Object.freeze(parts.flatMap((part, i) => part.pages.map((page) => Object.freeze({
-			page,
-			origin: scopes[i].origin
-		}))));
-		toolViews.add(chain);
-		current = {
-			identities,
-			parts,
-			chain
+		if (latest?.parts.length !== parts.length || parts.some((part, i) => part !== latest.parts[i] || origins[i] !== latest.origins[i])) {
+			const chain = Object.freeze(parts.flatMap((part, i) => part.pages.map((page) => Object.freeze({
+				page,
+				origin: origins[i]
+			}))));
+			toolViews.add(chain);
+			current = {
+				origins,
+				parts,
+				chain
+			};
+		}
+		return {
+			chain: current.chain,
+			timing: { pagesRead }
 		};
-		return chain;
 	});
 	return stores;
 }
-function freezeView(value) {
-	if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
-		for (const child of Object.values(value)) freezeView(child);
-		Object.freeze(value);
-	}
-	return value;
-}
 /** 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");
@@ -4893,46 +4993,26 @@ function assertKnowledgeWriteIntake(candidates, options) {
 		page,
 		origin: "here"
 	}))];
-	assertNoUnrelatedDuplicate(candidatePaths, corpus, options.nearDuplicates ?? {});
+	assertNoUnrelatedDuplicate(candidates, 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}`;
+function assertNoUnrelatedDuplicate(candidates, corpus, nearDuplicates) {
+	const { threshold, pairs } = detectCandidateNearDuplicates(candidates, corpus.map((entry) => entry.page), nearDuplicates);
+	const offending = pairs.filter(({ candidate: c, matched: m }) => c.id !== m.id && !relates(c, m) && !relates(m, c)).map(({ candidate, matched, similarity, exact }) => ({
+		candidatePageId: candidate.id,
+		candidatePath: candidate.path,
+		matchedPageId: matched.id,
+		matchedPath: matched.path,
+		similarity,
+		exact
+	}));
+	if (offending.length > 0) throw new KnowledgeDuplicateIntakeError(offending, threshold);
 }
-/** 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);
+/** Whether `page` already relates itself to `target` through `cites` or `contradicts`. */
+function relates(page, target) {
+	for (const persisted of page.cites ?? []) if (parseKnowledgeCitationReference(persisted).pageId === target.id) return true;
+	return (page.contradicts ?? []).includes(target.id);
 }
 // src/write-protocol.ts
 const OPENER_LINE = /^---\s*FILE:\s*(.+?)\s*---\s*$/i;
@@ -5053,10 +5133,10 @@ async function applyKnowledgeWriteBlocks(root, proposalText, options = {}) {
 			}
 			if (intake) {
 				const { inheritedPages = [], ...settings } = intake;
-				const here = await loadKnowledgePages(root, { pagesDirectory });
+				const { views } = await readKnowledgePageViews([root], { pagesDirectory });
 				assertKnowledgeWriteIntake(mutations.filter((mutation) => isKnowledgePagePath(mutation.path)).map((mutation) => knowledgePageFromMarkdown(mutation.path, mutation.content, pagesDirectory)), {
 					...settings,
-					visiblePages: [...originatedPages(here), ...inheritedPages]
+					visiblePages: [...originatedPages(views[0].pages), ...inheritedPages]
 				});
 			}
 			await commitKnowledgeFileMutations({
@@ -5157,4 +5237,4 @@ function explainKnowledgeTarget(index, target) {
 }
 export { loadSourceRegistry as $, writeFileDurableWithinRoot as $n, KNOWLEDGE_EVENT_TYPES as $t, validateKnowledgePage as A, finishKnowledgeFileTransaction as An, isScaffoldPath as At, CHECKABLE_RUNG_THRESHOLD as B, canonicalRelativeWithinRoot as Bn, KnowledgeEventSchema as Bt, immutablePageDigest as C, runInKnowledgeMutationScope as Cn, resolveKnowledgeCitation as Ct, normalizeVisibilityArtifact as D, applyKnowledgeFileTransaction as Dn, SCAFFOLD_PAGE_BASENAMES as Dt, nonEmpty as E, withKnowledgeRead as En, resolveRunScopedCitations as Et, detectNearDuplicatePages as F, recordLockOwner as Fn, WIKILINK_REGEX as Ft, gradeClaims as G, readRegularFileWithinRoot as Gn, KnowledgePageSchema as Gt, UncheckableClaimError as H, isMissingFile as Hn, KnowledgeGraphNodeSchema as Ht, normalizePageText as I, takeOverDeadHolder as In, extractWikilinks as It, verifyGradeableEvidence as J, renameDurable as Jn, ResearchClaimLedgerSchema as Jt, gradeFor as K, relativeWithinRoot as Kn, KnowledgeRelationSchema as Kt, prepareKnowledgeValidation as L, DEFAULT_PAGES_DIRECTORY as Ln, normalizeLinkTarget as Lt, verifyKnowledgeVisibilitySnapshot as M, prepareKnowledgeFileTransaction as Mn, layoutFor as Mt, visibilityIdentity as N, rollbackKnowledgeFileTransaction as Nn, loadKnowledgePages as Nt, normalizeVisibilityRef as O, assertKnowledgeMutationPath as On, initKnowledgeBase as Ot, visibilityIndexOf as P, RUN_LEASE as Pn, writeJson as Pt, addSourceText as Q, writeFileDurable as Qn, SourceRecordSchema as Qt, validateKnowledgeIndex as R, normalizePagesDirectory as Rn, DeepQuestionSchema as Rt, encodeKnowledgeVisibilitySnapshot as S, recoverPendingKnowledgeMutation as Sn, parseKnowledgeCitationReference as St, knowledgeVisibilityArtifactRef as T, withKnowledgeMutationLabel as Tn, resolveRunScopedCitation as Tt, assertGradeableEvidence as U, listRegularFilesWithinRoot as Un, KnowledgeIndexSchema as Ut, DEADLINE_EXIT_CODE as V, isKernelAnchoredPath as Vn, KnowledgeGraphEdgeSchema as Vt, claimCheckKey as W, readRegularFileNoFollow as Wn, KnowledgePageInvalidationSchema as Wt, writeKnowledgeIndex as X, withSafeDescendant as Xn, ResearchSourceVersionSchema as Xt, buildKnowledgeIndex as Y, syncDirectory as Yn, ResearchClaimRecordSchema as Yt, addSourcePath as Z, withSafeDirectory as Zn, SourceAnchorSchema as Zt, KNOWLEDGE_USE_RECEIPT_SCHEMA_VERSION as _, parseFrontmatter as _n, assertKnowledgeCitationsResolved as _t, applyKnowledgeWriteBlocksFile as a, claimEvidenceId as an, KB_CLAIM_LEDGER_DIR as at, decodeKnowledgeVisibilitySnapshot as b, isKnowledgeMutationHeld as bn, auditKnowledgeCitations as bt, KnowledgeDuplicateIntakeError as c, deepQuestionId as cn, KB_STORE_DIR as ct, createFileRunLineageAuthority as d, materializeRegisteredClaimEvidence as dn, buildKnowledgeGraph as dt, ClaimLedgerGoalConflictError as en, writeJsonDurable as er, snapshotSourceTextInput as et, createRunScopedStores as f, mergeClaimLedgers as fn, knowledgePageRelations as ft, KNOWLEDGE_RECEIPT_DIGEST_ALGORITHM as g, formatFrontmatter as gn, assertKnowledgeCitationAudit as gt, originatedPages as h, researchSourceVersionKey as hn, assertCurrentRunCitationsResolved as ht, applyKnowledgeWriteBlocks as i, assertTrackedClaimIntegrity as in, FileSystemKbStore as it, validateOrigin as j, knowledgeFileTransactionPlanHash as jn, knowledgePageFromMarkdown as jt, snapshotImmutableVisibility as k, commitKnowledgeFileMutations as kn, isKnowledgePagePath as kt, assertKnowledgeWriteIntake as l, emptyClaimLedger as ln, MemoryKbStore as lt, loadKnowledgeToolChain as m, normalizeClaimText as mn, KnowledgeCitationResolutionError as mt, inspectKnowledgeIndex as n, assertResearchClaimEvidenceIntegrity as nn, mediaTypeFor$1 as nr, writeSourceRegistry as nt, isSafeKnowledgePath as o, claimId as on, KB_EVENTS_PATH as ot, isKnowledgeToolChain as p, mergeTrackedClaims as pn, KnowledgeCitationAuditError as pt, verdictFor as q, removeDurable as qn, ResearchClaimEvidenceSchema as qt, stringMetadata as r, assertResearchClaimLedgerIntegrity as rn, textSourceAdapter as rr, ClaimLedgerMigrationRequiredError as rt, parseKnowledgeWriteBlocks as s, claimSourceHost as sn, KB_INDEX_PATH as st, explainKnowledgeTarget as t, assertDeepQuestionIntegrity as tn, writeJsonDurableWithinRoot as tr, sourceRegistryPath as tt, RUN_LINEAGE_BASENAME as u, linkClaimContradictions as un, assertClaimLedgerId as ut, assertSchemaVersion as v, acquireDurableFileLock as vn, assertRunScopedCitationsResolved as vt, knowledgePageDigest as w, withKnowledgeMutation as wn, resolveKnowledgeCitations as wt, digest as x, measureKnowledgeMutation as xn, formatKnowledgeCitationReference as xt, createKnowledgeVisibilitySnapshot as y, inspectPendingKnowledgeMutation as yn, auditCurrentRunCitations as yt, lintKnowledgeIndex as z, canonicalPathsEqual as zn, KnowledgeBaseCandidateSchema as zt };
 
-//# sourceMappingURL=inspect-tl0P7I7w.js.map
+//# sourceMappingURL=inspect-CKNcuqrY.js.map