@tangle-network/agent-knowledge 21.0.0 → 22.0.1

package/dist/{inspect-DXN6SE2o.js → inspect-DBxyQSdt.js}

@@ -1,13 +1,14 @@
 import { i as textSourceId, n as slugify, r as stableId, t as sha256 } from "./ids-Bevz_pXV.js";
-import { r as searchKnowledge } from "./search-BBr5eUyT.js";
+import { r as searchKnowledge } from "./search-aZdP2685.js";
 import { canonicalCandidateBytes, canonicalCandidateDigest, sha256Bytes, sha256DigestSchema } from "@tangle-network/agent-interface";
 import { contentHash } from "@tangle-network/agent-eval";
 import { z } from "zod";
 import { createHash, randomUUID } from "node:crypto";
 import { closeSync, constants, fstatSync, lstatSync, openSync, readFileSync } 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",
@@ -639,8 +640,10 @@ async function applyKnowledgeFileTransaction(input) {
 	});
 }
 async function assertKnowledgeFileTransactionApplied(root, transaction) {
-	for (const entry of transaction.entries) await withSafeDescendant(root, entry.path, async (target) => {
-		if (!fileMatches(await readRegularFile(target), entry.afterHash, entry.afterMode)) throw new Error(`knowledge file transaction did not commit: ${entry.path}`);
+	await mapFileIo(transaction.entries, async (entry) => {
+		await withSafeDescendant(root, entry.path, async (target) => {
+			if (!fileMatches(await readRegularFile(target), entry.afterHash, entry.afterMode)) throw new Error(`knowledge file transaction did not commit: ${entry.path}`);
+		});
 	});
 }
 async function finishKnowledgeFileTransaction(input) {
@@ -792,8 +795,10 @@ async function assertKnowledgeFileTransactionTerminal(root, transaction, directi
 		await assertKnowledgeFileTransactionApplied(root, transaction);
 		return;
 	}
-	for (const entry of transaction.entries) await withSafeDescendant(root, entry.path, async (target) => {
-		if (!fileMatches(await readRegularFile(target), entry.beforeHash, entry.beforeMode)) throw new Error(`knowledge file transaction did not roll back: ${entry.path}`);
+	await mapFileIo(transaction.entries, async (entry) => {
+		await withSafeDescendant(root, entry.path, async (target) => {
+			if (!fileMatches(await readRegularFile(target), entry.beforeHash, entry.beforeMode)) throw new Error(`knowledge file transaction did not roll back: ${entry.path}`);
+		});
 	});
 }
 async function withTransactionRoot(root, transactionRoot, create, use) {
@@ -880,8 +885,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");
@@ -890,14 +932,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: []
 		};
@@ -917,34 +958,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?.();
 	});
@@ -989,21 +1047,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);
@@ -1022,6 +1076,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;
 }
@@ -1168,27 +1270,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));
@@ -1260,9 +1381,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) => {
@@ -4873,6 +4994,6 @@ function explainKnowledgeTarget(index, target) {
 	};
 }
 //#endregion
