@tangle-network/agent-knowledge 18.0.0 → 19.0.0

package/dist/{inspect-BVT9JWDL.js → inspect-C6YK7af7.js}

@@ -3,6 +3,7 @@ import { r as searchKnowledge } from "./search-Cbyj2shJ.js";
 import { createHash, randomUUID } from "node:crypto";
 import { lstat, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { canonicalCandidateBytes, canonicalCandidateDigest, sha256Bytes, sha256DigestSchema } from "@tangle-network/agent-interface";
 import { contentHash } from "@tangle-network/agent-eval";
 import { z } from "zod";
 import { constants } from "node:fs";
@@ -400,6 +401,8 @@ const transactionSchema = z.object({
 	transactionId: z.string().uuid(),
 	purpose: z.string().min(1),
 	recoveryOwner: z.string().min(1).max(256).optional(),
+	actorId: z.string().trim().min(1).max(256).nullable().optional(),
+	runId: z.string().trim().min(1).max(256).nullable().optional(),
 	pagesDirectory: pagesDirectorySchema.optional(),
 	researchState: z.boolean().optional(),
 	retainHistory: z.boolean().optional(),
@@ -429,6 +432,10 @@ async function prepareKnowledgeFileTransaction(input) {
 			if (mutation.content === null && mutation.mode !== void 0) throw new Error(`deleted knowledge file cannot declare a mode: ${path}`);
 			paths.add(path);
 			const before = await withSafeDescendant(input.root, path, readRegularFile);
+			if (mutation.expectedBeforeHash !== void 0) {
+				const expected = digestSchema.nullable().parse(mutation.expectedBeforeHash);
+				if ((before ? hashBytes(before.bytes) : null) !== expected) throw new Error(`knowledge file changed before transaction: ${path}`);
+			}
 			const after = mutation.content === null ? null : Buffer.isBuffer(mutation.content) ? mutation.content : Buffer.from(mutation.content, "utf8");
 			const afterMode = after ? fileModeSchema.parse(mutation.mode ?? before?.mode ?? DEFAULT_FILE_MODE) : void 0;
 			if (!input.includeUnchanged && sameBytes(before?.bytes ?? null, after) && before?.mode === afterMode) return null;
@@ -457,6 +464,8 @@ async function prepareKnowledgeFileTransaction(input) {
 				kind: "knowledge-file-transaction",
 				transactionId: randomUUID(),
 				purpose: input.purpose,
+				actorId: input.actorId ?? null,
+				runId: input.runId ?? null,
 				...input.recoveryOwner ? { recoveryOwner: input.recoveryOwner } : {},
 				...pagesDirectory === void 0 ? {} : { pagesDirectory },
 				...input.researchState === void 0 ? {} : { researchState: input.researchState },
@@ -494,6 +503,8 @@ async function commitKnowledgeFileMutations(input) {
 		root: input.root,
 		transactionRoot: input.transactionRoot,
 		purpose: input.purpose,
+		actorId: input.actorId,
+		runId: input.runId,
 		mutations: input.mutations,
 		...input.researchState === void 0 ? {} : { researchState: input.researchState },
 		...input.retainHistory === void 0 ? {} : { retainHistory: input.retainHistory },
@@ -3622,6 +3633,212 @@ function round(value) {
 	return Math.round(value * 1e6) / 1e6;
 }
 //#endregion
+//#region src/knowledge-visibility.ts
+const KNOWLEDGE_USE_RECEIPT_SCHEMA_VERSION = "2.0.0";
+const KNOWLEDGE_RECEIPT_DIGEST_ALGORITHM = "rfc8785-sha256";
+/** Stable content identity for one exact knowledge page. */
+function knowledgePageDigest(page) {
+	validateKnowledgePage(page);
+	return canonicalCandidateDigest({
+		id: page.id,
+		path: page.path,
+		title: page.title,
+		text: page.text,
+		frontmatter: page.frontmatter,
+		sourceIds: [...page.sourceIds],
+		tags: [...page.tags],
+		outLinks: [...page.outLinks],
+		contradicts: [...page.contradicts ?? []],
+		invalidation: page.invalidation ?? null
+	});
+}
+/** Snapshot the exact ordered current/ancestor/shared page view. */
+function createKnowledgeVisibilitySnapshot(visiblePages) {
+	if (!Array.isArray(visiblePages)) throw new TypeError("knowledge visibility must be an array");
+	const identities = /* @__PURE__ */ new Set();
+	const entries = visiblePages.map((entry, position) => {
+		if (!entry || typeof entry !== "object") throw new TypeError(`knowledge visibility[${position}] must be an originated page`);
+		const origin = validateOrigin(entry.origin, `knowledge visibility[${position}].origin`);
+		validateKnowledgePage(entry.page);
+		const identity = visibilityIdentity(origin, entry.page.path);
+		if (identities.has(identity)) throw new Error(`knowledge visibility repeats path '${entry.page.path}' at origin '${origin}'`);
+		identities.add(identity);
+		return Object.freeze({
+			position,
+			pageId: entry.page.id,
+			origin,
+			path: entry.page.path,
+			pageDigest: knowledgePageDigest(entry.page),
+			sourceIds: Object.freeze([...entry.page.sourceIds]),
+			invalidated: entry.page.invalidation !== void 0
+		});
+	});
+	const material = visibilityMaterial(entries);
+	const snapshot = Object.freeze({
+		...material,
+		snapshotDigest: canonicalCandidateDigest(material),
+		entries: Object.freeze(entries)
+	});
+	visibilityIndexes.set(snapshot, indexVisibility(snapshot));
+	return snapshot;
+}
+/**
+* Verify a snapshot's schema and canonical digest. The check runs once per
+* snapshot object; later calls with the same object are free.
+*/
+function verifyKnowledgeVisibilitySnapshot(snapshot) {
+	return visibilityIndexOf(snapshot).snapshot;
+}
+/** Canonical bytes of a verified snapshot, for durable storage. */
+function encodeKnowledgeVisibilitySnapshot(snapshot) {
+	const verified = verifyKnowledgeVisibilitySnapshot(snapshot);
+	return canonicalCandidateBytes({
+		schemaVersion: verified.schemaVersion,
+		digestAlgorithm: verified.digestAlgorithm,
+		snapshotDigest: verified.snapshotDigest,
+		entries: visibilityMaterial(verified.entries).entries
+	});
+}
+/** Parse stored snapshot bytes and verify their schema and digest. */
+function decodeKnowledgeVisibilitySnapshot(bytes) {
+	if (!(bytes instanceof Uint8Array)) throw new TypeError("knowledge visibility snapshot bytes must be a Uint8Array");
+	let parsed;
+	try {
+		parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+	} catch (error) {
+		throw new Error(`knowledge visibility snapshot bytes are not JSON: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new TypeError("knowledge visibility snapshot must be an object");
+	const candidate = parsed;
+	if (!Array.isArray(candidate.entries)) throw new TypeError("knowledge visibility snapshot entries must be an array");
+	return verifyKnowledgeVisibilitySnapshot(Object.freeze({
+		schemaVersion: candidate.schemaVersion,
+		digestAlgorithm: candidate.digestAlgorithm,
+		snapshotDigest: digest(candidate.snapshotDigest, "knowledge visibility snapshotDigest"),
+		entries: Object.freeze(candidate.entries.map((entry, position) => {
+			if (!entry || typeof entry !== "object") throw new TypeError(`knowledge visibility[${position}] must be an object`);
+			const value = entry;
+			if (!Array.isArray(value.sourceIds)) throw new TypeError(`knowledge visibility[${position}].sourceIds must be an array`);
+			return Object.freeze({
+				position: value.position,
+				pageId: value.pageId,
+				origin: value.origin,
+				path: value.path,
+				pageDigest: value.pageDigest,
+				sourceIds: Object.freeze([...value.sourceIds]),
+				invalidated: value.invalidated
+			});
+		}))
+	}));
+}
+/** Locator for snapshot bytes stored at `uri`. */
+function knowledgeVisibilityArtifactRef(input) {
+	if (!input || typeof input !== "object" || !(input.bytes instanceof Uint8Array)) throw new TypeError("knowledge visibility artifact bytes must be a Uint8Array");
+	if (input.bytes.byteLength === 0) throw new TypeError("knowledge visibility artifact bytes must not be empty");
+	return Object.freeze({
+		uri: nonEmpty(input.uri, "knowledge visibility artifact uri"),
+		digest: sha256Bytes(input.bytes),
+		byteLength: input.bytes.byteLength
+	});
+}
+const visibilityIndexes = /* @__PURE__ */ new WeakMap();
+function visibilityIndexOf(snapshot) {
+	if (!snapshot || typeof snapshot !== "object") throw new TypeError("knowledge visibility snapshot is required");
+	const cached = visibilityIndexes.get(snapshot);
+	if (cached !== void 0) return cached;
+	assertSchemaVersion(snapshot.schemaVersion, "knowledge visibility");
+	if (snapshot.digestAlgorithm !== "rfc8785-sha256") throw new Error(`unsupported knowledge visibility digestAlgorithm '${snapshot.digestAlgorithm}'`);
+	if (!Array.isArray(snapshot.entries)) throw new TypeError("knowledge visibility snapshot entries must be an array");
+	if (canonicalCandidateDigest(visibilityMaterial(snapshot.entries)) !== digest(snapshot.snapshotDigest, "knowledge visibility snapshotDigest")) throw new Error("knowledge visibility snapshot digest mismatch");
+	const index = indexVisibility(snapshot);
+	visibilityIndexes.set(snapshot, index);
+	return index;
+}
+function indexVisibility(snapshot) {
+	const byIdentity = /* @__PURE__ */ new Map();
+	for (const entry of snapshot.entries) {
+		const identity = visibilityIdentity(entry.origin, entry.path);
+		if (byIdentity.has(identity)) throw new Error(`knowledge visibility repeats path '${entry.path}' at origin '${entry.origin}'`);
+		byIdentity.set(identity, entry);
+	}
+	return {
+		snapshot,
+		byIdentity
+	};
+}
+function visibilityIdentity(origin, path) {
+	return `${origin}\u0000${path}`;
+}
+function assertSchemaVersion(value, label) {
+	if (value === "2.0.0") return;
+	throw new Error(`unsupported ${label} schemaVersion '${String(value)}'${value === "1.0.0" ? "; 1.0.0 records embed the visibility snapshot and have no reader, create a 2.0.0 record from the snapshot" : ""}`);
+}
+function visibilityMaterial(entries) {
+	return {
+		schemaVersion: KNOWLEDGE_USE_RECEIPT_SCHEMA_VERSION,
+		digestAlgorithm: KNOWLEDGE_RECEIPT_DIGEST_ALGORITHM,
+		entries: entries.map((entry, position) => {
+			if (!entry || typeof entry !== "object") throw new TypeError(`knowledge visibility[${position}] must be an object`);
+			if (entry.position !== position) throw new Error(`knowledge visibility position mismatch: expected ${position}, observed ${entry.position}`);
+			if (!Array.isArray(entry.sourceIds)) throw new TypeError(`knowledge visibility[${position}].sourceIds must be an array`);
+			return {
+				position,
+				pageId: nonEmpty(entry.pageId, `knowledge visibility[${position}].pageId`),
+				origin: validateOrigin(entry.origin, `knowledge visibility[${position}].origin`),
+				path: nonEmpty(entry.path, `knowledge visibility[${position}].path`),
+				pageDigest: digest(entry.pageDigest, `knowledge visibility[${position}].pageDigest`),
+				sourceIds: entry.sourceIds.map((sourceId, sourceIndex) => nonEmpty(sourceId, `knowledge visibility[${position}].sourceIds[${sourceIndex}]`)),
+				invalidated: Boolean(entry.invalidated)
+			};
+		})
+	};
+}
+function normalizeVisibilityRef(input) {
+	if (!input || typeof input !== "object") throw new TypeError("knowledge retrieval visibility reference is required");
+	if (!Number.isSafeInteger(input.pageCount) || input.pageCount < 0) throw new TypeError("knowledge retrieval visibility pageCount must be a non-negative integer");
+	return Object.freeze({
+		snapshotDigest: digest(input.snapshotDigest, "knowledge retrieval visibility snapshotDigest"),
+		pageCount: input.pageCount,
+		...input.artifact === void 0 ? {} : { artifact: normalizeVisibilityArtifact(input.artifact, "knowledge retrieval visibility artifact") }
+	});
+}
+function normalizeVisibilityArtifact(input, label) {
+	if (!input || typeof input !== "object") throw new TypeError(`${label} must be an object`);
+	if (!Number.isSafeInteger(input.byteLength) || input.byteLength < 1) throw new TypeError(`${label} byteLength must be a positive integer`);
+	return Object.freeze({
+		uri: nonEmpty(input.uri, `${label} uri`),
+		digest: digest(input.digest, `${label} digest`),
+		byteLength: input.byteLength
+	});
+}
+function validateKnowledgePage(page) {
+	if (!page || typeof page !== "object") throw new TypeError("knowledge page must be an object");
+	nonEmpty(page.id, "knowledge page id");
+	nonEmpty(page.path, "knowledge page path");
+	nonEmpty(page.title, "knowledge page title");
+	if (typeof page.text !== "string") throw new TypeError("knowledge page text must be a string");
+	if (!page.frontmatter || typeof page.frontmatter !== "object" || Array.isArray(page.frontmatter)) throw new TypeError("knowledge page frontmatter must be an object");
+	for (const [name, values] of [
+		["sourceIds", page.sourceIds],
+		["tags", page.tags],
+		["outLinks", page.outLinks]
+	]) if (!Array.isArray(values) || values.some((value) => typeof value !== "string")) throw new TypeError(`knowledge page ${name} must be a string array`);
+}
+function validateOrigin(value, label) {
+	if (value === "here" || value === "shared") return value;
+	if (typeof value === "string" && value.startsWith("inherited:") && value.slice(10).trim().length > 0) return value;
+	throw new TypeError(`${label} is invalid: ${String(value)}`);
+}
+function digest(value, label) {
+	const parsed = sha256DigestSchema.safeParse(value);
+	if (!parsed.success) throw new TypeError(`${label} must be a lowercase sha256 digest`);
+	return parsed.data;
+}
+function nonEmpty(value, label) {
+	if (typeof value !== "string" || value.trim().length === 0) throw new TypeError(`${label} must be a non-empty string`);
+	return value.trim();
+}
+//#endregion
 //#region src/run-scoped.ts
 /**
 * Run-scoped knowledge stores with lineage-chain reads.
@@ -3961,7 +4178,13 @@ function parseKnowledgeWriteBlocks(text, allowedPrefixes = ["knowledge/"]) {
 async function applyKnowledgeWriteBlocks(root, proposalText, options = {}) {
 	const pagesDirectory = normalizePagesDirectory(options.pagesDirectory);
 	const parsed = parseKnowledgeWriteBlocks(proposalText, [`${pagesDirectory}/`]);
-	const purpose = `knowledge-proposal:${contentHash(parsed.blocks)}`;
+	const identity = options.actorId === void 0 && options.runId === void 0 && options.expectedPageDigests === void 0 ? parsed.blocks : {
+		blocks: parsed.blocks,
+		actorId: options.actorId ?? null,
+		runId: options.runId ?? null,
+		expectedPageDigests: options.expectedPageDigests ?? null
+	};
+	const purpose = "knowledge-proposal:" + contentHash(identity);
 	const intake = options.intake;
 	return withKnowledgeMutation(root, async (lock) => {
 		if (parsed.blocks.length > 0) {
@@ -3969,6 +4192,23 @@ async function applyKnowledgeWriteBlocks(root, proposalText, options = {}) {
 				path: block.path,
 				content: block.content.endsWith("\n") ? block.content : `${block.content}\n`
 			}));
+			if (options.expectedPageDigests !== void 0) {
+				const paths = new Set(mutations.map((mutation) => mutation.path));
+				for (const path of Object.keys(options.expectedPageDigests)) if (!paths.has(path)) throw new Error(`Expected digest has no proposed page: ${path}`);
+				for (const mutation of mutations) {
+					let before;
+					try {
+						before = await readRegularFileWithinRoot(root, mutation.path);
+					} catch (error) {
+						if (!isMissingFile(error)) throw error;
+					}
+					const current = before === void 0 ? null : knowledgePageDigest(knowledgePageFromMarkdown(mutation.path, Buffer.from(before.bytes).toString("utf8"), pagesDirectory));
+					const expected = Object.hasOwn(options.expectedPageDigests, mutation.path) ? options.expectedPageDigests[mutation.path] : null;
+					if (expected !== null && !/^sha256:[a-f0-9]{64}$/.test(expected ?? "")) throw new Error(`Invalid expected page digest: ${mutation.path}`);
+					if (current !== expected && !(!(Object.hasOwn(options.expectedPageDigests, mutation.path) && expected === null) && before !== void 0 && Buffer.from(before.bytes).equals(Buffer.from(mutation.content ?? "")))) throw new Error(`knowledge page changed: ${mutation.path}; current digest: ${current ?? "absent"}. Read the current page before editing it.`);
+					mutation.expectedBeforeHash = before === void 0 ? null : createHash("sha256").update(before.bytes).digest("hex");
+				}
+			}
 			if (intake) {
 				const { inheritedPages = [], ...settings } = intake;
 				const here = await loadKnowledgePages(root, { pagesDirectory });
@@ -3981,6 +4221,8 @@ async function applyKnowledgeWriteBlocks(root, proposalText, options = {}) {
 				root,
 				transactionRoot: lock.transactionRoot,
 				purpose,
+				actorId: options.actorId,
+				runId: options.runId,
 				mutations,
 				pagesDirectory,
 				retainHistory: options.retainHistory,
@@ -4074,6 +4316,6 @@ function explainKnowledgeTarget(index, target) {
 	};
 }
 //#endregion
-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 };
+export { FileSystemKbStore as $, assertResearchClaimEvidenceIntegrity as $t, visibilityIndexOf as A, normalizePagesDirectory as An, WIKILINK_REGEX as At, gradeClaims as B, renameDurable as Bn, KnowledgePageSchema as Bt, nonEmpty as C, assertKnowledgeMutationPath as Cn, initKnowledgeBase as Ct, validateOrigin as D, prepareKnowledgeFileTransaction as Dn, layoutFor as Dt, validateKnowledgePage as E, knowledgeFileTransactionPlanHash as En, knowledgePageFromMarkdown as Et, CHECKABLE_RUNG_THRESHOLD as F, listRegularFilesWithinRoot as Fn, KnowledgeEventSchema as Ft, writeKnowledgeIndex as G, writeFileDurableWithinRoot as Gn, ResearchClaimLedgerSchema as Gt, verdictFor as H, withSafeDescendant as Hn, KnowledgeRelationNodeSchema as Ht, DEADLINE_EXIT_CODE as I, readRegularFileNoFollow as In, KnowledgeGraphEdgeSchema as It, loadSourceRegistry as J, mediaTypeFor$1 as Jn, SourceAnchorSchema as Jt, addSourcePath as K, writeJsonDurable as Kn, ResearchClaimRecordSchema as Kt, UncheckableClaimError as L, readRegularFileWithinRoot as Ln, KnowledgeGraphNodeSchema as Lt, normalizePageText as M, canonicalRelativeWithinRoot as Mn, normalizeLinkTarget as Mt, validateKnowledgeIndex as N, isKernelAnchoredPath as Nn, DeepQuestionSchema as Nt, verifyKnowledgeVisibilitySnapshot as O, rollbackKnowledgeFileTransaction as On, loadKnowledgePages as Ot, lintKnowledgeIndex as P, isMissingFile as Pn, KnowledgeBaseCandidateSchema as Pt, ClaimLedgerMigrationRequiredError as Q, assertDeepQuestionIntegrity as Qt, assertGradeableEvidence as R, relativeWithinRoot as Rn, KnowledgeIndexSchema as Rt, knowledgeVisibilityArtifactRef as S, applyKnowledgeFileTransaction as Sn, SCAFFOLD_PAGE_BASENAMES as St, normalizeVisibilityRef as T, finishKnowledgeFileTransaction as Tn, isScaffoldPath as Tt, verifyGradeableEvidence as U, withSafeDirectory as Un, KnowledgeRelationSchema as Ut, gradeFor as V, syncDirectory as Vn, KnowledgeRelationGraphSchema as Vt, buildKnowledgeIndex as W, writeFileDurable as Wn, ResearchClaimEvidenceSchema as Wt, sourceRegistryPath as X, KNOWLEDGE_EVENT_TYPES as Xt, snapshotSourceTextInput as Y, textSourceAdapter as Yn, SourceRecordSchema as Yt, writeSourceRegistry as Z, ClaimLedgerGoalConflictError as Zt, createKnowledgeVisibilitySnapshot as _, isKnowledgeMutationHeld as _n, parseKnowledgeCitationReference as _t, applyKnowledgeWriteBlocksFile as a, deepQuestionId as an, assertClaimLedgerId as at, encodeKnowledgeVisibilitySnapshot as b, withKnowledgeMutation as bn, resolveRunScopedCitation as bt, KnowledgeDuplicateIntakeError as c, materializeRegisteredClaimEvidence as cn, KnowledgeCitationAuditError as ct, createFileRunLineageAuthority as d, normalizeClaimText as dn, assertKnowledgeCitationAudit as dt, assertResearchClaimLedgerIntegrity as en, KB_CLAIM_LEDGER_DIR as et, createRunScopedStores as f, researchSourceVersionKey as fn, assertKnowledgeCitationsResolved as ft, assertSchemaVersion as g, inspectPendingKnowledgeMutation as gn, formatKnowledgeCitationReference as gt, KNOWLEDGE_USE_RECEIPT_SCHEMA_VERSION as h, acquireDurableFileLock as hn, auditKnowledgeCitations as ht, applyKnowledgeWriteBlocks as i, claimSourceHost as in, MemoryKbStore as it, detectNearDuplicatePages as j, canonicalPathsEqual as jn, extractWikilinks as jt, visibilityIdentity as k, DEFAULT_PAGES_DIRECTORY as kn, writeJson as kt, assertKnowledgeWriteIntake as l, mergeClaimLedgers as ln, KnowledgeCitationResolutionError as lt, KNOWLEDGE_RECEIPT_DIGEST_ALGORITHM as m, parseFrontmatter as mn, auditCurrentRunCitations as mt, inspectKnowledgeIndex as n, claimEvidenceId as nn, KB_INDEX_PATH as nt, isSafeKnowledgePath as o, emptyClaimLedger as on, buildKnowledgeGraph as ot, originatedPages as p, formatFrontmatter as pn, assertRunScopedCitationsResolved as pt, addSourceText as q, writeJsonDurableWithinRoot as qn, ResearchSourceVersionSchema as qt, stringMetadata as r, claimId as rn, KB_STORE_DIR as rt, parseKnowledgeWriteBlocks as s, linkClaimContradictions as sn, knowledgePageRelations as st, explainKnowledgeTarget as t, assertTrackedClaimIntegrity as tn, KB_EVENTS_PATH as tt, RUN_LINEAGE_BASENAME as u, mergeTrackedClaims as un, assertCurrentRunCitationsResolved as ut, decodeKnowledgeVisibilitySnapshot as v, recoverPendingKnowledgeMutation as vn, resolveKnowledgeCitation as vt, normalizeVisibilityArtifact as w, commitKnowledgeFileMutations as wn, isKnowledgePagePath as wt, knowledgePageDigest as x, withKnowledgeRead as xn, resolveRunScopedCitations as xt, digest as y, runInKnowledgeMutationScope as yn, resolveKnowledgeCitations as yt, claimCheckKey as z, removeDurable as zn, KnowledgePageInvalidationSchema as zt };
 
-//# sourceMappingURL=inspect-BVT9JWDL.js.map
+//# sourceMappingURL=inspect-C6YK7af7.js.map