@tangle-network/agent-knowledge 11.0.0 → 12.0.0

package/dist/{inspect-yYqLQuM4.js → inspect-BUp9GUKO.js}

@@ -797,16 +797,19 @@ var KnowledgeLockLostError = class extends Error {
 		this.name = "KnowledgeLockLostError";
 	}
 };
+/**
+* Whether the current async context already holds the store lock for `root`.
+*
+* A caller that must decide between taking the lock and joining the one it is inside reads this
+* rather than guessing; taking a held lock from inside its own scope would block against itself.
+*/
+function isKnowledgeMutationHeld(root) {
+	return activeRoots.getStore()?.get(resolve(root))?.active === true;
+}
 async function withKnowledgeMutation(root, mutate, options = {}) {
 	const resolvedRoot = resolve(root);
-	const active = activeRoots.getStore();
-	const existing = active?.get(resolvedRoot);
-	if (existing?.active) {
-		existing.lock.assertOwned();
-		const result = await mutate(existing.lock);
-		existing.lock.assertOwned();
-		return result;
-	}
+	const existing = activeRoots.getStore()?.get(resolvedRoot);
+	if (existing?.active) return await runInlineMutation(existing.lock, mutate);
 	return withSafeDirectory(resolvedRoot, ".agent-knowledge", true, async (cacheDir) => {
 		const acquired = await acquireDurableFileLock(resolvedRoot, {
 			lockfilePath: join(cacheDir, "mutation.lock.durable"),
@@ -819,77 +822,110 @@ async function withKnowledgeMutation(root, mutate, options = {}) {
 				randomize: true
 			}
 		});
-		let recovery;
-		const mutationLock = {
-			transactionRoot: join(cacheDir, "file-transactions"),
-			get recovery() {
-				return recovery;
-			},
-			assertOwned: acquired.assertOwned
-		};
-		const scope = {
-			active: true,
-			lock: mutationLock
-		};
 		try {
-			const pendingState = await inspectKnowledgeFileTransaction({
-				root: resolvedRoot,
-				transactionRoot: mutationLock.transactionRoot
-			});
-			const pending = pendingState?.transaction ?? null;
-			const resume = pending ? assertKnowledgeTransactionResume(pending, options.resumeTransaction) : void 0;
-			const locks = new Map(active);
-			locks.set(resolvedRoot, scope);
-			return await activeRoots.run(locks, async () => {
-				const epoch = await beginMutationEpoch(cacheDir);
-				const finishEpoch = async (completed) => {
-					mutationLock.assertOwned();
-					const stillPending = await loadKnowledgeFileTransaction({
-						root: resolvedRoot,
-						transactionRoot: mutationLock.transactionRoot
-					});
-					if (completed && stillPending) throw new Error("knowledge mutation returned with an unfinished transaction");
-					if (!stillPending) await finishMutationEpoch(cacheDir, epoch);
-				};
-				try {
-					if (pending) {
-						if (!resume) throw new Error(`knowledge transaction '${pending.purpose}' requires its owner to resume`);
-						await recoverKnowledgeFileTransaction({
-							root: resolvedRoot,
-							transactionRoot: mutationLock.transactionRoot,
-							expectedPurpose: resume.purpose,
-							direction: resume.direction,
-							finish: resume.deferFinish !== true,
-							validate: resume.validate,
-							assertOwned: acquired.assertOwned
-						});
-						recovery = Object.freeze({
-							transactionId: pending.transactionId,
-							purpose: pending.purpose,
-							direction: resume.direction ?? pendingState?.direction ?? "apply",
-							transaction: pending
-						});
-					}
-					mutationLock.assertOwned();
-					const result = await mutate(mutationLock);
-					mutationLock.assertOwned();
-					await finishEpoch(true);
-					return result;
-				} catch (error) {
-					try {
-						await finishEpoch(false);
-					} catch (finishError) {
-						throw new AggregateError([error, finishError], "knowledge mutation failed and its durable state could not be inspected");
-					}
-					throw error;
-				}
-			});
+			return await runOwnedMutation(resolvedRoot, cacheDir, acquired, options, mutate);
 		} finally {
-			scope.active = false;
 			await acquired.release();
 		}
 	});
 }