-export { snapshotSourceTextInput as $, ClaimLedgerGoalConflictError as $t, validateKnowledgePage as A, prepareKnowledgeFileTransaction as An, knowledgePageFromMarkdown as At, DEADLINE_EXIT_CODE as B, readRegularFileWithinRoot as Bn, KnowledgeGraphEdgeSchema as Bt, immutablePageDigest as C, withKnowledgeMutation as Cn, resolveKnowledgeCitations as Ct, normalizeVisibilityArtifact as D, commitKnowledgeFileMutations as Dn, initKnowledgeBase as Dt, nonEmpty as E, assertKnowledgeMutationPath as En, SCAFFOLD_PAGE_BASENAMES as Et, detectNearDuplicatePages as F, canonicalRelativeWithinRoot as Fn, extractWikilinks as Ft, gradeFor as G, withSafeDescendant as Gn, KnowledgeRelationSchema as Gt, assertGradeableEvidence as H, removeDurable as Hn, KnowledgeIndexSchema as Ht, normalizePageText as I, isKernelAnchoredPath as In, normalizeLinkTarget as It, buildKnowledgeIndex as J, writeFileDurableWithinRoot as Jn, ResearchClaimRecordSchema as Jt, verdictFor as K, withSafeDirectory as Kn, ResearchClaimEvidenceSchema as Kt, validateKnowledgeIndex as L, isMissingFile as Ln, DeepQuestionSchema as Lt, verifyKnowledgeVisibilitySnapshot as M, DEFAULT_PAGES_DIRECTORY as Mn, loadKnowledgePages as Mt, visibilityIdentity as N, normalizePagesDirectory as Nn, writeJson as Nt, normalizeVisibilityRef as O, finishKnowledgeFileTransaction as On, isKnowledgePagePath as Ot, visibilityIndexOf as P, canonicalPathsEqual as Pn, WIKILINK_REGEX as Pt, loadSourceRegistry as Q, textSourceAdapter as Qn, KNOWLEDGE_EVENT_TYPES as Qt, lintKnowledgeIndex as R, listRegularFilesWithinRoot as Rn, KnowledgeBaseCandidateSchema as Rt, encodeKnowledgeVisibilitySnapshot as S, runInKnowledgeMutationScope as Sn, resolveKnowledgeCitation as St, knowledgeVisibilityArtifactRef as T, applyKnowledgeFileTransaction as Tn, resolveRunScopedCitations as Tt, claimCheckKey as U, renameDurable as Un, KnowledgePageInvalidationSchema as Ut, UncheckableClaimError as V, relativeWithinRoot as Vn, KnowledgeGraphNodeSchema as Vt, gradeClaims as W, syncDirectory as Wn, KnowledgePageSchema as Wt, addSourcePath as X, writeJsonDurableWithinRoot as Xn, SourceAnchorSchema as Xt, writeKnowledgeIndex as Y, writeJsonDurable as Yn, ResearchSourceVersionSchema as Yt, addSourceText as Z, mediaTypeFor$1 as Zn, SourceRecordSchema as Zt, KNOWLEDGE_USE_RECEIPT_SCHEMA_VERSION as _, acquireDurableFileLock as _n, assertRunScopedCitationsResolved as _t, applyKnowledgeWriteBlocksFile as a, claimId as an, KB_EVENTS_PATH as at, decodeKnowledgeVisibilitySnapshot as b, measureKnowledgeMutation as bn, formatKnowledgeCitationReference as bt, KnowledgeDuplicateIntakeError as c, emptyClaimLedger as cn, MemoryKbStore as ct, createFileRunLineageAuthority as d, mergeClaimLedgers as dn, knowledgePageRelations as dt, assertDeepQuestionIntegrity as en, sourceRegistryPath as et, createRunScopedStores as f, mergeTrackedClaims as fn, KnowledgeCitationAuditError as ft, KNOWLEDGE_RECEIPT_DIGEST_ALGORITHM as g, parseFrontmatter as gn, assertKnowledgeCitationsResolved as gt, originatedPages as h, formatFrontmatter as hn, assertKnowledgeCitationAudit as ht, applyKnowledgeWriteBlocks as i, claimEvidenceId as in, KB_CLAIM_LEDGER_DIR as it, validateOrigin as j, rollbackKnowledgeFileTransaction as jn, layoutFor as jt, snapshotImmutableVisibility as k, knowledgeFileTransactionPlanHash as kn, isScaffoldPath as kt, assertKnowledgeWriteIntake as l, linkClaimContradictions as ln, assertClaimLedgerId as lt, loadKnowledgeToolChain as m, researchSourceVersionKey as mn, assertCurrentRunCitationsResolved as mt, inspectKnowledgeIndex as n, assertResearchClaimLedgerIntegrity as nn, ClaimLedgerMigrationRequiredError as nt, isSafeKnowledgePath as o, claimSourceHost as on, KB_INDEX_PATH as ot, isKnowledgeToolChain as p, normalizeClaimText as pn, KnowledgeCitationResolutionError as pt, verifyGradeableEvidence as q, writeFileDurable as qn, ResearchClaimLedgerSchema as qt, stringMetadata as r, assertTrackedClaimIntegrity as rn, FileSystemKbStore as rt, parseKnowledgeWriteBlocks as s, deepQuestionId as sn, KB_STORE_DIR as st, explainKnowledgeTarget as t, assertResearchClaimEvidenceIntegrity as tn, writeSourceRegistry as tt, RUN_LINEAGE_BASENAME as u, materializeRegisteredClaimEvidence as un, buildKnowledgeGraph as ut, assertSchemaVersion as v, inspectPendingKnowledgeMutation as vn, auditCurrentRunCitations as vt, knowledgePageDigest as w, withKnowledgeRead as wn, resolveRunScopedCitation as wt, digest as x, recoverPendingKnowledgeMutation as xn, parseKnowledgeCitationReference as xt, createKnowledgeVisibilitySnapshot as y, isKnowledgeMutationHeld as yn, auditKnowledgeCitations as yt, CHECKABLE_RUNG_THRESHOLD as z, readRegularFileNoFollow as zn, KnowledgeEventSchema as zt };
+export { snapshotSourceTextInput as $, textSourceAdapter as $n, ClaimLedgerGoalConflictError as $t, validateKnowledgePage as A, knowledgeFileTransactionPlanHash as An, knowledgePageFromMarkdown as At, DEADLINE_EXIT_CODE as B, readRegularFileNoFollow as Bn, KnowledgeGraphEdgeSchema as Bt, immutablePageDigest as C, withKnowledgeMutation as Cn, resolveKnowledgeCitations as Ct, normalizeVisibilityArtifact as D, assertKnowledgeMutationPath as Dn, initKnowledgeBase as Dt, nonEmpty as E, applyKnowledgeFileTransaction as En, SCAFFOLD_PAGE_BASENAMES as Et, detectNearDuplicatePages as F, canonicalPathsEqual as Fn, extractWikilinks as Ft, gradeFor as G, syncDirectory as Gn, KnowledgeRelationSchema as Gt, assertGradeableEvidence as H, relativeWithinRoot as Hn, KnowledgeIndexSchema as Ht, normalizePageText as I, canonicalRelativeWithinRoot as In, normalizeLinkTarget as It, buildKnowledgeIndex as J, writeFileDurable as Jn, ResearchClaimRecordSchema as Jt, verdictFor as K, withSafeDescendant as Kn, ResearchClaimEvidenceSchema as Kt, validateKnowledgeIndex as L, isKernelAnchoredPath as Ln, DeepQuestionSchema as Lt, verifyKnowledgeVisibilitySnapshot as M, rollbackKnowledgeFileTransaction as Mn, loadKnowledgePages as Mt, visibilityIdentity as N, DEFAULT_PAGES_DIRECTORY as Nn, writeJson as Nt, normalizeVisibilityRef as O, commitKnowledgeFileMutations as On, isKnowledgePagePath as Ot, visibilityIndexOf as P, normalizePagesDirectory as Pn, WIKILINK_REGEX as Pt, loadSourceRegistry as Q, mediaTypeFor$1 as Qn, KNOWLEDGE_EVENT_TYPES as Qt, lintKnowledgeIndex as R, isMissingFile as Rn, KnowledgeBaseCandidateSchema as Rt, encodeKnowledgeVisibilitySnapshot as S, runInKnowledgeMutationScope as Sn, resolveKnowledgeCitation as St, knowledgeVisibilityArtifactRef as T, withKnowledgeRead as Tn, resolveRunScopedCitations as Tt, claimCheckKey as U, removeDurable as Un, KnowledgePageInvalidationSchema as Ut, UncheckableClaimError as V, readRegularFileWithinRoot as Vn, KnowledgeGraphNodeSchema as Vt, gradeClaims as W, renameDurable as Wn, KnowledgePageSchema as Wt, addSourcePath as X, writeJsonDurable as Xn, SourceAnchorSchema as Xt, writeKnowledgeIndex as Y, writeFileDurableWithinRoot as Yn, ResearchSourceVersionSchema as Yt, addSourceText as Z, writeJsonDurableWithinRoot as Zn, SourceRecordSchema as Zt, KNOWLEDGE_USE_RECEIPT_SCHEMA_VERSION as _, acquireDurableFileLock as _n, assertRunScopedCitationsResolved as _t, applyKnowledgeWriteBlocksFile as a, claimId as an, KB_EVENTS_PATH as at, decodeKnowledgeVisibilitySnapshot as b, measureKnowledgeMutation as bn, formatKnowledgeCitationReference as bt, KnowledgeDuplicateIntakeError as c, emptyClaimLedger as cn, MemoryKbStore as ct, createFileRunLineageAuthority as d, mergeClaimLedgers as dn, knowledgePageRelations as dt, assertDeepQuestionIntegrity as en, sourceRegistryPath as et, createRunScopedStores as f, mergeTrackedClaims as fn, KnowledgeCitationAuditError as ft, KNOWLEDGE_RECEIPT_DIGEST_ALGORITHM as g, parseFrontmatter as gn, assertKnowledgeCitationsResolved as gt, originatedPages as h, formatFrontmatter as hn, assertKnowledgeCitationAudit as ht, applyKnowledgeWriteBlocks as i, claimEvidenceId as in, KB_CLAIM_LEDGER_DIR as it, validateOrigin as j, prepareKnowledgeFileTransaction as jn, layoutFor as jt, snapshotImmutableVisibility as k, finishKnowledgeFileTransaction as kn, isScaffoldPath as kt, assertKnowledgeWriteIntake as l, linkClaimContradictions as ln, assertClaimLedgerId as lt, loadKnowledgeToolChain as m, researchSourceVersionKey as mn, assertCurrentRunCitationsResolved as mt, inspectKnowledgeIndex as n, assertResearchClaimLedgerIntegrity as nn, ClaimLedgerMigrationRequiredError as nt, isSafeKnowledgePath as o, claimSourceHost as on, KB_INDEX_PATH as ot, isKnowledgeToolChain as p, normalizeClaimText as pn, KnowledgeCitationResolutionError as pt, verifyGradeableEvidence as q, withSafeDirectory as qn, ResearchClaimLedgerSchema as qt, stringMetadata as r, assertTrackedClaimIntegrity as rn, FileSystemKbStore as rt, parseKnowledgeWriteBlocks as s, deepQuestionId as sn, KB_STORE_DIR as st, explainKnowledgeTarget as t, assertResearchClaimEvidenceIntegrity as tn, writeSourceRegistry as tt, RUN_LINEAGE_BASENAME as u, materializeRegisteredClaimEvidence as un, buildKnowledgeGraph as ut, assertSchemaVersion as v, inspectPendingKnowledgeMutation as vn, auditCurrentRunCitations as vt, knowledgePageDigest as w, withKnowledgeMutationLabel as wn, resolveRunScopedCitation as wt, digest as x, recoverPendingKnowledgeMutation as xn, parseKnowledgeCitationReference as xt, createKnowledgeVisibilitySnapshot as y, isKnowledgeMutationHeld as yn, auditKnowledgeCitations as yt, CHECKABLE_RUNG_THRESHOLD as z, listRegularFilesWithinRoot as zn, KnowledgeEventSchema as zt };
 
-//# sourceMappingURL=inspect-DXN6SE2o.js.map
+//# sourceMappingURL=inspect-DBxyQSdt.js.map