@tangle-network/agent-knowledge 20.0.0 → 20.0.2

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

@@ -4,9 +4,10 @@ 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 { lstat, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { AsyncLocalStorage } from "node:async_hooks";
+import { hostname } from "node:os";
 //#region src/adapters.ts
 const textSourceAdapter = {
 	id: "text",
@@ -862,8 +863,45 @@ function fileMatches(file, hash, mode) {
 //#endregion
 //#region src/mutation-lock.ts
 const DEFAULT_STALE_MS = 9e5;
-const DEFAULT_READ_RETRIES = 100;
 const DEFAULT_READ_WAIT_MS = 25;
+const MAX_POLL_MS = 250;
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* How long a writer waits for the store lock, behind this process's writers and then another
+* process's hold, before it fails naming the holder. It is the default stale window: by then the
+* holder released, or stopped heartbeating and its lock was taken over, or it held the store
+* longer than a crashed holder could wedge it.
+*
+* Holds measured on Discovery's archive USB disk had a median of 30.4 s and reached 92.6 s, and
+* the 60 s same-process admission this replaces failed a queued `knowledge_record` terminally
+* there, losing the write (agent-knowledge#251). On flash the same holds take 58-86 ms.
+*/
+const WRITER_WAIT_MS = DEFAULT_STALE_MS;
+/**
+* How long a reader waits out writes before failing, when the caller sets no `retries`. It covers
+* the slowest hold measured (92.6 s); the 2.5 s it replaces failed 18.3% of reads on that disk.
+* A read changes nothing, so failing one loses no work, which is why it waits less than a writer.
+*/
+const READER_WAIT_MS = 12e4;
+/** Diagnostic record of the current cross-process holder, read only to name it in a timeout. */
+const LOCK_OWNER_FILE = "mutation.lock.owner.json";
+const holderLabels = new AsyncLocalStorage();
+/**
+* Name the store mutations `body` performs, so a writer or reader that times out behind them can
+* say who held the store. Internal: tools label their writes with the tool and actor.
+*/
+function withKnowledgeMutationLabel(label, body) {
+	return holderLabels.run(label, body);
+}
+function describeHolder(holder, now = Date.now()) {
+	const heldS = Math.max(0, Math.round((now - holder.since) / 1e3));
+	return `${holder.label} (pid ${holder.pid} on ${holder.host}, holding since ${new Date(holder.since).toISOString()}, ${heldS} s)`;
+}
+function seconds(ms) {
+	return `${Math.round(ms / 100) / 10} s`;
+}
 let lockfileModule;
 function loadLockfile() {
 	lockfileModule ??= import("proper-lockfile");
@@ -872,14 +910,13 @@ function loadLockfile() {
 const activeRoots = new AsyncLocalStorage();
 const activeReadRoots = new AsyncLocalStorage();
 const gates = /* @__PURE__ */ new Map();
-/** How long a same-process writer waits for admission before failing like a contended lock. */
-const WRITER_ADMISSION_MS = 6e4;
 function gateOf(root) {
 	let gate = gates.get(root);
 	if (!gate) {
 		gate = {
 			readers: 0,
 			writing: false,
+			holder: void 0,
 			readersWaiting: [],
 			writersWaiting: []
 		};
@@ -899,34 +936,51 @@ function admitNext(root, gate, afterWrite) {
 		gate.writersWaiting.shift()();
 	} else if (gate.readers === 0) gates.delete(root);
 }
-async function enterGate(root, mode, timeoutMs) {
+/** Who a same-process waiter is waiting behind, for its timeout error. */
+function describeGate(gate) {
+	const queued = gate.writersWaiting.length;
+	const behind = gate.holder ? describeHolder(gate.holder) : gate.readers > 0 ? `${gate.readers} reader(s) of this process` : "no admitted writer";
+	return queued > 0 ? `${behind}; ${queued} writer(s) still queued` : behind;
+}
+async function enterGate(root, mode, timeoutMs, label = "a knowledge mutation") {
 	const gate = gateOf(root);
 	const release = mode === "read" ? () => {
 		gate.readers -= 1;
 		if (gate.readers === 0) admitNext(root, gate, false);
 	} : () => {
 		gate.writing = false;
+		gate.holder = void 0;
 		admitNext(root, gate, true);
 	};
+	const hold = () => {
+		if (mode === "write") gate.holder = {
+			label,
+			pid: process.pid,
+			host: hostname(),
+			since: Date.now()
+		};
+		return once(release);
+	};
 	if (mode === "read" ? !gate.writing && gate.writersWaiting.length === 0 : !gate.writing && gate.readers === 0 && gate.writersWaiting.length === 0) {
 		if (mode === "read") gate.readers += 1;
 		else gate.writing = true;
-		return once(release);
+		return hold();
 	}
 	const waiting = mode === "read" ? gate.readersWaiting : gate.writersWaiting;
 	return new Promise((resolve, reject) => {
 		let timer;
 		const admit = () => {
 			if (timer) clearTimeout(timer);
-			resolve(once(release));
+			resolve(hold());
 		};
 		waiting.push(admit);
 		timer = setTimeout(() => {
 			const position = waiting.indexOf(admit);
 			if (position < 0) return;
 			waiting.splice(position, 1);
+			const behind = describeGate(gate);
 			admitNext(root, gate, mode === "write");
-			reject(mode === "read" ? /* @__PURE__ */ new Error("knowledge read could not observe a stable mutation epoch") : Object.assign(/* @__PURE__ */ new Error(`knowledge store is locked by this process: ${root}`), { code: "ELOCKED" }));
+			reject(mode === "read" ? /* @__PURE__ */ new Error(`knowledge read could not observe a stable mutation epoch: ${root}; waited ${seconds(timeoutMs)} behind ${behind}`) : Object.assign(/* @__PURE__ */ new Error(`knowledge store is locked by this process: ${root}; waited ${seconds(timeoutMs)} behind ${behind}`), { code: "ELOCKED" }));
 		}, timeoutMs);
 		timer.unref?.();
 	});
@@ -971,21 +1025,17 @@ async function withKnowledgeMutation(root, mutate, options = {}) {
 	const existing = activeRoots.getStore()?.get(resolvedRoot);
 	if (existing?.active) return await runInlineMutation(existing.lock, mutate);
 	if (activeReadRoots.getStore()?.has(resolvedRoot)) throw new Error("a knowledge mutation cannot start inside a read of the same store");
+	const label = holderLabels.getStore() ?? options.resumeTransaction?.purpose ?? "a knowledge mutation";
 	const started = performance.now();
-	const leave = await enterGate(resolvedRoot, "write", noRetries(options.retries) ? 0 : WRITER_ADMISSION_MS);
+	const leave = await enterGate(resolvedRoot, "write", noRetries(options.retries) ? 0 : WRITER_WAIT_MS, label);
 	try {
 		return await withSafeDirectory(resolvedRoot, ".agent-knowledge", true, async (cacheDir) => {
-			const acquired = await acquireDurableFileLock(resolvedRoot, {
-				lockfilePath: join(cacheDir, "mutation.lock.durable"),
+			const acquired = await acquireStoreLock(resolvedRoot, cacheDir, {
 				staleMs: options.staleMs,
-				retries: options.retries ?? {
-					retries: 100,
-					factor: 1.1,
-					minTimeout: 10,
-					maxTimeout: 200,
-					randomize: true
-				}
+				retries: options.retries,
+				started
 			});
+			await recordLockOwner(cacheDir, label);
 			const held = performance.now();
 			try {
 				return await runOwnedMutation(resolvedRoot, cacheDir, acquired, options, mutate);
@@ -1004,6 +1054,54 @@ async function withKnowledgeMutation(root, mutate, options = {}) {
 		leave();
 	}
 }
+/**
+* Take the cross-process file lock. A caller that sets `retries` keeps that attempt budget; every
+* other writer polls until one deadline shared with its in-process wait, so a hold longer than a
+* fixed number of attempts delays a write instead of failing it.
+*/
+async function acquireStoreLock(root, cacheDir, options) {
+	const lockfilePath = join(cacheDir, "mutation.lock.durable");
+	const deadline = options.started + WRITER_WAIT_MS;
+	let pause = 10;
+	for (;;) try {
+		return await acquireDurableFileLock(root, {
+			lockfilePath,
+			staleMs: options.staleMs,
+			retries: options.retries ?? 0
+		});
+	} catch (error) {
+		const remaining = deadline - performance.now();
+		if (options.retries !== void 0 || error.code !== "ELOCKED" || remaining <= 0) throw await namedLockError(error, root, cacheDir, performance.now() - options.started);
+		await sleep(Math.min(remaining, pause * (.5 + Math.random())));
+		pause = Math.min(MAX_POLL_MS, pause * 1.5);
+	}
+}
+/** A contended file lock, restated with the holder its owner record names. */
+async function namedLockError(error, root, cacheDir, waitedMs) {
+	if (error?.code !== "ELOCKED") return error;
+	const owner = await readLockOwner(cacheDir);
+	return Object.assign(new Error(`knowledge store is locked by another process: ${root}; waited ${seconds(waitedMs)} for ${owner ? describeHolder(owner) : "a holder that recorded no owner"}`, { cause: error }), { code: "ELOCKED" });
+}
+/** Record who holds the file lock, for a waiter's timeout. Diagnostic only, so not fsynced. */
+async function recordLockOwner(cacheDir, label) {
+	const owner = {
+		label,
+		pid: process.pid,
+		host: hostname(),
+		since: Date.now()
+	};
+	try {
+		await writeFile(join(cacheDir, LOCK_OWNER_FILE), `${JSON.stringify(owner)}\n`);
+	} catch {}
+}
+async function readLockOwner(cacheDir) {
+	try {
+		const value = JSON.parse(await readFile(join(cacheDir, LOCK_OWNER_FILE), "utf8"));
+		return typeof value.label === "string" && Number.isSafeInteger(value.pid) && typeof value.host === "string" && Number.isFinite(value.since) ? value : void 0;
+	} catch {
+		return;
+	}
+}
 function noRetries(retries) {
 	return retries === 0 || typeof retries === "object" && !Array.isArray(retries) && retries.retries === 0;
 }
@@ -1150,27 +1248,46 @@ async function withKnowledgeRead(root, read, options = {}) {
 	if (activeReadRoots.getStore()?.has(resolvedRoot)) return await read();
 	const readRoots = new Set(activeReadRoots.getStore());
 	readRoots.add(resolvedRoot);
-	const retries = options.retries ?? DEFAULT_READ_RETRIES;
-	const leave = await enterGate(resolvedRoot, "read", (retries + 1) * (options.waitMs ?? DEFAULT_READ_WAIT_MS));
+	const started = performance.now();
+	const retries = options.retries;
+	const budgetMs = retries === void 0 ? READER_WAIT_MS : (retries + 1) * (options.waitMs ?? DEFAULT_READ_WAIT_MS);
+	const deadline = started + budgetMs;
+	const leave = await enterGate(resolvedRoot, "read", budgetMs);
 	try {
 		return await activeReadRoots.run(readRoots, async () => {
-			for (let attempt = 0; attempt <= retries; attempt += 1) {
+			let pause = options.waitMs ?? DEFAULT_READ_WAIT_MS;
+			for (let attempt = 0; retries === void 0 || attempt <= retries; attempt += 1) {
+				if (attempt > 0 && retries === void 0 && performance.now() >= deadline) break;
 				const before = await readMutationEpoch(resolvedRoot);
-				if (isOdd(before)) {
-					await waitForActiveMutationEpoch(resolvedRoot, before, options);
-					continue;
+				let active = before;
+				if (!isOdd(before)) {
+					const result = await read();
+					const after = await readMutationEpoch(resolvedRoot);
+					if (before === after) return result;
+					if (!isOdd(after)) continue;
+					active = after;
 				}
-				const result = await read();
-				const after = await readMutationEpoch(resolvedRoot);
-				if (before === after && !isOdd(after)) return result;
-				if (isOdd(after)) await waitForActiveMutationEpoch(resolvedRoot, after, options);
+				await waitForActiveMutationEpoch(resolvedRoot, active, options, pause);
+				if (retries === void 0) pause = Math.min(MAX_POLL_MS, pause * 1.5);
 			}
-			throw new Error("knowledge read could not observe a stable mutation epoch");
+			throw new Error(`knowledge read could not observe a stable mutation epoch: ${resolvedRoot}; waited ${seconds(performance.now() - started)} for ${await describeWriter(resolvedRoot)}`);
 		});
 	} finally {
 		leave();
 	}
 }
+/** The writer a reader gave up on: this process's admitted writer, else the recorded owner. */
+async function describeWriter(root) {
+	const local = gates.get(root)?.holder;
+	if (local) return describeHolder(local);
+	let owner;
+	try {
+		owner = await withSafeDirectory(root, ".agent-knowledge", false, readLockOwner);
+	} catch {
+		owner = void 0;
+	}
+	return owner ? describeHolder(owner) : "a writer that recorded no owner";
+}
 async function acquireDurableFileLock(target, options) {
 	const stale = Math.max(5e3, options.staleMs ?? DEFAULT_STALE_MS);
 	const update = Math.max(1e3, Math.floor(stale / 3));
@@ -1242,9 +1359,9 @@ async function writeMutationEpoch(cacheDir, epoch) {
 		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
 	});
 }
-async function waitForActiveMutationEpoch(root, epoch, options) {
+async function waitForActiveMutationEpoch(root, epoch, options, pauseMs) {
 	if (!await hasActiveMutationLock(root, options)) await healAbandonedMutationEpoch(root, epoch, options);
-	await new Promise((resolve) => setTimeout(resolve, options.waitMs ?? DEFAULT_READ_WAIT_MS));
+	await sleep(pauseMs);
 }
 async function healAbandonedMutationEpoch(root, expectedEpoch, options) {
 	await withSafeDirectory(root, ".agent-knowledge", false, async (cacheDir) => {
@@ -4581,29 +4698,25 @@ function lexicalPageTerms(page, tokenize, fieldBoosts) {
 		length
 	};
 }
-/** Inverted index from per-page terms already computed with `tokenize` and `fieldBoosts`. */
+/**
+* Inverted index from per-page terms already computed with `tokenize` and `fieldBoosts`.
+*
+* Posting lists are built when a term is first looked up, not up front. A query reads a handful of
+* terms, while assembling every list walks every distinct term of every page: on a 910-page run
+* store that was about 440 ms of each search that followed a write, because every write starts a
+* new page view and so a new index (agent-knowledge#203). Enumerating the postings builds them all
+* once, so the map behaves exactly as an eagerly built one.
+*/
 function assembleLexicalIndex(pages, terms, tokenize, fieldBoosts) {
-	const postings = /* @__PURE__ */ new Map();
 	const documentLengths = [];
 	let totalLength = 0;
-	terms.forEach(({ frequencies, length }, ordinal) => {
+	for (const { length } of terms) {
 		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,
+		postings: new LazyPostings(terms),
 		documentLengths,
 		averageDocumentLength: pages.length > 0 ? totalLength / pages.length : 0,
 		documentCount: pages.length,
@@ -4611,6 +4724,74 @@ function assembleLexicalIndex(pages, terms, tokenize, fieldBoosts) {
 		fieldBoosts
 	};
 }
+const NO_POSTINGS = Object.freeze([]);
+/** A read-only postings map that builds one term's list on first lookup, in ordinal order. */
+var LazyPostings = class {
+	#terms;
+	#lists = /* @__PURE__ */ new Map();
+	#all;
+	constructor(terms) {
+		this.#terms = terms;
+	}
+	get(term) {
+		if (this.#all) return this.#all.get(term);
+		let list = this.#lists.get(term);
+		if (list === void 0) {
+			const found = [];
+			this.#terms.forEach(({ frequencies }, ordinal) => {
+				const tf = frequencies.get(term);
+				if (tf !== void 0) found.push({
+					ordinal,
+					tf
+				});
+			});
+			list = found.length === 0 ? NO_POSTINGS : found;
+			this.#lists.set(term, list);
+		}
+		return list.length === 0 ? void 0 : list;
+	}
+	has(term) {
+		return this.get(term) !== void 0;
+	}
+	get size() {
+		return this.#every().size;
+	}
+	forEach(callback, thisArg) {
+		for (const [term, list] of this.#every()) callback.call(thisArg, list, term, this);
+	}
+	entries() {
+		return this.#every().entries();
+	}
+	keys() {
+		return this.#every().keys();
+	}
+	values() {
+		return this.#every().values();
+	}
+	[Symbol.iterator]() {
+		return this.entries();
+	}
+	#every() {
+		if (this.#all) return this.#all;
+		const all = /* @__PURE__ */ new Map();
+		this.#terms.forEach(({ frequencies }, ordinal) => {
+			for (const [term, tf] of frequencies) {
+				let list = all.get(term);
+				if (!list) {
+					list = [];
+					all.set(term, list);
+				}
+				list.push({
+					ordinal,
+					tf
+				});
+			}
+		});
+		this.#lists.clear();
+		this.#all = all;
+		return all;
+	}
+};
 //#endregion
 //#region src/lexical-index.ts
 const STOP_WORDS = /* @__PURE__ */ new Set([
@@ -4891,6 +5072,6 @@ function explainKnowledgeTarget(index, target) {
 	};
 }
 //#endregion
-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 };
+export { assertGradeableEvidence as $, relativeWithinRoot as $n, KnowledgeIndexSchema as $t, createKnowledgeVisibilitySnapshot as A, isKnowledgeMutationHeld as An, auditKnowledgeCitations as At, snapshotImmutableVisibility as B, finishKnowledgeFileTransaction 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, withKnowledgeMutationLabel as Fn, resolveRunScopedCitation as Ft, visibilityIndexOf as G, normalizePagesDirectory as Gn, WIKILINK_REGEX as Gt, validateOrigin as H, prepareKnowledgeFileTransaction as Hn, layoutFor as Ht, knowledgeVisibilityArtifactRef as I, withKnowledgeRead as In, resolveRunScopedCitations as It, validateKnowledgeIndex as J, isKernelAnchoredPath as Jn, DeepQuestionSchema as Jt, detectNearDuplicatePages as K, canonicalPathsEqual as Kn, extractWikilinks as Kt, nonEmpty as L, applyKnowledgeFileTransaction 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, readRegularFileWithinRoot as Qn, KnowledgeGraphNodeSchema as Qt, normalizeVisibilityArtifact as R, assertKnowledgeMutationPath 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, rollbackKnowledgeFileTransaction as Un, loadKnowledgePages as Ut, validateKnowledgePage as V, knowledgeFileTransactionPlanHash as Vn, knowledgePageFromMarkdown as Vt, visibilityIdentity as W, DEFAULT_PAGES_DIRECTORY as Wn, writeJson as Wt, CHECKABLE_RUNG_THRESHOLD as X, listRegularFilesWithinRoot as Xn, KnowledgeEventSchema as Xt, lintKnowledgeIndex as Y, isMissingFile as Yn, KnowledgeBaseCandidateSchema as Yt, DEADLINE_EXIT_CODE as Z, readRegularFileNoFollow as Zn, KnowledgeGraphEdgeSchema as Zt, isSafeKnowledgePath as _, claimSourceHost as _n, KB_INDEX_PATH as _t, searchKnowledge as a, ResearchClaimRecordSchema as an, writeFileDurable as ar, buildKnowledgeIndex as at, assertKnowledgeWriteIntake as b, linkClaimContradictions as bn, assertClaimLedgerId as bt, scoreBm25 as c, SourceRecordSchema as cn, writeJsonDurableWithinRoot as cr, addSourceText as ct, DEFAULT_FIELD_BOOSTS as d, assertDeepQuestionIntegrity as dn, sourceRegistryPath as dt, KnowledgePageInvalidationSchema as en, removeDurable 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, withSafeDirectory 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, mediaTypeFor$1 as lr, loadSourceRegistry as lt, stringMetadata as m, assertTrackedClaimIntegrity as mn, FileSystemKbStore as mt, inspectKnowledgeIndex as n, KnowledgeRelationSchema as nn, syncDirectory as nr, gradeFor as nt, searchKnowledgePages as o, ResearchSourceVersionSchema as on, writeFileDurableWithinRoot as or, writeKnowledgeIndex as ot, lexicalPageTerms as p, assertResearchClaimLedgerIntegrity as pn, ClaimLedgerMigrationRequiredError as pt, normalizePageText as q, canonicalRelativeWithinRoot as qn, normalizeLinkTarget as qt, KNOWLEDGE_SEARCH_RETRIEVER_ID as r, ResearchClaimEvidenceSchema as rn, withSafeDescendant as rr, verdictFor as rt, buildKnowledgeLexicalIndex as s, SourceAnchorSchema as sn, writeJsonDurable as sr, addSourcePath as st, explainKnowledgeTarget as t, KnowledgePageSchema as tn, renameDurable as tr, gradeClaims as tt, tokenizeText as u, ClaimLedgerGoalConflictError as un, textSourceAdapter as ur, 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, commitKnowledgeFileMutations as zn, isKnowledgePagePath as zt };
 
-//# sourceMappingURL=inspect-CMigdsD5.js.map
+//# sourceMappingURL=inspect-B24gqPC4.js.map