+/**
+* Run `body` inside this package's mutation scope for `root`, on a lock the caller already holds.
+*
+* The caller owns acquiring and releasing that lock; this package owns the scope, the file
+* transaction it opens, and the epoch a concurrent reader watches. Inside `body`, every
+* lock-taking function in this package sees the root as held and runs inline, which is what makes
+* a consumer's own read-modify-write composable with this package instead of exclusive of it.
+*
+* The hold is asked `assertOwned()` at the same points a lock this package acquired is asked, so
+* an externally held lock carries the same guarantee and not a weaker one. Entering a scope for a
+* lock the caller does not actually hold is the one way to defeat the store's single-writer rule;
+* the hold is required, rather than assumed, so that is a statement the caller has to make.
+*/
+async function runInKnowledgeMutationScope(root, hold, body, options = {}) {
+	const resolvedRoot = resolve(root);
+	const existing = activeRoots.getStore()?.get(resolvedRoot);
+	if (existing?.active) return await runInlineMutation(existing.lock, body);
+	return withSafeDirectory(resolvedRoot, ".agent-knowledge", true, (cacheDir) => runOwnedMutation(resolvedRoot, cacheDir, hold, options, body));
+}
+/** The reentrant path: the root is already held in this async context, so no lock is taken. */
+async function runInlineMutation(lock, mutate) {
+	lock.assertOwned();
+	const result = await mutate(lock);
+	lock.assertOwned();
+	return result;
+}
+/** The owning path, shared by a lock this package acquired and a lock the caller supplies. */
+async function runOwnedMutation(resolvedRoot, cacheDir, hold, options, mutate) {
+	let recovery;
+	const mutationLock = {
+		transactionRoot: join(cacheDir, "file-transactions"),
+		get recovery() {
+			return recovery;
+		},
+		assertOwned: () => hold.assertOwned()
+	};
+	const scope = {
+		active: true,
+		lock: mutationLock
+	};
+	try {
+		const pendingState = await inspectKnowledgeFileTransaction({
+			root: resolvedRoot,
+			transactionRoot: mutationLock.transactionRoot
+		});
+		const pending = pendingState?.transaction ?? null;
+		const resume = pending ? assertKnowledgeTransactionResume(pending, options.resumeTransaction) : void 0;
+		const locks = new Map(activeRoots.getStore());
+		locks.set(resolvedRoot, scope);
+		return await activeRoots.run(locks, async () => {
+			const epoch = await beginMutationEpoch(cacheDir);
+			const finishEpoch = async (completed) => {
+				mutationLock.assertOwned();
+				const stillPending = await loadKnowledgeFileTransaction({
+					root: resolvedRoot,
+					transactionRoot: mutationLock.transactionRoot
+				});
+				if (completed && stillPending) throw new Error("knowledge mutation returned with an unfinished transaction");
+				if (!stillPending) await finishMutationEpoch(cacheDir, epoch);
+			};
+			try {
+				if (pending) {
+					if (!resume) throw new Error(`knowledge transaction '${pending.purpose}' requires its owner to resume`);
+					await recoverKnowledgeFileTransaction({
+						root: resolvedRoot,
+						transactionRoot: mutationLock.transactionRoot,
+						expectedPurpose: resume.purpose,
+						direction: resume.direction,
+						finish: resume.deferFinish !== true,
+						validate: resume.validate,
+						assertOwned: mutationLock.assertOwned
+					});
+					recovery = Object.freeze({
+						transactionId: pending.transactionId,
+						purpose: pending.purpose,
+						direction: resume.direction ?? pendingState?.direction ?? "apply",
+						transaction: pending
+					});
+				}
+				mutationLock.assertOwned();
+				const result = await mutate(mutationLock);
+				mutationLock.assertOwned();
+				await finishEpoch(true);
+				return result;
+			} catch (error) {
+				try {
+					await finishEpoch(false);
+				} catch (finishError) {
+					throw new AggregateError([error, finishError], "knowledge mutation failed and its durable state could not be inspected");
+				}
+				throw error;
+			}
+		});
+	} finally {
+		scope.active = false;
+	}
+}
 async function inspectPendingKnowledgeMutation(root) {
 	const resolvedRoot = resolve(root);
 	const pending = await inspectKnowledgeFileTransaction({
@@ -2811,7 +2847,7 @@ const NO_CHECK_NOTE = "a claim at this rung asserts that a command reproduces a
 const NO_EXPECTATION_NOTE = "exit code alone cannot verify a claim at this rung — record the value the check must print";
 const CONSTANT_EMITTER_NOTE = "the check is a constant emitter: it prints a fixed string and exits zero whatever the claim describes, so it can never fail — record a command that reads the artifact the claim is about";
 const MULTILINE_EXPECTATION_NOTE = "the expected value spans multiple lines, but the grader performs one contiguous-substring comparison — record one decisive single-line value per claim";
-const MULTI_VALUE_EXPECTATION_NOTE = "the expected value carries three or more key=value tokens, so any extra token in the check output breaks an otherwise correct claim — record one decisive value per claim";
+const SELF_CERTIFYING_NOTE = "the check text contains the expected value, so the check carries the answer it is graded against and prints a value the claim did not have to produce — record a command that reads the artifact and prints the value it finds there";
 const LONG_FIRST_WORD_NOTE = "the check begins with a shell word longer than 200 characters; this is the escaped-newline failure shape where \\n text was recorded instead of real line breaks — write the script to a file or record a real heredoc and a short invocation";
 const INVALID_SHELL_SYNTAX_NOTE = "the recorded check does not parse under bash and would fail independently of the claim — record the exact command only after bash -n accepts it";
 /**
@@ -2841,28 +2877,56 @@ var UncheckableClaimError = class extends Error {
 * `gradeFor` grades `uncheckable`: no check, a check that cannot fail, an unusable expectation,
 * or the escaped-newline command shape. Below the threshold nothing is refused.
 *
-* Four additional rules are calibrated on downstream losses, not taste: four correct claims died
-* from multiline expectations, two from brittle multi-value expectations, one campaign recorded
-* an enormous first word made of literal `\\n` sequences, and a 299-run fleet autopsy reduced ten
-* reported grader failures to checks that were never executed before their authors disappeared.
-* The dynamic half of that last rule is `verifyGradeableEvidence` below.
+* Three additional rules are calibrated on downstream losses, not taste: four correct claims
+* died from multiline expectations, one campaign recorded an enormous first word made of literal
+* `\\n` sequences, and a 299-run fleet autopsy reduced ten reported grader failures to checks that
+* were never executed before their authors disappeared. The dynamic half of that last rule is
+* `verifyGradeableEvidence` below.
 */
 function assertGradeableEvidence(evidence) {
 	if (evidence.rung < 4) return evidence;
-	const note = checkRefusalNote(evidence.check) ?? expectationRefusalNote(evidence.expect);
+	const note = checkRefusalNote(evidence.check) ?? selfCertifyingNote(evidence) ?? expectationRefusalNote(evidence.expect);
 	if (note) throw new UncheckableClaimError(evidence.rung, note);
 	return evidence;
 }
-/** The error signatures that mean the check could not run, as opposed to ran and failed. */
-const UNRUNNABLE_SIGNATURES = /No such file|FileNotFoundError|ModuleNotFoundError|command not found|ENOENT|AbortError|timed out|ERR_CHILD_PROCESS_STDIO_MAXBUFFER/;
+/**
+* The output signatures that mean the check never reached what the claim is about.
+*
+* Matched case-insensitively, because a tool that prints its own diagnostic chooses its own case,
+* and read from the OUTPUT rather than from the exit status. A shell pipeline exits with the
+* status of its last stage, so `sha256sum <missing path> | cut -d' ' -f1` prints
+* "No such file or directory" and exits 0; reading only the status calls that a refutation of
+* research that was never run. Swept over 272 grade files, 29 of 61 recorded refutations were
+* this shape: 7 a malformed check body, 7 a shell that could not parse the check, 6 a solver that
+* could not open its problem file, 5 `Permission denied`, 4 `cannot create directory`.
+*/
+const UNRUNNABLE_SIGNATURES = /No such file|FileNotFoundError|ModuleNotFoundError|command not found|ENOENT|AbortError|timed out|ERR_CHILD_PROCESS_STDIO_MAXBUFFER|Permission denied|EACCES|cannot create directory|cannot open|SyntaxError|unexpected EOF while looking for matching|syntax error near unexpected token/i;
+/**
+* The exit status a deadline kill reports: `timeout(1)`'s status, and the one a bounded process
+* runner forces so a killed child that closes with 0 cannot read as a pass. A grader that has
+* only an exit status reports this one; a grader that knows it killed the process sets
+* `CheckExecution.timedOut` instead, which is unambiguous.
+*/
+const DEADLINE_EXIT_CODE = 124;
+const DEADLINE_NOTE = "the check was killed at its deadline, so it never tested the claim — a deadline is a budget, not a verdict; raise the budget or record a check that decides within it";
+const UNREACHED_INPUT_NOTE = "the check never reached what the claim is about, so this is a verdict on the environment and not on the claim";
 /**
 * The calibrated verdict function, pure so every grader shares one semantics. Callers execute the
 * check however their environment requires and pass the observation; this function only judges.
+*
+* Three rules decide a verdict before the expectation is compared, and each one exists because
+* comparing first blamed the claim for something the claim did not do:
+*
+*   - a check that carries its own expected value is refused, because its output is authored
+*     rather than measured;
+*   - a check killed at its deadline is `unrunnable`, because a budget is not a verdict;
+*   - a check whose output says it never reached its input is `unrunnable` whatever its exit
+*     status, because a pipeline hides the failing stage's status behind its last stage.
 */
 function gradeFor(evidence, execution) {
 	const mustBeCheckable = evidence.rung >= 4;
 	if (mustBeCheckable) {
-		const note = checkRefusalNote(evidence.check);
+		const note = checkRefusalNote(evidence.check) ?? selfCertifyingNote(evidence);
 		if (note) return {
 			verdict: "uncheckable",
 			note
@@ -2870,7 +2934,11 @@ function gradeFor(evidence, execution) {
 	}
 	if (!execution) return { verdict: "unrunnable" };
 	const output = `${execution.stdout}\n${execution.stderr}`.trim();
-	if (execution.exitCode !== 0) return { verdict: UNRUNNABLE_SIGNATURES.test(output) ? "unrunnable" : "contradicted" };
+	if (execution.timedOut || execution.exitCode === 124) return {
+		verdict: "unrunnable",
+		note: DEADLINE_NOTE
+	};
+	if (execution.exitCode !== 0) return refutation(output, evidence.expect);
 	if (mustBeCheckable) {
 		const note = expectationRefusalNote(evidence.expect);
 		if (note) return {
@@ -2878,9 +2946,88 @@ function gradeFor(evidence, execution) {
 			note
 		};
 	}
-	if (evidence.expect && !output.includes(evidence.expect)) return { verdict: output === "" ? "silent-check" : "contradicted" };
+	if (evidence.expect && !output.includes(evidence.expect)) {
+		if (output === "") return { verdict: "silent-check" };
+		return refutation(output, evidence.expect);
+	}
 	return { verdict: "verified" };
 }
+/**
+* Decide between a claim verdict and an environment verdict for output that failed to establish
+* the claim. The signature list only ever downgrades a refutation to `unrunnable`: it can turn a
+* measurement that did not happen into an honest "not measured", and it can never turn a real
+* failure into a pass.
+*
+* The expectation is consulted first. A claim that PREDICTED the error is genuinely contradicted
+* when the error does not appear, so an expectation naming a signature switches this guard off
+* for that claim rather than letting it hide the one case it would grade backwards.
+*/
+function refutation(output, expect) {
+	if (expect && UNRUNNABLE_SIGNATURES.test(expect)) return { verdict: "contradicted" };
+	const hit = UNRUNNABLE_SIGNATURES.exec(output);
+	if (!hit) return { verdict: "contradicted" };
+	return {
+		verdict: "unrunnable",
+		note: `${UNREACHED_INPUT_NOTE} (${hit[0]})`
+	};
+}
+/**
+* Grade one pass of claims and flag the repeats within it.
+*
+* `gradeFor` judges one claim and cannot see a second claim carrying the same check, so a run
+* that recorded one verification under several titles reports as several independent
+* verifications. This function grades each claim exactly as `gradeFor` does and marks the later
+* claim with `duplicateOf`, leaving the verdict and the count untouched: the flag is for a reader
+* deciding how much evidence a run really produced.
+*/
+function gradeClaims(claims) {
+	const firstSeen = /* @__PURE__ */ new Map();
+	return claims.map((claim) => {
+		const grade = gradeFor(claim.evidence, claim.execution);
+		const key = claimCheckKey({
+			...claim.evidence,
+			title: claim.title
+		});
+		if (!key) return {
+			id: claim.id,
+			...grade
+		};
+		const seenAt = `${key}\u0000${grade.verdict}`;
+		const canonical = firstSeen.get(seenAt);
+		if (canonical === void 0) {
+			firstSeen.set(seenAt, claim.id);
+			return {
+				id: claim.id,
+				...grade
+			};
+		}
+		return {
+			id: claim.id,
+			...grade,
+			duplicateOf: canonical
+		};
+	});
+}
+/**
+* The identity two claims must share to be one verification counted twice: the same command, the
+* same expectation, and the same sentence. A check shared across claims that say different things
+* is one instrument used several times, which is not a duplicate.
+*
+* Returns `undefined` when the claim cannot be keyed at all — no check, or no title to compare —
+* so an unkeyable claim is never flagged as a repeat of another unkeyable one. The key is JSON
+* rather than a joined string, so no separator can collide with text inside a check.
+*/
+function claimCheckKey(claim) {
+	const check = claim.check?.trim();
+	if (!check) return void 0;
+	const title = claim.title?.trim().replace(/\s+/g, " ").toLowerCase().replace(/\.md$/, "");
+	if (!title) return void 0;
+	return JSON.stringify([
+		check,
+		claim.expect?.trim() ?? "",
+		title
+	]);
+}
 /** The verdict alone, for graders that report a lattice member and not a reason. */
 function verdictFor(evidence, execution) {
 	return gradeFor(evidence, execution).verdict;
@@ -2914,6 +3061,35 @@ async function verifyGradeableEvidence(evidence, options) {
 		grade: gradeFor(accepted, execution)
 	};
 }
+const WORD_CHARACTER = /[A-Za-z0-9_]/;
+/**
+* Whether the check text carries the value it is graded against.
+*
+* A check that contains its own expectation prints a value the claim's subject did not have to
+* produce, so the comparison that follows tests the author's typing rather than the artifact.
+* The test is the whole trimmed expectation appearing verbatim in the command, which is narrow
+* on purpose: it costs an author only a rewrite of the command, and it catches the shape
+* `isConstantEmitter` cannot, where a real command's arguments already spell the answer.
+*
+* An occurrence glued to a word character on a side where the expectation is itself a word
+* character does not count. Without that, a short expectation refuses the check that reads it:
+* `expect: 6` appears inside `node report6.mjs`, and refusing a correct claim is the cost this
+* file's rules are calibrated to avoid.
+*/
+function selfCertifyingNote(evidence) {
+	const wanted = evidence.expect?.trim();
+	const check = evidence.check;
+	if (!check || !wanted) return void 0;
+	const startsInsideWord = WORD_CHARACTER.test(wanted[0]);
+	const endsInsideWord = WORD_CHARACTER.test(wanted[wanted.length - 1]);
+	for (let at = check.indexOf(wanted); at !== -1; at = check.indexOf(wanted, at + 1)) {
+		const before = check[at - 1];
+		const after = check[at + wanted.length];
+		if (startsInsideWord && before !== void 0 && WORD_CHARACTER.test(before)) continue;
+		if (endsInsideWord && after !== void 0 && WORD_CHARACTER.test(after)) continue;
+		return SELF_CERTIFYING_NOTE;
+	}
+}
 function checkRefusalNote(check) {
 	if (!check) return NO_CHECK_NOTE;
 	if (isConstantEmitter(check)) return CONSTANT_EMITTER_NOTE;
@@ -2922,7 +3098,6 @@ function checkRefusalNote(check) {
 function expectationRefusalNote(expect) {
 	if (!expect?.trim()) return NO_EXPECTATION_NOTE;
 	if (expect.includes("\n") || expect.includes("\r")) return MULTILINE_EXPECTATION_NOTE;
-	if (expect.trim().split(/\s+/).filter((token) => token.includes("=")).length >= 3) return MULTI_VALUE_EXPECTATION_NOTE;
 }
 async function runBash(args, options) {
 	const { execFile } = await import("node:child_process");
@@ -2936,10 +3111,12 @@ async function runBash(args, options) {
 			encoding: "utf8"
 		}, (error, stdout, stderr) => {
 			const diagnostic = error && typeof error.code !== "number" ? `${stderr}\n${error}` : stderr;
+			const timedOut = error?.killed === true && error.name !== "AbortError";
 			resolve({
 				exitCode: typeof error?.code === "number" ? error.code : error ? 127 : 0,
 				stdout: String(stdout ?? ""),
-				stderr: String(diagnostic ?? "")
+				stderr: String(diagnostic ?? ""),
+				...timedOut ? { timedOut: true } : {}
 			});
 		});
 	});
@@ -3794,6 +3971,6 @@ function explainKnowledgeTarget(index, target) {
 	};
 }
 //#endregion
-export { resolveKnowledgeCitations as $, withKnowledgeRead as $t, sourceRegistryPath as A, KNOWLEDGE_EVENT_TYPES as At, buildKnowledgeGraph as B, emptyClaimLedger as Bt, verifyGradeableEvidence as C, writeFileDurableWithinRoot as Cn, KnowledgeRelationSchema as Ct, addSourceText as D, textSourceAdapter as Dn, ResearchSourceVersionSchema as Dt, addSourcePath as E, mediaTypeFor$1 as En, ResearchClaimRecordSchema as Et, KB_EVENTS_PATH as F, assertTrackedClaimIntegrity as Ft, assertKnowledgeCitationAudit as G, normalizeClaimText as Gt, KnowledgeCitationAuditError as H, materializeRegisteredClaimEvidence as Ht, KB_INDEX_PATH as I, claimEvidenceId as It, auditCurrentRunCitations as J, parseFrontmatter as Jt, assertKnowledgeCitationsResolved as K, researchSourceVersionKey as Kt, KB_STORE_DIR as L, claimId as Lt, ClaimLedgerMigrationRequiredError as M, assertDeepQuestionIntegrity as Mt, FileSystemKbStore as N, assertResearchClaimEvidenceIntegrity as Nt, loadSourceRegistry as O, SourceAnchorSchema as Ot, KB_CLAIM_LEDGER_DIR as P, assertResearchClaimLedgerIntegrity as Pt, resolveKnowledgeCitation as Q, withKnowledgeMutation as Qt, MemoryKbStore as R, claimSourceHost as Rt, verdictFor as S, writeFileDurable as Sn, KnowledgeRelationNodeSchema as St, writeKnowledgeIndex as T, writeJsonDurableWithinRoot as Tn, ResearchClaimLedgerSchema as Tt, KnowledgeCitationResolutionError as U, mergeClaimLedgers as Ut, knowledgePageRelations as V, linkClaimContradictions as Vt, assertCurrentRunCitationsResolved as W, mergeTrackedClaims as Wt, formatKnowledgeCitationReference as X, inspectPendingKnowledgeMutation as Xt, auditKnowledgeCitations as Y, acquireDurableFileLock as Yt, parseKnowledgeCitationReference as Z, recoverPendingKnowledgeMutation as Zt, lintKnowledgeIndex as _, removeDurable as _n, KnowledgeGraphNodeSchema as _t, applyKnowledgeWriteBlocksFile as a, prepareKnowledgeFileTransaction as an, isScaffoldPath as at, assertGradeableEvidence as b, withSafeDescendant as bn, KnowledgePageSchema as bt, KnowledgeDuplicateIntakeError as c, normalizePagesDirectory as cn, loadKnowledgePages as ct, createFileRunLineageAuthority as d, isKernelAnchoredPath as dn, extractWikilinks as dt, applyKnowledgeFileTransaction as en, resolveRunScopedCitation as et, createRunScopedStores as f, isMissingFile as fn, normalizeLinkTarget as ft, validateKnowledgeIndex as g, relativeWithinRoot as gn, KnowledgeGraphEdgeSchema as gt, normalizePageText as h, readRegularFileWithinRoot as hn, KnowledgeEventSchema as ht, applyKnowledgeWriteBlocks as i, knowledgeFileTransactionPlanHash as in, isKnowledgePagePath as it, writeSourceRegistry as j, ClaimLedgerGoalConflictError as jt, snapshotSourceTextInput as k, SourceRecordSchema as kt, assertKnowledgeWriteIntake as l, canonicalPathsEqual as ln, writeJson as lt, detectNearDuplicatePages as m, readRegularFileNoFollow as mn, KnowledgeBaseCandidateSchema as mt, inspectKnowledgeIndex as n, commitKnowledgeFileMutations as nn, SCAFFOLD_PAGE_BASENAMES as nt, isSafeKnowledgePath as o, rollbackKnowledgeFileTransaction as on, knowledgePageFromMarkdown as ot, originatedPages as p, listRegularFilesWithinRoot as pn, DeepQuestionSchema as pt, assertRunScopedCitationsResolved as q, formatFrontmatter as qt, stringMetadata as r, finishKnowledgeFileTransaction as rn, initKnowledgeBase as rt, parseKnowledgeWriteBlocks as s, DEFAULT_PAGES_DIRECTORY as sn, layoutFor as st, explainKnowledgeTarget as t, assertKnowledgeMutationPath as tn, resolveRunScopedCitations as tt, RUN_LINEAGE_BASENAME as u, canonicalRelativeWithinRoot as un, WIKILINK_REGEX as ut, CHECKABLE_RUNG_THRESHOLD as v, renameDurable as vn, KnowledgeIndexSchema as vt, buildKnowledgeIndex as w, writeJsonDurable as wn, ResearchClaimEvidenceSchema as wt, gradeFor as x, withSafeDirectory as xn, KnowledgeRelationGraphSchema as xt, UncheckableClaimError as y, syncDirectory as yn, KnowledgePageInvalidationSchema as yt, assertClaimLedgerId as z, deepQuestionId as zt };
+export { formatKnowledgeCitationReference as $, inspectPendingKnowledgeMutation as $t, addSourceText as A, writeJsonDurableWithinRoot as An, ResearchSourceVersionSchema as At, KB_STORE_DIR as B, claimId as Bt, gradeClaims as C, renameDurable as Cn, KnowledgePageSchema as Ct, buildKnowledgeIndex as D, writeFileDurable as Dn, ResearchClaimEvidenceSchema as Dt, verifyGradeableEvidence as E, withSafeDirectory as En, KnowledgeRelationSchema as Et, ClaimLedgerMigrationRequiredError as F, assertDeepQuestionIntegrity as Ft, KnowledgeCitationAuditError as G, materializeRegisteredClaimEvidence as Gt, assertClaimLedgerId as H, deepQuestionId as Ht, FileSystemKbStore as I, assertResearchClaimEvidenceIntegrity as It, assertKnowledgeCitationAudit as J, normalizeClaimText as Jt, KnowledgeCitationResolutionError as K, mergeClaimLedgers as Kt, KB_CLAIM_LEDGER_DIR as L, assertResearchClaimLedgerIntegrity as Lt, snapshotSourceTextInput as M, textSourceAdapter as Mn, SourceRecordSchema as Mt, sourceRegistryPath as N, KNOWLEDGE_EVENT_TYPES as Nt, writeKnowledgeIndex as O, writeFileDurableWithinRoot as On, ResearchClaimLedgerSchema as Ot, writeSourceRegistry as P, ClaimLedgerGoalConflictError as Pt, auditKnowledgeCitations as Q, acquireDurableFileLock as Qt, KB_EVENTS_PATH as R, assertTrackedClaimIntegrity as Rt, claimCheckKey as S, removeDurable as Sn, KnowledgePageInvalidationSchema as St, verdictFor as T, withSafeDescendant as Tn, KnowledgeRelationNodeSchema as Tt, buildKnowledgeGraph as U, emptyClaimLedger as Ut, MemoryKbStore as V, claimSourceHost as Vt, knowledgePageRelations as W, linkClaimContradictions as Wt, assertRunScopedCitationsResolved as X, formatFrontmatter as Xt, assertKnowledgeCitationsResolved as Y, researchSourceVersionKey as Yt, auditCurrentRunCitations as Z, parseFrontmatter as Zt, lintKnowledgeIndex as _, isMissingFile as _n, KnowledgeBaseCandidateSchema as _t, applyKnowledgeWriteBlocksFile as a, applyKnowledgeFileTransaction as an, SCAFFOLD_PAGE_BASENAMES as at, UncheckableClaimError as b, readRegularFileWithinRoot as bn, KnowledgeGraphNodeSchema as bt, KnowledgeDuplicateIntakeError as c, finishKnowledgeFileTransaction as cn, isScaffoldPath as ct, createFileRunLineageAuthority as d, rollbackKnowledgeFileTransaction as dn, loadKnowledgePages as dt, isKnowledgeMutationHeld as en, parseKnowledgeCitationReference as et, createRunScopedStores as f, DEFAULT_PAGES_DIRECTORY as fn, writeJson as ft, validateKnowledgeIndex as g, isKernelAnchoredPath as gn, DeepQuestionSchema as gt, normalizePageText as h, canonicalRelativeWithinRoot as hn, normalizeLinkTarget as ht, applyKnowledgeWriteBlocks as i, withKnowledgeRead as in, resolveRunScopedCitations as it, loadSourceRegistry as j, mediaTypeFor$1 as jn, SourceAnchorSchema as jt, addSourcePath as k, writeJsonDurable as kn, ResearchClaimRecordSchema as kt, assertKnowledgeWriteIntake as l, knowledgeFileTransactionPlanHash as ln, knowledgePageFromMarkdown as lt, detectNearDuplicatePages as m, canonicalPathsEqual as mn, extractWikilinks as mt, inspectKnowledgeIndex as n, runInKnowledgeMutationScope as nn, resolveKnowledgeCitations as nt, isSafeKnowledgePath as o, assertKnowledgeMutationPath as on, initKnowledgeBase as ot, originatedPages as p, normalizePagesDirectory as pn, WIKILINK_REGEX as pt, assertCurrentRunCitationsResolved as q, mergeTrackedClaims as qt, stringMetadata as r, withKnowledgeMutation as rn, resolveRunScopedCitation as rt, parseKnowledgeWriteBlocks as s, commitKnowledgeFileMutations as sn, isKnowledgePagePath as st, explainKnowledgeTarget as t, recoverPendingKnowledgeMutation as tn, resolveKnowledgeCitation as tt, RUN_LINEAGE_BASENAME as u, prepareKnowledgeFileTransaction as un, layoutFor as ut, CHECKABLE_RUNG_THRESHOLD as v, listRegularFilesWithinRoot as vn, KnowledgeEventSchema as vt, gradeFor as w, syncDirectory as wn, KnowledgeRelationGraphSchema as wt, assertGradeableEvidence as x, relativeWithinRoot as xn, KnowledgeIndexSchema as xt, DEADLINE_EXIT_CODE as y, readRegularFileNoFollow as yn, KnowledgeGraphEdgeSchema as yt, KB_INDEX_PATH as z, claimEvidenceId as zt };
 
-//# sourceMappingURL=inspect-yYqLQuM4.js.map
+//# sourceMappingURL=inspect-BUp9GUKO.js.map