@tangle-network/agent-knowledge 22.0.0 → 22.0.2

package/dist/{inspect-B1VI49Y9.js → inspect-rnlXAb4O.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",
@@ -884,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");
@@ -894,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: []
 		};
@@ -921,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?.();
 	});
@@ -993,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);
@@ -1026,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;
 }
@@ -1172,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));
@@ -1264,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) => {
@@ -3833,25 +3950,36 @@ function extractSourceRefs(text) {
 //#endregion
 //#region src/validate.ts
 function validateKnowledgeIndex(index, options = {}) {
-	const findings = [...lintKnowledgeIndex(index)];
+	return prepareKnowledgeValidation(index).validate(options);
+}
+/** One observation's lint/schema findings; strictness is a caller-owned policy. */
+function prepareKnowledgeValidation(index) {
+	const lintFindings = lintKnowledgeIndex(index);
+	const findings = [...lintFindings];
 	const parsed = KnowledgeIndexSchema.safeParse(index);
 	if (!parsed.success) findings.push({
 		type: "missing-frontmatter",
 		severity: "error",
 		message: parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")
 	});
-	if (options.strict) for (const page of index.pages) {
-		if (isScaffoldPath(page.path)) continue;
-		if (!page.frontmatter.id || !page.frontmatter.title) findings.push({
-			type: "missing-frontmatter",
-			severity: "error",
-			page: page.path,
-			message: "Strict mode requires id and title frontmatter."
-		});
-	}
 	return {
-		ok: !findings.some((finding) => finding.severity === "error"),
-		findings
+		lintFindings,
+		validate(options = {}) {
+			const result = [...findings];
+			if (options.strict) for (const page of index.pages) {
+				if (isScaffoldPath(page.path)) continue;
+				if (!page.frontmatter.id || !page.frontmatter.title) result.push({
+					type: "missing-frontmatter",
+					severity: "error",
+					page: page.path,
+					message: "Strict mode requires id and title frontmatter."
+				});
+			}
+			return {
+				ok: !result.some((finding) => finding.severity === "error"),
+				findings: result
+			};
+		}
 	};
 }
 //#endregion
@@ -4877,6 +5005,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 { loadSourceRegistry as $, mediaTypeFor$1 as $n, KNOWLEDGE_EVENT_TYPES as $t, validateKnowledgePage as A, finishKnowledgeFileTransaction as An, isScaffoldPath as At, CHECKABLE_RUNG_THRESHOLD as B, listRegularFilesWithinRoot 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, normalizePagesDirectory as Fn, WIKILINK_REGEX as Ft, gradeClaims as G, renameDurable as Gn, KnowledgePageSchema as Gt, UncheckableClaimError as H, readRegularFileWithinRoot as Hn, KnowledgeGraphNodeSchema as Ht, normalizePageText as I, canonicalPathsEqual as In, extractWikilinks as It, verifyGradeableEvidence as J, withSafeDirectory as Jn, ResearchClaimLedgerSchema as Jt, gradeFor as K, syncDirectory as Kn, KnowledgeRelationSchema as Kt, prepareKnowledgeValidation as L, canonicalRelativeWithinRoot 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, DEFAULT_PAGES_DIRECTORY as Pn, writeJson as Pt, addSourceText as Q, writeJsonDurableWithinRoot as Qn, SourceRecordSchema as Qt, validateKnowledgeIndex as R, isKernelAnchoredPath 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, relativeWithinRoot as Un, KnowledgeIndexSchema as Ut, DEADLINE_EXIT_CODE as V, readRegularFileNoFollow as Vn, KnowledgeGraphEdgeSchema as Vt, claimCheckKey as W, removeDurable as Wn, KnowledgePageInvalidationSchema as Wt, writeKnowledgeIndex as X, writeFileDurableWithinRoot as Xn, ResearchSourceVersionSchema as Xt, buildKnowledgeIndex as Y, writeFileDurable as Yn, ResearchClaimRecordSchema as Yt, addSourcePath as Z, writeJsonDurable 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, textSourceAdapter 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, 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, withSafeDescendant as qn, ResearchClaimEvidenceSchema as qt, stringMetadata as r, assertResearchClaimLedgerIntegrity as rn, ClaimLedgerMigrationRequiredError as rt, parseKnowledgeWriteBlocks as s, claimSourceHost as sn, KB_INDEX_PATH as st, explainKnowledgeTarget as t, assertDeepQuestionIntegrity as tn, 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, isMissingFile as zn, KnowledgeBaseCandidateSchema as zt };
 
-//# sourceMappingURL=inspect-B1VI49Y9.js.map
+//# sourceMappingURL=inspect-rnlXAb4O.js.map