@moldea.ai/core 5.0.1 → 7.0.0

package/dist/chunks/core-Cdeiu6xG.js

@@ -0,0 +1,3364 @@
+import { E as parseDecisionIdFromPath, S as isRuntimeGuidancePath, T as isVariableId, a as escapeJsonPointerSegment, c as freezeRecursively, d as hasNonWhitespace, g as isContextPath, i as createCoreDiagnosticCollector, k as trimRepositoryFormatWhitespace, l as compareExactStrings, n as normalizeCoreOptions, o as normalizeDiagnostics, r as countDiagnosticsBySeverity, s as createNullPrototypeRecord, t as createCoreOperationOptionsSnapshot, u as countUnicodeScalars } from "./options-5x9gu2Qb.js";
+import { n as CoreOperationException } from "./exceptions-IXsorE8t.js";
+import { a as createSourceLocator, c as calculateContentDigest, i as parseStrictYaml, l as calculateNormalizedTextDigest, n as inspectManifestDocument, o as collectManifestScopeDeclarations, r as parseManifestDocument, s as matchesRepositoryGlob, t as matchManifestScope, u as normalizeTextDocument } from "./scope-AGMcHUE_.js";
+import { REPOSITORY_ROOT, RepositorySourceException, compareRepositoryPaths, createRepositoryIdentity, isRepositoryPath, parseRepositoryPath } from "@moldea.ai/repository";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region src/canonical-content-page/index.ts
+var decoder = new TextDecoder("utf-8", {
+	fatal: true,
+	ignoreBOM: true
+});
+var invalidArgument$2 = () => {
+	throw new CoreOperationException({
+		code: "INVALID_ARGUMENT",
+		operation: "read-canonical-content-page"
+	});
+};
+var invalidContent = () => {
+	throw new CoreOperationException({
+		code: "CONTENT_INVALID",
+		operation: "read-canonical-content-page"
+	});
+};
+var isRepositoryReader$1 = (candidate) => typeof candidate === "object" && candidate !== null && typeof candidate.getEntry === "function" && typeof candidate.readFilePage === "function";
+var readBytes = async (repository, path, offset, maxBytes, signal) => {
+	const chunks = [];
+	let byteLength = 0;
+	let nextOffset = offset;
+	let lastPage = null;
+	let totalBytes = null;
+	while (byteLength < maxBytes) {
+		const page = await repository.readFilePage(path, {
+			maxBytes: maxBytes - byteLength,
+			offset: nextOffset,
+			...signal === void 0 ? {} : { signal }
+		});
+		if (page.snapshot.id !== repository.snapshot.id || page.offset !== nextOffset || page.bytes.byteLength > maxBytes - byteLength || page.totalBytes < page.offset + page.bytes.byteLength || totalBytes !== null && page.totalBytes !== totalBytes || page.bytes.byteLength === 0 && !page.isComplete) throw new RepositorySourceException({
+			code: "INVALID_SOURCE_DATA",
+			operation: "read-file-page",
+			path,
+			retryable: false
+		});
+		chunks.push(page.bytes);
+		byteLength += page.bytes.byteLength;
+		totalBytes = page.totalBytes;
+		lastPage = page;
+		if (page.isComplete || byteLength === maxBytes) break;
+		if (page.nextOffset !== page.offset + page.bytes.byteLength) throw new RepositorySourceException({
+			code: "INVALID_SOURCE_DATA",
+			operation: "read-file-page",
+			path,
+			retryable: false
+		});
+		nextOffset = page.nextOffset;
+	}
+	if (lastPage === null) return invalidArgument$2();
+	const bytes = new Uint8Array(byteLength);
+	let writeOffset = 0;
+	for (const chunk of chunks) {
+		bytes.set(chunk, writeOffset);
+		writeOffset += chunk.byteLength;
+	}
+	return {
+		bytes,
+		lastPage
+	};
+};
+var decodeSafePrefix = (bytes, maximumBytes) => {
+	const minimumCandidate = Math.max(0, maximumBytes - 3);
+	for (let end = maximumBytes; end >= minimumCandidate; end -= 1) try {
+		const content = decoder.decode(bytes.subarray(0, end));
+		if (end === 0 && bytes.byteLength > 0) continue;
+		return [content, end];
+	} catch {}
+	return invalidContent();
+};
+/** Reads one explicit canonical file range without materializing the complete file. */
+var readCanonicalContentPage = async (input, options) => {
+	if (typeof input !== "object" || input === null || Reflect.ownKeys(input).some((key) => key !== "maxBytes" && key !== "offset" && key !== "path" && key !== "repository" && key !== "signal") || !isRepositoryReader$1(input.repository) || !Number.isSafeInteger(input.maxBytes) || input.maxBytes < 1 || input.maxBytes > options.limits.maxFileBytes || !Number.isSafeInteger(input.offset) || input.offset < 0) return invalidArgument$2();
+	const path = parseRepositoryPath(input.path);
+	if (!path.startsWith("/moldea/")) return invalidArgument$2();
+	const operationOptions = input.signal === void 0 ? void 0 : { signal: input.signal };
+	const entry = await input.repository.getEntry(path, operationOptions);
+	if (entry === null) throw new RepositorySourceException({
+		code: "ENTRY_NOT_FOUND",
+		operation: "read-file-page",
+		path,
+		retryable: false
+	});
+	if (entry.type !== "file" || entry.byteLength === null) throw new RepositorySourceException({
+		code: "ENTRY_NOT_FILE",
+		operation: "read-file-page",
+		path,
+		retryable: false
+	});
+	if (entry.byteLength > options.limits.maxFileBytes) throw new CoreOperationException({
+		code: "RESOURCE_LIMIT_EXCEEDED",
+		limit: "maxFileBytes",
+		limitMaximum: options.limits.maxFileBytes,
+		nextAction: "reduce-input-or-increase-limit",
+		observedUsage: entry.byteLength,
+		operation: "read-canonical-content-page"
+	});
+	if (input.offset > entry.byteLength) return invalidArgument$2();
+	if (input.offset === entry.byteLength) return freezeRecursively({
+		byteEnd: input.offset,
+		byteStart: input.offset,
+		content: "",
+		contentIdentity: entry.contentIdentity,
+		isComplete: true,
+		nextOffset: null,
+		path,
+		source: input.repository.snapshot,
+		totalBytes: entry.byteLength
+	});
+	const lookaheadBytes = Math.min(entry.byteLength - input.offset, input.maxBytes + 3);
+	const { bytes, lastPage } = await readBytes(input.repository, path, input.offset, lookaheadBytes, input.signal);
+	if (lastPage.totalBytes !== entry.byteLength || (bytes[0] & 192) === 128) return invalidArgument$2();
+	const [content, consumedBytes] = decodeSafePrefix(bytes, Math.min(input.maxBytes, bytes.byteLength));
+	const byteEnd = input.offset + consumedBytes;
+	const isComplete = byteEnd === entry.byteLength;
+	return freezeRecursively({
+		byteEnd,
+		byteStart: input.offset,
+		content,
+		contentIdentity: entry.contentIdentity,
+		isComplete,
+		nextOffset: isComplete ? null : byteEnd,
+		path,
+		source: input.repository.snapshot,
+		totalBytes: entry.byteLength
+	});
+};
+//#endregion
+//#region src/decision-validation/index.ts
+var DECISION_STATUSES = /* @__PURE__ */ new Set([
+	"accepted",
+	"proposed",
+	"rejected",
+	"superseded"
+]);
+var DECISION_ID_PATTERN = /^\d{13}$/u;
+var CREATED_AT_PATTERN = /^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d\.\d{3}Z$/u;
+var getEntity = (decisionId) => {
+	return decisionId === null ? null : { decisionId };
+};
+var addInvalidFrontmatter = (context, range, reason, pointer = null) => {
+	context.diagnostics.add({
+		code: "MOLDEA_DECISION_FRONTMATTER_INVALID",
+		details: { reason },
+		entity: getEntity(context.decisionId),
+		path: context.path,
+		pointer,
+		range
+	});
+};
+var isCanonicalCreatedAt = (value) => {
+	if (!CREATED_AT_PATTERN.test(value)) return false;
+	const timestamp = Date.parse(value);
+	return Number.isFinite(timestamp) && new Date(timestamp).toISOString() === value;
+};
+var readMapping = (node, context) => {
+	if (node.kind !== "mapping") {
+		addInvalidFrontmatter(context, node.range, "mapping-required");
+		return null;
+	}
+	const entries = /* @__PURE__ */ new Map();
+	for (const entry of node.entries) {
+		if (entry.key.kind !== "scalar" || typeof entry.key.value !== "string") {
+			addInvalidFrontmatter(context, entry.key.range, "string-key-required");
+			continue;
+		}
+		const key = entry.key.value;
+		if (key !== "status" && key !== "createdAt" && key !== "supersedes") {
+			context.diagnostics.add({
+				code: "MOLDEA_DECISION_PROPERTY_UNKNOWN",
+				entity: getEntity(context.decisionId),
+				path: context.path,
+				pointer: `/${escapeJsonPointerSegment(key)}`,
+				range: entry.key.range
+			});
+			continue;
+		}
+		entries.set(key, entry.value);
+	}
+	return entries;
+};
+var readStatus = (node, context) => {
+	if (node?.kind !== "scalar" || typeof node.value !== "string" || !DECISION_STATUSES.has(node.value)) {
+		context.diagnostics.add({
+			code: "MOLDEA_DECISION_STATUS_INVALID",
+			entity: getEntity(context.decisionId),
+			path: context.path,
+			pointer: "/status",
+			range: node?.range ?? null
+		});
+		return null;
+	}
+	return node.value;
+};
+var readCreatedAt = (node, context) => {
+	if (node?.kind !== "scalar" || typeof node.value !== "string" || !isCanonicalCreatedAt(node.value)) {
+		context.diagnostics.add({
+			code: "MOLDEA_DECISION_CREATED_AT_INVALID",
+			entity: getEntity(context.decisionId),
+			path: context.path,
+			pointer: "/createdAt",
+			range: node?.range ?? null
+		});
+		return null;
+	}
+	if (context.decisionId !== null && Date.parse(node.value) !== Number(context.decisionId)) context.diagnostics.add({
+		code: "MOLDEA_DECISION_TIMESTAMP_MISMATCH",
+		entity: getEntity(context.decisionId),
+		path: context.path,
+		pointer: "/createdAt",
+		range: node.range
+	});
+	return node.value;
+};
+var readSupersedes = (node, context) => {
+	if (node === void 0) return [];
+	if (node.kind !== "sequence" || node.items.length === 0) {
+		addInvalidFrontmatter(context, node.range, "non-empty-supersedes-sequence-required", "/supersedes");
+		return null;
+	}
+	const supersedes = [];
+	const seen = /* @__PURE__ */ new Set();
+	node.items.forEach((item, index) => {
+		const pointer = `/supersedes/${index}`;
+		if (item.kind !== "scalar" || typeof item.value !== "string" || !DECISION_ID_PATTERN.test(item.value)) {
+			addInvalidFrontmatter(context, item.range, "decision-id-string-required", pointer);
+			return;
+		}
+		if (seen.has(item.value)) {
+			context.diagnostics.add({
+				code: "MOLDEA_ID_DUPLICATE",
+				entity: getEntity(context.decisionId),
+				path: context.path,
+				pointer,
+				range: item.range
+			});
+			return;
+		}
+		seen.add(item.value);
+		supersedes.push(item.value);
+		if (item.value === context.decisionId) context.diagnostics.add({
+			code: "MOLDEA_DECISION_SELF_SUPERSESSION",
+			entity: getEntity(context.decisionId),
+			path: context.path,
+			pointer,
+			range: item.range
+		});
+	});
+	return supersedes.sort(compareExactStrings);
+};
+/**
+* Locates exact decision frontmatter delimiters and preserves the complete Markdown body.
+* @param value The complete normalized decision document.
+* @param locator The full-document scalar-aware source locator.
+* @param context The decision diagnostic context.
+* @returns The YAML prefix and exact body, or `null` when delimiters are unavailable.
+*/
+var extractDecisionSections = (value, locator, context) => {
+	const firstLineEnd = value.indexOf("\n");
+	const openingLineEnd = firstLineEnd === -1 ? value.length : firstLineEnd;
+	if (value.slice(0, openingLineEnd) !== "---") {
+		context.diagnostics.add({
+			code: "MOLDEA_DECISION_FRONTMATTER_MISSING",
+			entity: getEntity(context.decisionId),
+			path: context.path,
+			range: locator.locateRange(0, openingLineEnd)
+		});
+		return null;
+	}
+	let lineStart = firstLineEnd === -1 ? value.length : firstLineEnd + 1;
+	while (lineStart <= value.length) {
+		const nextLineBreak = value.indexOf("\n", lineStart);
+		const lineEnd = nextLineBreak === -1 ? value.length : nextLineBreak;
+		if (value.slice(lineStart, lineEnd) === "---") {
+			const bodyStart = nextLineBreak === -1 ? lineEnd : nextLineBreak + 1;
+			return {
+				body: value.slice(bodyStart),
+				bodyRange: locator.locateRange(bodyStart, value.length),
+				yaml: value.slice(0, lineStart)
+			};
+		}
+		if (nextLineBreak === -1) break;
+		lineStart = nextLineBreak + 1;
+	}
+	context.diagnostics.add({
+		code: "MOLDEA_DECISION_FRONTMATTER_MISSING",
+		entity: getEntity(context.decisionId),
+		path: context.path,
+		range: locator.locateRange(value.length, value.length)
+	});
+	return null;
+};
+/**
+* Validates one parsed decision-frontmatter mapping without resolving other files.
+* @param node The strict parser-neutral YAML root.
+* @param context The decision diagnostic context.
+* @returns Canonical decision metadata when every document-level rule is valid.
+*/
+var validateDecisionFrontmatter = (node, context) => {
+	const initialDiagnosticCount = context.diagnostics.size;
+	const entries = readMapping(node, context);
+	if (entries === null) return null;
+	const status = readStatus(entries.get("status"), context);
+	const createdAt = readCreatedAt(entries.get("createdAt"), context);
+	const supersedes = readSupersedes(entries.get("supersedes"), context);
+	if (status === null || createdAt === null || supersedes === null || context.diagnostics.size > initialDiagnosticCount) return null;
+	return {
+		createdAt,
+		status,
+		supersedes
+	};
+};
+/** Adds the decision-body diagnostic when the preserved Markdown has no content. */
+var validateDecisionBody = (body, range, context) => {
+	if (hasNonWhitespace(body)) return true;
+	context.diagnostics.add({
+		code: "MOLDEA_DECISION_BODY_EMPTY",
+		entity: getEntity(context.decisionId),
+		path: context.path,
+		range
+	});
+	return false;
+};
+//#endregion
+//#region src/decision/index.ts
+/**
+* Parses and validates one complete decision document without resolving cross-file relationships.
+* @param input The canonical logical path and exact decision text or bytes.
+* @param options The immutable Core limit snapshot.
+* @param operation The owning public or repository-level operation for typed failures.
+* @returns A frozen all-or-nothing decision parse result.
+* @throws
+* - INVALID_REPOSITORY_PATH: The repository path is invalid.
+* - INVALID_ARGUMENT: The Core operation received an invalid argument.
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+*/
+var parseDecisionDocument = async (input, options, operation = "parse-decision") => {
+	options = createCoreOperationOptionsSnapshot(options);
+	const normalized = normalizeTextDocument(input, options.limits, operation);
+	const path = parseRepositoryPath(input.path);
+	const diagnostics = createCoreDiagnosticCollector(options.limits, operation);
+	const decisionId = parseDecisionIdFromPath(path);
+	if (decisionId === null) diagnostics.add({
+		code: "MOLDEA_DECISION_FILENAME_INVALID",
+		path
+	});
+	for (const diagnostic of normalized.diagnostics) diagnostics.merge(diagnostic);
+	if (!normalized.valid || normalized.text === null) return freezeRecursively({
+		decision: null,
+		diagnostics: diagnostics.finalize(),
+		valid: false
+	});
+	const context = {
+		decisionId,
+		diagnostics,
+		path
+	};
+	const locator = createSourceLocator(normalized.text.value);
+	const sections = extractDecisionSections(normalized.text.value, locator, context);
+	let metadata = null;
+	if (sections !== null) {
+		validateDecisionBody(sections.body, sections.bodyRange, context);
+		const parsed = parseStrictYaml(sections.yaml, path, locator, diagnostics);
+		if (parsed.valid && parsed.value !== null) metadata = validateDecisionFrontmatter(parsed.value, context);
+	}
+	if (decisionId === null || sections === null || metadata === null || diagnostics.size > 0) return freezeRecursively({
+		decision: null,
+		diagnostics: diagnostics.finalize(),
+		valid: false
+	});
+	const digest = await calculateNormalizedTextDigest(normalized.text);
+	const asset = {
+		content: normalized.text.value,
+		digest,
+		path,
+		scalarLength: normalized.text.scalarLength,
+		utf8ByteLength: normalized.text.utf8ByteLength
+	};
+	return freezeRecursively({
+		decision: {
+			asset,
+			body: sections.body,
+			createdAt: metadata.createdAt,
+			id: decisionId,
+			path,
+			status: metadata.status,
+			supersedes: metadata.supersedes
+		},
+		diagnostics: diagnostics.finalize(),
+		valid: true
+	});
+};
+//#endregion
+//#region src/project-agent-assignments/index.ts
+/** Iterates content-free agent-to-runtime assignments without retaining an intermediate array. */
+var iterateProjectAgentAssignments = function* (project) {
+	for (const agent of project.agents) yield {
+		agentId: agent.id,
+		runtimeId: agent.declaration.runtime.id
+	};
+};
+//#endregion
+//#region src/project-metadata/index.ts
+var createAssetItem = (asset, kind, agentId = null, decisionId = null) => ({
+	agentId,
+	byteLength: asset.utf8ByteLength,
+	canonicalDigest: null,
+	decisionId,
+	digest: asset.digest,
+	kind,
+	path: asset.path,
+	scalarLength: asset.scalarLength
+});
+/** Iterates content-free asset metadata without retaining a second project-sized collection. */
+var iterateProjectMetadata = function* (project) {
+	yield createAssetItem(project.manifest.asset, "manifest");
+	yield createAssetItem(project.project, "project");
+	for (const context of project.context) yield createAssetItem(context.asset, "context");
+	for (const { decision } of project.decisions) yield createAssetItem(decision.asset, "decision", null, decision.id);
+	for (const runtime of project.runtimes) yield createAssetItem(runtime.asset, "runtime-guidance");
+	for (const agent of project.agents) {
+		yield createAssetItem(agent.description.asset, "agent-description", agent.id);
+		yield createAssetItem(agent.instruction, "agent-instruction", agent.id);
+		if (agent.handoffDescription !== null) yield createAssetItem(agent.handoffDescription.asset, "agent-handoff-description", agent.id);
+		for (const mirror of agent.mirrors) yield {
+			agentId: agent.id,
+			byteLength: mirror.byteLength,
+			canonicalDigest: mirror.canonicalDigest,
+			decisionId: null,
+			digest: mirror.digest,
+			kind: "mirror",
+			path: mirror.path,
+			scalarLength: mirror.scalarLength
+		};
+	}
+};
+/** Creates the content-free summary for one validated project snapshot. */
+var createProjectSummary = (project) => ({
+	counts: {
+		agents: project.agents.length,
+		context: project.context.length,
+		decisions: project.decisions.length,
+		mirrors: project.agents.reduce((count, agent) => count + agent.mirrors.length, 0),
+		runtimes: project.runtimes.length,
+		unresolved: project.agents.reduce((count, agent) => count + Object.keys(agent.declaration.unresolved ?? {}).length, Object.keys(project.unresolved).length)
+	},
+	manifestDigest: project.manifest.asset.digest,
+	manifestPath: project.manifest.asset.path,
+	projectDigest: project.project.digest,
+	projectPath: project.project.path
+});
+//#endregion
+//#region src/binding-coverage/index.ts
+/** Counts every declared, existing binding by its actual export-check outcome. */
+var countBindingCoverage = (coverage) => ({
+	bindings: coverage.length,
+	exportsPassed: coverage.filter((record) => record.exportCheck === "passed").length,
+	exportsFailed: coverage.filter((record) => record.exportCheck === "failed").length,
+	exportsNotChecked: coverage.filter((record) => record.exportCheck === "not-checked").length
+});
+//#endregion
+//#region src/retained-memory/index.ts
+var ledgers = /* @__PURE__ */ new WeakMap();
+/** Registers the sole memory owner for one internal reader. */
+var registerRetainedMemory = (reader, ledger) => {
+	if (ledgers.has(reader)) throw new TypeError("The inspection reader is already registered.");
+	ledgers.set(reader, ledger);
+};
+/** Returns the ledger shared by all phases of a repository inspection. */
+var getRetainedMemory = (reader) => {
+	const ledger = ledgers.get(reader);
+	if (ledger === void 0) throw new TypeError("The inspection reader has no retained-memory ledger.");
+	return ledger;
+};
+/** Reserves retained coverage in production sessions and leaves standalone file-check readers untracked. */
+var reserveRetainedBytesIfTracked = (reader, bytes) => {
+	ledgers.get(reader)?.reserve(bytes);
+};
+//#endregion
+//#region src/repository-inspection-session/index.ts
+var MANIFEST_PATH$3 = parseRepositoryPath("/moldea/moldea.yaml");
+var SOURCE_PAGE_ENTRIES = 256;
+var SOURCE_PAGE_BYTES = 65536;
+var CANONICAL_BYTE_RETENTION_MULTIPLIER = 4;
+var RETAINED_PATH_FIXED_BYTES = 64;
+var RETAINED_PATH_BYTE_MULTIPLIER = 2;
+var encoder$1 = new TextEncoder();
+var invalidSourceData$3 = (operation, path) => {
+	throw new RepositorySourceException({
+		code: "INVALID_SOURCE_DATA",
+		operation,
+		path,
+		retryable: false
+	});
+};
+var copyReaderEntry$1 = (candidate, operation, fallbackPath, expectedPath) => {
+	if (typeof candidate !== "object" || candidate === null) return invalidSourceData$3(operation, fallbackPath);
+	const record = candidate;
+	const pathCandidate = record["path"];
+	const typeCandidate = record["type"];
+	const byteLength = record["byteLength"];
+	const contentIdentity = record["contentIdentity"];
+	if (typeof pathCandidate !== "string" || !isRepositoryPath(pathCandidate)) return invalidSourceData$3(operation, fallbackPath);
+	const path = parseRepositoryPath(pathCandidate);
+	if (expectedPath !== void 0 && path !== expectedPath) return invalidSourceData$3(operation, path);
+	if (typeCandidate !== "file" && typeCandidate !== "directory" && typeCandidate !== "symlink") return invalidSourceData$3(operation, path);
+	if (typeCandidate === "file" ? !Number.isSafeInteger(byteLength) || byteLength < 0 || contentIdentity !== null && typeof contentIdentity !== "string" : byteLength !== null || contentIdentity !== null) return invalidSourceData$3(operation, path);
+	return {
+		byteLength,
+		contentIdentity,
+		path,
+		type: typeCandidate
+	};
+};
+var isStrictDescendant = (path, prefix) => {
+	if (path === prefix) return false;
+	const descendantPrefix = prefix === REPOSITORY_ROOT ? REPOSITORY_ROOT : `${prefix}/`;
+	return path.startsWith(descendantPrefix);
+};
+var throwResourceLimitExceeded = (limit, limitMaximum, observedUsage) => {
+	throw new CoreOperationException({
+		code: "RESOURCE_LIMIT_EXCEEDED",
+		limit,
+		limitMaximum,
+		nextAction: "reduce-input-or-increase-limit",
+		observedUsage,
+		operation: "validate-project"
+	});
+};
+var createSourceOptions = (sessionSignal, operationSignal) => {
+	const signal = sessionSignal === void 0 ? operationSignal : operationSignal === void 0 || operationSignal === sessionSignal ? sessionSignal : AbortSignal.any([sessionSignal, operationSignal]);
+	return signal === void 0 ? void 0 : { signal };
+};
+/**
+* Creates the isolated reader state for one repository inspection.
+* @param repository The source-neutral reader bound to one coherent snapshot.
+* @param limits The immutable resource limits for the inspection.
+* @param signal Optional cancellation shared by every inspection operation.
+* @returns A session that pages source metadata and range-reads bounded canonical files.
+* @throws
+* - ABORTED: The Core operation was aborted.
+*/
+var createRepositoryInspectionSession = (repository, limits, signal) => {
+	const seenPaths = /* @__PURE__ */ new Set();
+	let canonicalBytes = 0;
+	let peakRetainedBytes = 0;
+	let retainedBytes = 0;
+	let totalBytesRead = 0;
+	const createAbortedException = (abortedSignal) => {
+		return new CoreOperationException({
+			cause: abortedSignal.reason,
+			code: "ABORTED",
+			operation: "validate-project"
+		});
+	};
+	const reserveRetainedBytes = (byteLength) => {
+		if (!Number.isSafeInteger(byteLength) || byteLength < 0 || byteLength > limits.maxRetainedBytes - retainedBytes) return throwResourceLimitExceeded("maxRetainedBytes", limits.maxRetainedBytes, retainedBytes + byteLength);
+		retainedBytes += byteLength;
+		peakRetainedBytes = Math.max(peakRetainedBytes, retainedBytes);
+	};
+	const observeTransientBytes = (byteLength) => {
+		if (!Number.isSafeInteger(byteLength) || byteLength < 0 || byteLength > limits.maxRetainedBytes - retainedBytes) return throwResourceLimitExceeded("maxRetainedBytes", limits.maxRetainedBytes, retainedBytes + byteLength);
+		peakRetainedBytes = Math.max(peakRetainedBytes, retainedBytes + byteLength);
+	};
+	const registerPath = (path) => {
+		if (path === REPOSITORY_ROOT || seenPaths.has(path)) return;
+		if (seenPaths.size >= limits.maxEntries) return throwResourceLimitExceeded("maxEntries", limits.maxEntries, seenPaths.size + 1);
+		reserveRetainedBytes(RETAINED_PATH_FIXED_BYTES + encoder$1.encode(path).byteLength * RETAINED_PATH_BYTE_MULTIPLIER);
+		seenPaths.add(path);
+	};
+	const throwIfSignalAborted = (operationSignal) => {
+		const abortedSignal = signal?.aborted ? signal : operationSignal?.aborted ? operationSignal : null;
+		if (abortedSignal !== null) throw createAbortedException(abortedSignal);
+	};
+	throwIfSignalAborted();
+	const reserveReadBytes = (byteLength) => {
+		if (byteLength > limits.maxTotalBytesRead - totalBytesRead) return throwResourceLimitExceeded("maxTotalBytesRead", limits.maxTotalBytesRead, totalBytesRead + byteLength);
+		totalBytesRead += byteLength;
+	};
+	const getEntry = async (path, options) => {
+		const parsedPath = parseRepositoryPath(path);
+		throwIfSignalAborted(options?.signal);
+		registerPath(parsedPath);
+		const candidate = await repository.getEntry(parsedPath, createSourceOptions(signal, options?.signal));
+		throwIfSignalAborted(options?.signal);
+		return candidate === null ? null : copyReaderEntry$1(candidate, "get-entry", parsedPath, parsedPath);
+	};
+	const iterateEntries = (options) => {
+		const prefix = options?.prefix === void 0 ? REPOSITORY_ROOT : parseRepositoryPath(options.prefix);
+		return { async *[Symbol.asyncIterator]() {
+			registerPath(prefix);
+			const yieldedPaths = /* @__PURE__ */ new Set();
+			let cursor;
+			let previousPath = null;
+			do {
+				throwIfSignalAborted(options?.signal);
+				const page = await repository.listEntriesPage({
+					...cursor === void 0 ? {} : { cursor },
+					maxEntries: Math.min(SOURCE_PAGE_ENTRIES, limits.maxEntries),
+					prefix,
+					...createSourceOptions(signal, options?.signal) ?? {}
+				});
+				if (page.snapshot.id !== repository.snapshot.id || page.entries.length === 0 && !page.isComplete) return invalidSourceData$3("list-entries-page", prefix);
+				for (const candidate of page.entries) {
+					throwIfSignalAborted(options?.signal);
+					const entry = copyReaderEntry$1(candidate, "list-entries-page", prefix);
+					if (!isStrictDescendant(entry.path, prefix) || yieldedPaths.has(entry.path) || previousPath !== null && compareRepositoryPaths(previousPath, entry.path) >= 0) return invalidSourceData$3("list-entries-page", entry.path);
+					yieldedPaths.add(entry.path);
+					previousPath = entry.path;
+					registerPath(entry.path);
+					yield entry;
+				}
+				if (page.isComplete) {
+					if (page.nextCursor !== null) return invalidSourceData$3("list-entries-page", prefix);
+					return;
+				}
+				if (page.nextCursor === null || page.nextCursor === cursor) return invalidSourceData$3("list-entries-page", prefix);
+				cursor = page.nextCursor;
+			} while (true);
+		} };
+	};
+	const loadFile = async (path, operationSignal, isSource = false) => {
+		const multiplier = isSource ? 1 : CANONICAL_BYTE_RETENTION_MULTIPLIER;
+		const fileLimit = path === MANIFEST_PATH$3 ? "maxManifestBytes" : "maxFileBytes";
+		const availableRetainedBytes = limits.maxRetainedBytes - retainedBytes;
+		if (availableRetainedBytes < 1) return throwResourceLimitExceeded("maxRetainedBytes", limits.maxRetainedBytes, retainedBytes + 1);
+		const firstPageMaximumBytes = Math.min(SOURCE_PAGE_BYTES, Math.max(1, limits[fileLimit]), availableRetainedBytes);
+		observeTransientBytes(firstPageMaximumBytes);
+		const firstPage = await repository.readFilePage(path, {
+			maxBytes: firstPageMaximumBytes,
+			offset: 0,
+			...createSourceOptions(signal, operationSignal) ?? {}
+		});
+		throwIfSignalAborted(operationSignal);
+		if (firstPage.snapshot.id !== repository.snapshot.id || firstPage.offset !== 0 || !(firstPage.bytes instanceof Uint8Array) || !Number.isSafeInteger(firstPage.totalBytes) || firstPage.totalBytes < 0 || firstPage.bytes.byteLength > SOURCE_PAGE_BYTES || firstPage.bytes.byteLength > firstPage.totalBytes || firstPage.bytes.byteLength === 0 && !firstPage.isComplete) return invalidSourceData$3("read-file-page", path);
+		if (firstPage.totalBytes > limits[fileLimit]) return throwResourceLimitExceeded(fileLimit, limits[fileLimit], firstPage.totalBytes);
+		const firstPageBytes = firstPage.bytes.byteLength;
+		const retainedBytesAvailableForCanonicalContent = limits.maxRetainedBytes - retainedBytes - firstPageBytes;
+		if (retainedBytesAvailableForCanonicalContent < 0 || firstPage.totalBytes > Math.floor(retainedBytesAvailableForCanonicalContent / multiplier)) {
+			const projectedUsage = retainedBytes + firstPageBytes + firstPage.totalBytes * multiplier;
+			return throwResourceLimitExceeded("maxRetainedBytes", limits.maxRetainedBytes, Number.isSafeInteger(projectedUsage) ? projectedUsage : Number.MAX_SAFE_INTEGER);
+		}
+		reserveReadBytes(firstPage.totalBytes);
+		const canonicalRetainedBytes = firstPage.totalBytes * multiplier;
+		observeTransientBytes(canonicalRetainedBytes + firstPageBytes);
+		reserveRetainedBytes(canonicalRetainedBytes);
+		if (!isSource) canonicalBytes += firstPage.totalBytes;
+		const content = new Uint8Array(firstPage.totalBytes);
+		let offset = 0;
+		let page = firstPage;
+		let isFirstPage = true;
+		while (isFirstPage || offset < content.byteLength) {
+			isFirstPage = false;
+			if (page.snapshot.id !== repository.snapshot.id || page.offset !== offset || page.totalBytes !== content.byteLength || !(page.bytes instanceof Uint8Array) || page.bytes.byteLength > SOURCE_PAGE_BYTES || page.bytes.byteLength > content.byteLength - offset || page.bytes.byteLength === 0 && !page.isComplete) return invalidSourceData$3("read-file-page", path);
+			content.set(page.bytes, offset);
+			offset += page.bytes.byteLength;
+			if (page.isComplete) {
+				if (page.nextOffset !== null || offset !== content.byteLength) return invalidSourceData$3("read-file-page", path);
+				break;
+			}
+			if (page.nextOffset !== offset) return invalidSourceData$3("read-file-page", path);
+			page = await repository.readFilePage(path, {
+				maxBytes: Math.min(SOURCE_PAGE_BYTES, Math.max(1, content.byteLength - offset)),
+				offset,
+				...createSourceOptions(signal, operationSignal) ?? {}
+			});
+			throwIfSignalAborted(operationSignal);
+		}
+		return content;
+	};
+	const awaitWithCancellation = async (promise, operationSignal) => {
+		const callerSignal = createSourceOptions(signal, operationSignal)?.signal;
+		if (callerSignal === void 0) return promise;
+		return new Promise((resolve, reject) => {
+			const cleanup = () => callerSignal.removeEventListener("abort", abort);
+			const abort = () => {
+				cleanup();
+				reject(createAbortedException(callerSignal));
+			};
+			if (callerSignal.aborted) abort();
+			else callerSignal.addEventListener("abort", abort, { once: true });
+			promise.then((result) => {
+				cleanup();
+				resolve(result);
+			}, (error) => {
+				cleanup();
+				reject(error instanceof Error ? error : new RepositorySourceException({
+					cause: error,
+					code: "INVALID_SOURCE_DATA",
+					operation: "read-file-page",
+					path: null,
+					retryable: false
+				}));
+			});
+		});
+	};
+	const readCompleteFile = async (path, options) => {
+		const parsedPath = parseRepositoryPath(path);
+		throwIfSignalAborted(options?.signal);
+		registerPath(parsedPath);
+		const content = await awaitWithCancellation(loadFile(parsedPath, options?.signal), options?.signal);
+		throwIfSignalAborted(options?.signal);
+		return content.slice();
+	};
+	const reader = Object.freeze({
+		getEntry,
+		iterateEntries,
+		readCompleteFile
+	});
+	registerRetainedMemory(reader, {
+		reserve: reserveRetainedBytes,
+		tryReserve: (bytes) => {
+			if (!Number.isSafeInteger(bytes) || bytes < 0 || bytes > limits.maxRetainedBytes - retainedBytes) return false;
+			reserveRetainedBytes(bytes);
+			return true;
+		},
+		release: (bytes) => {
+			if (!Number.isSafeInteger(bytes) || bytes < 0 || bytes > retainedBytes) throw new TypeError("The retained-memory release is invalid.");
+			retainedBytes -= bytes;
+		},
+		readSourceFile: async (path) => {
+			throwIfSignalAborted();
+			registerPath(path);
+			const bytes = await awaitWithCancellation(loadFile(path, void 0, true));
+			throwIfSignalAborted();
+			let isReleased = false;
+			return {
+				bytes,
+				release: () => {
+					if (!isReleased) retainedBytes -= bytes.byteLength;
+					isReleased = true;
+				}
+			};
+		}
+	});
+	return Object.freeze({
+		getResourceUsage: () => Object.freeze({
+			canonicalBytes,
+			peakRetainedBytes,
+			retainedBytes,
+			totalBytesRead
+		}),
+		reader,
+		throwIfAborted: throwIfSignalAborted
+	});
+};
+//#endregion
+//#region src/agent-asset-validation/index.ts
+var OPENING_HEADING_PATTERN = /^#{1,6} /u;
+/** Finds the first nonblank line at or after one normalized line index. */
+var findNonblankLine = (lines, startIndex) => {
+	for (let index = startIndex; index < lines.length; index += 1) {
+		const line = lines[index];
+		if (line !== void 0 && hasNonWhitespace(line)) return index;
+	}
+	return null;
+};
+/**
+* Validates the effective value of one agent description asset.
+* @param asset The normalized complete description or handoff-description asset.
+* @param agentId The owning registered agent ID.
+* @param kind The description role determining its diagnostic code.
+* @param limits The Core diagnostic budget.
+* @returns The frozen effective description when every version 1 rule passes.
+* @throws
+* - RESOURCE_LIMIT_EXCEEDED: The repository-level diagnostic budget was exceeded.
+*/
+var validateAgentDescription = (asset, agentId, kind, limits) => {
+	const diagnostics = createCoreDiagnosticCollector(limits, "validate-project");
+	const value = trimRepositoryFormatWhitespace(asset.content);
+	const scalarLength = countUnicodeScalars(value);
+	const code = kind === "description" ? "MOLDEA_AGENT_DESCRIPTION_INVALID" : "MOLDEA_AGENT_HANDOFF_DESCRIPTION_INVALID";
+	if (scalarLength === 0) diagnostics.add({
+		code,
+		details: { reason: "empty" },
+		entity: { agentId },
+		path: asset.path
+	});
+	if (scalarLength > 1e3) diagnostics.add({
+		code,
+		details: { reason: "too-long" },
+		entity: { agentId },
+		path: asset.path
+	});
+	if (value.includes("{{") || value.includes("}}")) diagnostics.add({
+		code,
+		details: { reason: "runtime-variable-delimiter" },
+		entity: { agentId },
+		path: asset.path
+	});
+	const finalizedDiagnostics = diagnostics.finalize();
+	return freezeRecursively({
+		description: finalizedDiagnostics.length === 0 ? {
+			asset,
+			scalarLength,
+			value
+		} : null,
+		diagnostics: finalizedDiagnostics,
+		valid: finalizedDiagnostics.length === 0
+	});
+};
+/**
+* Validates one canonical instruction's non-empty content and opening identity.
+* @param asset The normalized complete instruction asset.
+* @param agentId The owning registered agent ID.
+* @param limits The Core diagnostic budget.
+* @returns The frozen instruction result, retaining non-empty content for later validation.
+* @throws
+* - RESOURCE_LIMIT_EXCEEDED: The repository-level diagnostic budget was exceeded.
+*/
+var validateAgentInstruction = (asset, agentId, limits) => {
+	const diagnostics = createCoreDiagnosticCollector(limits, "validate-project");
+	if (!hasNonWhitespace(asset.content)) {
+		diagnostics.add({
+			code: "MOLDEA_AGENT_INSTRUCTION_EMPTY",
+			entity: { agentId },
+			path: asset.path
+		});
+		return freezeRecursively({
+			diagnostics: diagnostics.finalize(),
+			instruction: null,
+			valid: false
+		});
+	}
+	const identityToken = `\`${agentId}\``;
+	const lines = asset.content.split("\n");
+	const openingIndex = findNonblankLine(lines, 0);
+	let identityIndex = openingIndex;
+	if (openingIndex !== null && OPENING_HEADING_PATTERN.test(lines[openingIndex] ?? "")) identityIndex = findNonblankLine(lines, openingIndex + 1);
+	if (identityIndex === null || !(lines[identityIndex] ?? "").includes(identityToken)) diagnostics.add({
+		code: "MOLDEA_AGENT_IDENTITY_INVALID",
+		details: { reason: asset.content.includes(identityToken) ? "misplaced" : "missing" },
+		entity: { agentId },
+		path: asset.path
+	});
+	const finalizedDiagnostics = diagnostics.finalize();
+	return freezeRecursively({
+		diagnostics: finalizedDiagnostics,
+		instruction: asset,
+		valid: finalizedDiagnostics.length === 0
+	});
+};
+//#endregion
+//#region src/repository-text/index.ts
+var invalidSourceData$2 = (path) => {
+	throw new RepositorySourceException({
+		code: "INVALID_SOURCE_DATA",
+		operation: "read-file-page",
+		path,
+		retryable: false
+	});
+};
+/**
+* Reads and normalizes one canonical Markdown asset through a repository reader.
+* @param repository The coherent source-neutral repository reader.
+* @param path The discovered regular-file path to read exactly once.
+* @param limits The Core limits applied to the source bytes and diagnostics.
+* @param signal Optional cancellation forwarded to the repository read.
+* @returns A deeply immutable indexed asset or its deterministic text diagnostics.
+* @throws
+* - ENTRY_NOT_FOUND: The discovered file disappeared from the reader snapshot.
+* - ENTRY_NOT_FILE: The discovered entry is no longer a regular file.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during the read.
+* - INVALID_SOURCE_DATA: The repository reader returned invalid contract data.
+* - RESOURCE_LIMIT_EXCEEDED: A Core or repository resource limit was exceeded.
+* - ABORTED: Repository inspection or the repository read was aborted.
+*/
+var readRepositoryTextAsset = async (repository, path, limits, signal) => {
+	const content = await repository.readCompleteFile(path, signal === void 0 ? void 0 : { signal });
+	if (!(content instanceof Uint8Array)) return invalidSourceData$2(path);
+	const normalized = normalizeTextDocument({
+		content,
+		path
+	}, limits, "validate-project");
+	if (!normalized.valid || normalized.text === null) return freezeRecursively({
+		asset: null,
+		diagnostics: normalized.diagnostics,
+		valid: false
+	});
+	const asset = {
+		content: normalized.text.value,
+		digest: await calculateNormalizedTextDigest(normalized.text),
+		path,
+		scalarLength: normalized.text.scalarLength,
+		utf8ByteLength: normalized.text.utf8ByteLength
+	};
+	return freezeRecursively({
+		asset,
+		diagnostics: [],
+		valid: true
+	});
+};
+//#endregion
+//#region src/runtime-placeholder-validation/index.ts
+var readBraceRunEnd = (content, startOffset, brace) => {
+	let endOffset = startOffset + 1;
+	while (content[endOffset] === brace) endOffset += 1;
+	return endOffset;
+};
+/** Finds the end of the next closing-delimiter run without rescanning prior content. */
+var findClosingRunEnd = (content, startOffset) => {
+	let cursor = startOffset;
+	while (cursor < content.length) {
+		if (content[cursor] !== "}") {
+			cursor += 1;
+			continue;
+		}
+		const runEnd = readBraceRunEnd(content, cursor, "}");
+		if (runEnd - cursor >= 2) return runEnd;
+		cursor = runEnd;
+	}
+	return content.length;
+};
+/** Adds one malformed-placeholder diagnostic for an exact normalized source span. */
+var addMalformedDiagnostic = (collector, instruction, agentId, reason, range) => {
+	collector.add({
+		code: "MOLDEA_VARIABLE_PLACEHOLDER_MALFORMED",
+		details: { reason },
+		entity: { agentId },
+		path: instruction.path,
+		range
+	});
+};
+/** Records a valid placeholder occurrence and its first normalized source range. */
+var recordOccurrence = (occurrences, variableId, range) => {
+	const occurrence = occurrences.get(variableId);
+	if (occurrence === void 0) {
+		occurrences.set(variableId, {
+			count: 1,
+			firstRange: range
+		});
+		return;
+	}
+	occurrence.count += 1;
+};
+/**
+* Validates runtime-variable placeholders in one normalized canonical agent instruction.
+* @param manifestPath The canonical manifest path containing variable declarations.
+* @param agentId The owning agent ID.
+* @param instruction The normalized non-empty canonical instruction asset.
+* @param declaredVariables The owning agent's normalized variable declarations.
+* @param limits The resource limits applied to emitted diagnostics.
+* @returns Frozen deterministic placeholder diagnostics.
+* @throws
+* - RESOURCE_LIMIT_EXCEEDED: The repository-level diagnostic budget was exceeded.
+*/
+var validateRuntimePlaceholders = (manifestPath, agentId, instruction, declaredVariables, limits) => {
+	const collector = createCoreDiagnosticCollector(limits, "validate-project");
+	const locator = createSourceLocator(instruction.content);
+	const occurrences = /* @__PURE__ */ new Map();
+	let cursor = 0;
+	while (cursor < instruction.content.length) {
+		const character = instruction.content[cursor];
+		if (character === "}") {
+			const runEnd = readBraceRunEnd(instruction.content, cursor, "}");
+			const runLength = runEnd - cursor;
+			if (runLength >= 2) addMalformedDiagnostic(collector, instruction, agentId, runLength === 2 ? "unmatched-closing" : "invalid-closing-delimiter", locator.locateRange(cursor, runEnd));
+			cursor = runEnd;
+			continue;
+		}
+		if (character !== "{") {
+			cursor += 1;
+			continue;
+		}
+		const openingEnd = readBraceRunEnd(instruction.content, cursor, "{");
+		const openingLength = openingEnd - cursor;
+		if (openingLength === 1) {
+			cursor = openingEnd;
+			continue;
+		}
+		if (openingLength > 2) {
+			addMalformedDiagnostic(collector, instruction, agentId, "invalid-opening-delimiter", locator.locateRange(cursor, openingEnd));
+			cursor = openingEnd;
+			continue;
+		}
+		let candidateCursor = openingEnd;
+		let isCandidateComplete = false;
+		while (candidateCursor < instruction.content.length) {
+			const candidateCharacter = instruction.content[candidateCursor];
+			if (candidateCharacter === "{") {
+				const nestedOpeningEnd = readBraceRunEnd(instruction.content, candidateCursor, "{");
+				if (nestedOpeningEnd - candidateCursor >= 2) {
+					const malformedEnd = findClosingRunEnd(instruction.content, nestedOpeningEnd);
+					addMalformedDiagnostic(collector, instruction, agentId, "nested-opening", locator.locateRange(cursor, malformedEnd));
+					cursor = malformedEnd;
+					isCandidateComplete = true;
+					break;
+				}
+				candidateCursor = nestedOpeningEnd;
+				continue;
+			}
+			if (candidateCharacter !== "}") {
+				candidateCursor += 1;
+				continue;
+			}
+			const closingEnd = readBraceRunEnd(instruction.content, candidateCursor, "}");
+			const closingLength = closingEnd - candidateCursor;
+			if (closingLength === 1) {
+				candidateCursor = closingEnd;
+				continue;
+			}
+			if (closingLength > 2) {
+				addMalformedDiagnostic(collector, instruction, agentId, "invalid-closing-delimiter", locator.locateRange(cursor, closingEnd));
+				cursor = closingEnd;
+				isCandidateComplete = true;
+				break;
+			}
+			const variableId = instruction.content.slice(openingEnd, candidateCursor);
+			const placeholderRange = locator.locateRange(cursor, closingEnd);
+			if (isVariableId(variableId)) recordOccurrence(occurrences, variableId, placeholderRange);
+			else addMalformedDiagnostic(collector, instruction, agentId, "invalid-variable-id", placeholderRange);
+			cursor = closingEnd;
+			isCandidateComplete = true;
+			break;
+		}
+		if (!isCandidateComplete) {
+			addMalformedDiagnostic(collector, instruction, agentId, "unmatched-opening", locator.locateRange(cursor, instruction.content.length));
+			cursor = instruction.content.length;
+		}
+	}
+	for (const variableId of [...occurrences.keys()].sort(compareExactStrings)) {
+		if (declaredVariables[variableId] !== void 0) continue;
+		const occurrence = occurrences.get(variableId);
+		if (occurrence === void 0) continue;
+		collector.add({
+			code: "MOLDEA_VARIABLE_UNDECLARED",
+			details: { occurrences: occurrence.count },
+			entity: {
+				agentId,
+				variableId
+			},
+			path: instruction.path,
+			range: occurrence.firstRange
+		});
+	}
+	for (const variableId of Object.keys(declaredVariables).sort(compareExactStrings)) {
+		if (occurrences.has(variableId)) continue;
+		collector.add({
+			code: "MOLDEA_VARIABLE_UNUSED",
+			entity: {
+				agentId,
+				variableId
+			},
+			path: manifestPath,
+			pointer: `/agents/${escapeJsonPointerSegment(agentId)}/variables/${escapeJsonPointerSegment(variableId)}`
+		});
+	}
+	return collector.finalize();
+};
+//#endregion
+//#region src/agent-assets/index.ts
+var MANIFEST_PATH$2 = parseRepositoryPath("/moldea/moldea.yaml");
+var addDiagnostics$4 = (collector, diagnostics) => {
+	for (const diagnostic of diagnostics) collector.merge(diagnostic);
+};
+var isBlockedPath$2 = (path, blockedPaths) => {
+	let candidate = path;
+	while (candidate.length > 0) {
+		if (blockedPaths.has(candidate)) return true;
+		const separatorIndex = candidate.lastIndexOf("/");
+		if (separatorIndex <= 0) return false;
+		candidate = candidate.slice(0, separatorIndex);
+	}
+	return false;
+};
+/** Reads and validates a required or optional description asset. */
+var readDescription = async (repository, path, agentId, kind, options, collector, signal) => {
+	const readResult = await readRepositoryTextAsset(repository, path, options.limits, signal);
+	addDiagnostics$4(collector, readResult.diagnostics);
+	if (readResult.asset === null) return null;
+	const validation = validateAgentDescription(readResult.asset, agentId, kind, options.limits);
+	addDiagnostics$4(collector, validation.diagnostics);
+	return validation.description;
+};
+/** Reads and validates a mandatory instruction asset. */
+var readInstruction = async (repository, path, agentId, declaration, options, collector, signal) => {
+	const readResult = await readRepositoryTextAsset(repository, path, options.limits, signal);
+	addDiagnostics$4(collector, readResult.diagnostics);
+	if (readResult.asset === null) return null;
+	const validation = validateAgentInstruction(readResult.asset, agentId, options.limits);
+	addDiagnostics$4(collector, validation.diagnostics);
+	if (validation.instruction !== null) addDiagnostics$4(collector, validateRuntimePlaceholders(MANIFEST_PATH$2, agentId, validation.instruction, declaration.variables ?? {}, options.limits));
+	return validation.instruction;
+};
+/**
+* Reconciles registered agents with their convention-owned directories and Markdown assets.
+* @param repository The coherent source-neutral repository reader.
+* @param manifest The normalized manifest containing registered agents.
+* @param discovery The canonical inventory and path-owned structural diagnostics.
+* @param options The immutable Core configuration snapshot.
+* @param signal Optional cancellation forwarded to every repository read.
+* @returns Deeply immutable registered-agent assets and deterministic diagnostics.
+* @throws
+* - ENTRY_NOT_FOUND: A discovered agent asset disappeared from the reader snapshot.
+* - ENTRY_NOT_FILE: A discovered agent asset is no longer a regular file.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during agent reads.
+* - INVALID_SOURCE_DATA: The repository reader returned invalid contract data.
+* - RESOURCE_LIMIT_EXCEEDED: A Core or repository resource limit was exceeded.
+* - ABORTED: Agent inspection or a repository operation was aborted.
+*/
+var inspectAgentAssets = async (repository, manifest, discovery, options, signal) => {
+	options = createCoreOperationOptionsSnapshot(options);
+	const collector = createCoreDiagnosticCollector(options.limits, "validate-project");
+	const agents = [];
+	const registeredAgents = manifest.agents ?? {};
+	const registeredIds = new Set(Object.keys(registeredAgents));
+	const discoveredById = new Map(discovery.inventory.agents.map((agent) => [agent.id, agent]));
+	const blockedPaths = new Set(discovery.diagnostics.flatMap((diagnostic) => diagnostic.path === null ? [] : [diagnostic.path]));
+	for (const discovered of discovery.inventory.agents) if (!registeredIds.has(discovered.id)) collector.add({
+		code: "MOLDEA_AGENT_DIRECTORY_UNREGISTERED",
+		entity: { agentId: discovered.id },
+		path: discovered.path
+	});
+	for (const agentId of [...registeredIds].sort(compareExactStrings)) {
+		const declaration = registeredAgents[agentId];
+		if (declaration === void 0) continue;
+		const discovered = discoveredById.get(agentId);
+		if (discovered === void 0) {
+			const directoryPath = parseRepositoryPath(`/moldea/agents/${agentId}`);
+			if (!isBlockedPath$2(directoryPath, blockedPaths)) collector.add({
+				code: "MOLDEA_AGENT_DIRECTORY_MISSING",
+				entity: { agentId },
+				path: directoryPath
+			});
+			agents.push({
+				declaration,
+				description: null,
+				handoffDescription: null,
+				id: agentId,
+				instruction: null
+			});
+			continue;
+		}
+		let description = null;
+		let instruction = null;
+		let handoffDescription = null;
+		if (discovered.description === null) {
+			const path = parseRepositoryPath(`${discovered.path}/description.md`);
+			if (!isBlockedPath$2(path, blockedPaths)) collector.add({
+				code: "MOLDEA_AGENT_DESCRIPTION_MISSING",
+				entity: { agentId },
+				path
+			});
+		} else description = await readDescription(repository, discovered.description, agentId, "description", options, collector, signal);
+		if (discovered.instruction === null) {
+			const path = parseRepositoryPath(`${discovered.path}/instruction.md`);
+			if (!isBlockedPath$2(path, blockedPaths)) collector.add({
+				code: "MOLDEA_AGENT_INSTRUCTION_MISSING",
+				entity: { agentId },
+				path
+			});
+		} else instruction = await readInstruction(repository, discovered.instruction, agentId, declaration, options, collector, signal);
+		if (discovered.handoffDescription !== null) handoffDescription = await readDescription(repository, discovered.handoffDescription, agentId, "handoff-description", options, collector, signal);
+		agents.push({
+			declaration,
+			description,
+			handoffDescription,
+			id: agentId,
+			instruction
+		});
+	}
+	const diagnostics = collector.finalize();
+	return freezeRecursively({
+		agents,
+		diagnostics,
+		valid: diagnostics.length === 0
+	});
+};
+//#endregion
+//#region src/canonical-discovery-validation/index.ts
+var AGENT_ASSET_PATTERN = /^\/moldea\/agents\/([^/]+)\/(description|instruction|handoff-description)\.md$/u;
+var AGENT_DIRECTORY_PATTERN = /^\/moldea\/agents\/([^/]+)$/u;
+var DECISION_CANDIDATE_PATTERN = /^\/moldea\/decisions\/[^/]+\.md$/u;
+var readCanonicalFile = (path) => {
+	if (path === "/moldea/moldea.yaml") return {
+		agentId: null,
+		fileKind: "manifest",
+		kind: "canonical-file"
+	};
+	if (path === "/moldea/project.md") return {
+		agentId: null,
+		fileKind: "project",
+		kind: "canonical-file"
+	};
+	if (isContextPath(path, false)) return {
+		agentId: null,
+		fileKind: "context",
+		kind: "canonical-file"
+	};
+	if (DECISION_CANDIDATE_PATTERN.test(path)) return {
+		agentId: null,
+		fileKind: "decision",
+		kind: "canonical-file"
+	};
+	if (isRuntimeGuidancePath(path)) return {
+		agentId: null,
+		fileKind: "runtime-guidance",
+		kind: "canonical-file"
+	};
+	const agentAsset = AGENT_ASSET_PATTERN.exec(path);
+	if (agentAsset === null) return null;
+	const agentId = agentAsset[1];
+	const fileName = agentAsset[2];
+	if (agentId === void 0 || fileName === void 0) return null;
+	return {
+		agentId,
+		fileKind: fileName === "description" ? "agent-description" : fileName === "instruction" ? "agent-instruction" : "agent-handoff-description",
+		kind: "canonical-file"
+	};
+};
+var readAgentDirectoryId = (path) => {
+	return AGENT_DIRECTORY_PATTERN.exec(path)?.[1] ?? null;
+};
+var isRequiredDirectoryPath = (path) => {
+	return path === "/moldea" || path === "/moldea/context" || path === "/moldea/decisions" || path === "/moldea/runtimes" || path === "/moldea/agents";
+};
+var isPermittedStructuralDirectoryPath = (path) => {
+	return isRequiredDirectoryPath(path) || path.startsWith("/moldea/context/") || path.startsWith("/moldea/runtimes/");
+};
+/**
+* Classifies one reader entry against the version 1 canonical layout.
+* @param entry The detached entry beneath the canonical moldea root.
+* @returns Its canonical category or the precise structural failure category.
+*/
+var classifyCanonicalEntry = (entry) => {
+	const canonicalFile = readCanonicalFile(entry.path);
+	if (canonicalFile !== null) {
+		if (entry.type === "file") return canonicalFile;
+		return entry.type === "symlink" ? { kind: "canonical-asset-symlink" } : {
+			expectedType: "file",
+			kind: "entry-type-invalid"
+		};
+	}
+	const agentId = readAgentDirectoryId(entry.path);
+	if (agentId !== null) return entry.type === "directory" ? {
+		agentId,
+		kind: "agent-directory"
+	} : {
+		expectedType: "directory",
+		kind: "entry-type-invalid"
+	};
+	if (isRequiredDirectoryPath(entry.path)) return entry.type === "directory" ? { kind: "structural-directory" } : {
+		expectedType: "directory",
+		kind: "entry-type-invalid"
+	};
+	if (entry.type === "directory") return isPermittedStructuralDirectoryPath(entry.path) ? { kind: "structural-directory" } : { kind: "ignored-directory" };
+	return { kind: "unrecognized" };
+};
+//#endregion
+//#region src/canonical-discovery/index.ts
+var MOLDEA_ROOT$1 = parseRepositoryPath("/moldea");
+var MANIFEST_PATH$1 = parseRepositoryPath("/moldea/moldea.yaml");
+var PROJECT_PATH$1 = parseRepositoryPath("/moldea/project.md");
+var createWorkingInventory = () => ({
+	agents: /* @__PURE__ */ new Map(),
+	context: /* @__PURE__ */ new Set(),
+	decisions: /* @__PURE__ */ new Set(),
+	manifest: null,
+	project: null,
+	runtimeGuidance: /* @__PURE__ */ new Set()
+});
+var invalidSourceData$1 = (operation, path) => {
+	throw new RepositorySourceException({
+		code: "INVALID_SOURCE_DATA",
+		operation,
+		path,
+		retryable: false
+	});
+};
+var copyReaderEntry = (candidate, operation, expectedPath) => {
+	if (typeof candidate !== "object" || candidate === null) return invalidSourceData$1(operation, expectedPath ?? null);
+	const record = candidate;
+	const pathCandidate = record["path"];
+	const typeCandidate = record["type"];
+	const byteLength = record["byteLength"];
+	const contentIdentity = record["contentIdentity"];
+	if (typeof pathCandidate !== "string" || !isRepositoryPath(pathCandidate)) return invalidSourceData$1(operation, expectedPath ?? null);
+	const path = parseRepositoryPath(pathCandidate);
+	if (expectedPath !== void 0 && path !== expectedPath) return invalidSourceData$1(operation, path);
+	if (typeCandidate !== "file" && typeCandidate !== "directory" && typeCandidate !== "symlink") return invalidSourceData$1(operation, path);
+	if (typeCandidate === "file" ? !Number.isSafeInteger(byteLength) || byteLength < 0 || contentIdentity !== null && typeof contentIdentity !== "string" : byteLength !== null || contentIdentity !== null) return invalidSourceData$1(operation, path);
+	return {
+		byteLength,
+		contentIdentity,
+		path,
+		type: typeCandidate
+	};
+};
+var readExactEntry = async (repository, path, signal) => {
+	const candidate = await repository.getEntry(path, signal === void 0 ? void 0 : { signal });
+	return candidate === null ? null : copyReaderEntry(candidate, "get-entry", path);
+};
+var addEntryTypeDiagnostic = (diagnostics, entry, expectedType) => {
+	diagnostics.add({
+		code: "MOLDEA_ENTRY_TYPE_INVALID",
+		details: {
+			actualType: entry.type,
+			expectedType
+		},
+		path: entry.path
+	});
+};
+var getAgent = (agents, agentId) => {
+	const existing = agents.get(agentId);
+	if (existing !== void 0) return existing;
+	const created = {
+		description: null,
+		handoffDescription: null,
+		id: agentId,
+		instruction: null,
+		path: parseRepositoryPath(`/moldea/agents/${agentId}`)
+	};
+	agents.set(agentId, created);
+	return created;
+};
+var retainCanonicalFile = (inventory, path, fileKind, agentId) => {
+	switch (fileKind) {
+		case "manifest":
+			inventory.manifest = path;
+			return;
+		case "project":
+			inventory.project = path;
+			return;
+		case "context":
+			inventory.context.add(path);
+			return;
+		case "decision":
+			inventory.decisions.add(path);
+			return;
+		case "runtime-guidance":
+			inventory.runtimeGuidance.add(path);
+			return;
+	}
+	if (agentId === null) return invalidSourceData$1("list-entries-page", path);
+	const agent = getAgent(inventory.agents, agentId);
+	if (fileKind === "agent-description") agent.description = path;
+	else if (fileKind === "agent-instruction") agent.instruction = path;
+	else agent.handoffDescription = path;
+};
+var finalizeInventory = (working) => {
+	const sortPaths = (paths) => {
+		return [...paths].sort(compareExactStrings);
+	};
+	const agents = [...working.agents.values()].sort((left, right) => compareExactStrings(left.id, right.id)).map((agent) => freezeRecursively({ ...agent }));
+	return freezeRecursively({
+		agents,
+		context: sortPaths(working.context),
+		decisions: sortPaths(working.decisions),
+		manifest: working.manifest,
+		project: working.project,
+		runtimeGuidance: sortPaths(working.runtimeGuidance)
+	});
+};
+var finalizeResult = (working, diagnostics) => {
+	const finalizedDiagnostics = diagnostics.finalize();
+	return freezeRecursively({
+		diagnostics: finalizedDiagnostics,
+		inventory: finalizeInventory(working),
+		valid: finalizedDiagnostics.length === 0
+	});
+};
+var retainFoundationEntry = (entry, expectedPath, missingCode, working, diagnostics) => {
+	if (entry === null) {
+		diagnostics.add({
+			code: missingCode,
+			path: expectedPath
+		});
+		return;
+	}
+	if (entry.type === "file") {
+		if (expectedPath === MANIFEST_PATH$1) working.manifest = expectedPath;
+		else working.project = expectedPath;
+		return;
+	}
+	if (entry.type === "symlink") {
+		diagnostics.add({
+			code: "MOLDEA_CANONICAL_ASSET_SYMLINK",
+			path: expectedPath
+		});
+		return;
+	}
+	addEntryTypeDiagnostic(diagnostics, entry, "file");
+};
+var checkFoundationListing = (listedEntry, exactEntry) => {
+	if (exactEntry === null || exactEntry.type !== listedEntry.type) return invalidSourceData$1("list-entries-page", listedEntry.path);
+};
+/**
+* Discovers and classifies version 1 canonical assets through one repository snapshot.
+* @param repository The coherent source-neutral repository reader.
+* @param limits The immutable Core limits governing diagnostic collection.
+* @param signal Optional cancellation forwarded to every repository operation.
+* @param foundations Optional exact foundation entries already observed by this inspection.
+* @returns A deeply immutable inventory and its deterministic structural diagnostics.
+* @throws
+* - ENTRY_NOT_FOUND: The reader snapshot became inconsistent during discovery.
+* - ENTRY_NOT_DIRECTORY: The reader snapshot became inconsistent during discovery.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source was unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during discovery.
+* - INVALID_SOURCE_DATA: The repository reader returned invalid contract data.
+* - RESOURCE_LIMIT_EXCEEDED: A Core or repository resource limit was exceeded.
+* - ABORTED: Discovery or a repository operation was aborted.
+*/
+var discoverCanonicalAssets = async (repository, limits, signal, foundations) => {
+	const diagnostics = createCoreDiagnosticCollector(limits, "validate-project");
+	const working = createWorkingInventory();
+	const moldeaEntry = foundations === void 0 ? await readExactEntry(repository, MOLDEA_ROOT$1, signal) : foundations.moldeaRoot;
+	if (moldeaEntry === null) {
+		diagnostics.add({
+			code: "MOLDEA_MANIFEST_MISSING",
+			path: MANIFEST_PATH$1
+		});
+		diagnostics.add({
+			code: "MOLDEA_PROJECT_FILE_MISSING",
+			path: PROJECT_PATH$1
+		});
+		return finalizeResult(working, diagnostics);
+	}
+	if (moldeaEntry.type !== "directory") {
+		addEntryTypeDiagnostic(diagnostics, moldeaEntry, "directory");
+		return finalizeResult(working, diagnostics);
+	}
+	const manifestEntry = foundations === void 0 ? await readExactEntry(repository, MANIFEST_PATH$1, signal) : foundations.manifest;
+	const projectEntry = foundations === void 0 ? await readExactEntry(repository, PROJECT_PATH$1, signal) : foundations.project;
+	retainFoundationEntry(manifestEntry, MANIFEST_PATH$1, "MOLDEA_MANIFEST_MISSING", working, diagnostics);
+	retainFoundationEntry(projectEntry, PROJECT_PATH$1, "MOLDEA_PROJECT_FILE_MISSING", working, diagnostics);
+	const seenPaths = /* @__PURE__ */ new Set();
+	let listedManifest = false;
+	let listedProject = false;
+	const listOptions = signal === void 0 ? { prefix: MOLDEA_ROOT$1 } : {
+		prefix: MOLDEA_ROOT$1,
+		signal
+	};
+	for await (const candidate of repository.iterateEntries(listOptions)) {
+		const entry = copyReaderEntry(candidate, "list-entries-page");
+		if (!entry.path.startsWith("/moldea/")) return invalidSourceData$1("list-entries-page", entry.path);
+		if (seenPaths.has(entry.path)) return invalidSourceData$1("list-entries-page", entry.path);
+		seenPaths.add(entry.path);
+		if (entry.path === MANIFEST_PATH$1) {
+			checkFoundationListing(entry, manifestEntry);
+			listedManifest = true;
+			continue;
+		}
+		if (entry.path === PROJECT_PATH$1) {
+			checkFoundationListing(entry, projectEntry);
+			listedProject = true;
+			continue;
+		}
+		const classification = classifyCanonicalEntry(entry);
+		switch (classification.kind) {
+			case "canonical-file":
+				retainCanonicalFile(working, entry.path, classification.fileKind, classification.agentId);
+				break;
+			case "agent-directory":
+				getAgent(working.agents, classification.agentId);
+				break;
+			case "canonical-asset-symlink":
+				diagnostics.add({
+					code: "MOLDEA_CANONICAL_ASSET_SYMLINK",
+					path: entry.path
+				});
+				break;
+			case "entry-type-invalid":
+				addEntryTypeDiagnostic(diagnostics, entry, classification.expectedType);
+				break;
+			case "unrecognized": diagnostics.add({
+				code: "MOLDEA_CANONICAL_PATH_UNRECOGNIZED",
+				details: { entryType: entry.type },
+				path: entry.path
+			});
+		}
+	}
+	if (manifestEntry !== null !== listedManifest) return invalidSourceData$1("list-entries-page", MANIFEST_PATH$1);
+	if (projectEntry !== null !== listedProject) return invalidSourceData$1("list-entries-page", PROJECT_PATH$1);
+	return finalizeResult(working, diagnostics);
+};
+//#endregion
+//#region src/decision-graph-validation/index.ts
+var sortCandidates = (candidates) => {
+	return [...candidates].sort((left, right) => compareExactStrings(left.path, right.path));
+};
+var buildGraphIndex = (candidates) => {
+	const mutableGroups = /* @__PURE__ */ new Map();
+	for (const candidate of sortCandidates(candidates)) {
+		if (candidate.id === null) continue;
+		const group = mutableGroups.get(candidate.id) ?? [];
+		group.push(candidate);
+		mutableGroups.set(candidate.id, group);
+	}
+	const candidateGroups = /* @__PURE__ */ new Map();
+	const nodes = /* @__PURE__ */ new Map();
+	for (const id of [...mutableGroups.keys()].sort(compareExactStrings)) {
+		const group = mutableGroups.get(id) ?? [];
+		candidateGroups.set(id, group);
+		if (group.length === 1 && group[0]?.decision !== null) {
+			const decision = group[0]?.decision;
+			if (decision !== void 0) nodes.set(id, decision);
+		}
+	}
+	const edges = /* @__PURE__ */ new Map();
+	for (const [id, decision] of nodes) {
+		const resolvedTargets = decision.supersedes.filter((targetId) => {
+			const group = candidateGroups.get(targetId);
+			return group?.length === 1 && group[0]?.decision !== null;
+		});
+		edges.set(id, resolvedTargets);
+	}
+	return {
+		candidateGroups,
+		edges,
+		nodes
+	};
+};
+var collectDuplicateDiagnostics = (index, diagnostics) => {
+	for (const [id, candidates] of index.candidateGroups) {
+		if (candidates.length < 2) continue;
+		for (const candidate of candidates) diagnostics.add({
+			code: "MOLDEA_DECISION_ID_DUPLICATE",
+			details: { occurrences: candidates.length },
+			entity: { decisionId: id },
+			path: candidate.path
+		});
+	}
+};
+var collectReferenceDiagnostics = (index, diagnostics) => {
+	for (const decision of index.nodes.values()) for (const targetId of decision.supersedes) {
+		if (index.candidateGroups.has(targetId)) continue;
+		diagnostics.add({
+			code: "MOLDEA_DECISION_REFERENCE_MISSING",
+			details: { referencedDecisionId: targetId },
+			entity: { decisionId: decision.id },
+			path: decision.path,
+			pointer: "/supersedes"
+		});
+	}
+};
+var collectStatusDiagnostics = (index, diagnostics) => {
+	const activelySupersededIds = /* @__PURE__ */ new Set();
+	for (const decision of index.nodes.values()) {
+		if (decision.status !== "accepted" && decision.status !== "superseded") continue;
+		for (const targetId of index.edges.get(decision.id) ?? []) {
+			const target = index.nodes.get(targetId);
+			if (target === void 0) continue;
+			if (target.status === "superseded") {
+				activelySupersededIds.add(targetId);
+				continue;
+			}
+			diagnostics.add({
+				code: "MOLDEA_DECISION_SUPERSESSION_STATUS_INVALID",
+				details: {
+					referencedDecisionId: targetId,
+					sourceStatus: decision.status,
+					targetStatus: target.status
+				},
+				entity: { decisionId: decision.id },
+				path: decision.path,
+				pointer: "/supersedes"
+			});
+		}
+	}
+	return activelySupersededIds;
+};
+var collectOrphanDiagnostics = (index, activelySupersededIds, diagnostics) => {
+	for (const decision of index.nodes.values()) if (decision.status === "superseded" && !activelySupersededIds.has(decision.id)) diagnostics.add({
+		code: "MOLDEA_DECISION_SUPERSEDED_ORPHAN",
+		entity: { decisionId: decision.id },
+		path: decision.path
+	});
+};
+var calculateFinishOrder = (index) => {
+	const visited = /* @__PURE__ */ new Set();
+	const finished = [];
+	for (const startId of index.nodes.keys()) {
+		if (visited.has(startId)) continue;
+		const stack = [{
+			id: startId,
+			nextNeighbor: 0
+		}];
+		visited.add(startId);
+		while (stack.length > 0) {
+			const current = stack.at(-1);
+			if (current === void 0) break;
+			const neighbor = (index.edges.get(current.id) ?? [])[current.nextNeighbor];
+			if (neighbor === void 0) {
+				finished.push(current.id);
+				stack.pop();
+				continue;
+			}
+			current.nextNeighbor += 1;
+			if (!visited.has(neighbor)) {
+				visited.add(neighbor);
+				stack.push({
+					id: neighbor,
+					nextNeighbor: 0
+				});
+			}
+		}
+	}
+	return finished;
+};
+var buildReverseEdges = (index) => {
+	const reverseEdges = /* @__PURE__ */ new Map();
+	for (const id of index.nodes.keys()) reverseEdges.set(id, []);
+	for (const [sourceId, targets] of index.edges) for (const targetId of targets) reverseEdges.get(targetId)?.push(sourceId);
+	for (const sources of reverseEdges.values()) sources.sort(compareExactStrings);
+	return reverseEdges;
+};
+var findStronglyConnectedComponents = (index) => {
+	const reverseEdges = buildReverseEdges(index);
+	const visited = /* @__PURE__ */ new Set();
+	const components = [];
+	for (const startId of [...calculateFinishOrder(index)].reverse()) {
+		if (visited.has(startId)) continue;
+		const component = [];
+		const stack = [startId];
+		visited.add(startId);
+		while (stack.length > 0) {
+			const currentId = stack.pop();
+			if (currentId === void 0) break;
+			component.push(currentId);
+			for (const sourceId of [...reverseEdges.get(currentId) ?? []].reverse()) if (!visited.has(sourceId)) {
+				visited.add(sourceId);
+				stack.push(sourceId);
+			}
+		}
+		components.push(component.sort(compareExactStrings));
+	}
+	return components.sort((left, right) => compareExactStrings(left[0] ?? "", right[0] ?? ""));
+};
+var collectCycleDiagnostics = (index, diagnostics) => {
+	for (const component of findStronglyConnectedComponents(index)) {
+		if (component.length < 2) continue;
+		const cycleRepresentativeDecisionId = component[0];
+		if (cycleRepresentativeDecisionId === void 0) continue;
+		for (const decisionId of component) {
+			const decision = index.nodes.get(decisionId);
+			if (decision !== void 0) diagnostics.add({
+				code: "MOLDEA_DECISION_SUPERSESSION_CYCLE",
+				details: {
+					cycleRepresentativeDecisionId,
+					cycleSize: component.length
+				},
+				entity: { decisionId },
+				path: decision.path,
+				pointer: "/supersedes"
+			});
+		}
+	}
+};
+/**
+* Validates every trustworthy cross-file relationship in one decision candidate set.
+* @param candidates Discovered candidates with valid parsed decisions where available.
+* @param limits The immutable Core limits governing repository-level diagnostics.
+* @returns Deterministically sorted, deeply immutable graph diagnostics.
+* @throws
+* - RESOURCE_LIMIT_EXCEEDED: The repository-level diagnostic budget was exceeded.
+*/
+var validateDecisionGraph = (candidates, limits) => {
+	const diagnostics = createCoreDiagnosticCollector(limits, "validate-project");
+	const index = buildGraphIndex(candidates);
+	collectDuplicateDiagnostics(index, diagnostics);
+	collectReferenceDiagnostics(index, diagnostics);
+	collectCycleDiagnostics(index, diagnostics);
+	collectOrphanDiagnostics(index, collectStatusDiagnostics(index, diagnostics), diagnostics);
+	return diagnostics.finalize();
+};
+//#endregion
+//#region src/decision-graph/index.ts
+var invalidSourceData = (path) => {
+	throw new RepositorySourceException({
+		code: "INVALID_SOURCE_DATA",
+		operation: "read-file-page",
+		path,
+		retryable: false
+	});
+};
+var sortDecisions = (decisions) => {
+	return [...decisions].sort((left, right) => {
+		return compareExactStrings(left.id, right.id) || compareExactStrings(left.path, right.path);
+	});
+};
+/**
+* Reads, parses, and validates every discovered decision through one repository snapshot.
+* @param repository The coherent source-neutral repository reader.
+* @param paths The decision candidates retained by canonical discovery.
+* @param options The immutable Core limit snapshot.
+* @param signal Optional cancellation forwarded to every repository read.
+* @returns A deeply immutable internal decision set and its deterministic diagnostics.
+* @throws
+* - ENTRY_NOT_FOUND: The requested repository entry was not found.
+* - ENTRY_NOT_FILE: The requested repository entry is not a file.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during the operation.
+* - INVALID_SOURCE_DATA: The repository source returned invalid data.
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+* - RESOURCE_LIMIT_EXCEEDED: A named repository resource limit was exceeded.
+* - ABORTED: The Core operation was aborted.
+* - ABORTED: The repository operation was aborted.
+*/
+var readDecisionGraph = async (repository, paths, options, signal) => {
+	options = createCoreOperationOptionsSnapshot(options);
+	const diagnostics = createCoreDiagnosticCollector(options.limits, "validate-project");
+	const candidates = [];
+	const decisions = [];
+	const readOptions = signal === void 0 ? void 0 : { signal };
+	for (const path of [...paths].sort(compareExactStrings)) {
+		const content = await repository.readCompleteFile(path, readOptions);
+		if (!(content instanceof Uint8Array)) return invalidSourceData(path);
+		const parsed = await parseDecisionDocument({
+			content: content.slice(),
+			path
+		}, options, "validate-project");
+		for (const diagnostic of parsed.diagnostics) diagnostics.merge(diagnostic);
+		candidates.push({
+			decision: parsed.decision,
+			id: parseDecisionIdFromPath(path),
+			path
+		});
+		if (parsed.decision !== null) decisions.push(parsed.decision);
+	}
+	for (const diagnostic of validateDecisionGraph(candidates, options.limits)) diagnostics.merge(diagnostic);
+	const finalizedDiagnostics = diagnostics.finalize();
+	return freezeRecursively({
+		decisions: sortDecisions(decisions),
+		diagnostics: finalizedDiagnostics,
+		valid: finalizedDiagnostics.length === 0
+	});
+};
+//#endregion
+//#region src/manifest-relationship-validation/index.ts
+/** Creates diagnostic entity metadata for a decision relationship. */
+var createDecisionEntity = (decisionPath, agentId) => {
+	const decisionId = parseDecisionIdFromPath(decisionPath);
+	return {
+		...agentId === void 0 ? {} : { agentId },
+		...decisionId === null ? {} : { decisionId }
+	};
+};
+/** Adds a missing-context diagnostic unless discovery owns the target-path failure. */
+var validateContextRelationship = (referencedPath, pointer, validContextPaths, context, agentId) => {
+	if (validContextPaths.has(referencedPath) || context.blockedPaths.has(referencedPath)) return;
+	context.collector.add({
+		code: "MOLDEA_REFERENCE_MISSING",
+		details: { referencedPath },
+		entity: agentId === void 0 ? null : { agentId },
+		path: context.manifestPath,
+		pointer
+	});
+};
+/** Adds missing or inactive diagnostics for a decision relationship. */
+var validateDecisionRelationship = (referencedPath, pointer, context, agentId) => {
+	if (!context.discoveredDecisionPaths.has(referencedPath)) {
+		if (context.blockedPaths.has(referencedPath)) return;
+		context.collector.add({
+			code: "MOLDEA_DECISION_REFERENCE_MISSING",
+			details: { referencedPath },
+			entity: createDecisionEntity(referencedPath, agentId),
+			path: context.manifestPath,
+			pointer
+		});
+		return;
+	}
+	const parsedDecision = context.parsedDecisionsByPath.get(referencedPath);
+	if (parsedDecision === void 0 || parsedDecision.status === "accepted") return;
+	context.collector.add({
+		code: "MOLDEA_DECISION_RELATIONSHIP_INACTIVE",
+		details: {
+			referencedPath,
+			targetStatus: parsedDecision.status
+		},
+		entity: createDecisionEntity(referencedPath, agentId),
+		path: context.manifestPath,
+		pointer
+	});
+};
+/**
+* Validates manifest and agent relationships against canonical discovery and parsed decisions.
+* @param manifestPath The canonical manifest path used for relationship diagnostics.
+* @param manifest The normalized manifest contract to validate.
+* @param discovery The canonical repository discovery result.
+* @param decisions The successfully parsed canonical decisions.
+* @param limits The resource limits applied to emitted diagnostics.
+* @returns The frozen deterministic relationship diagnostics.
+* @throws
+* - RESOURCE_LIMIT_EXCEEDED: The repository-level diagnostic budget was exceeded.
+*/
+var validateManifestRelationships = (manifestPath, manifest, discovery, decisions, limits) => {
+	const collector = createCoreDiagnosticCollector(limits, "validate-project");
+	const validAgentContextPaths = new Set(discovery.inventory.context);
+	const validTopLevelContextPaths = new Set(validAgentContextPaths);
+	if (discovery.inventory.project !== null) validTopLevelContextPaths.add(discovery.inventory.project);
+	const validationContext = {
+		blockedPaths: new Set(discovery.diagnostics.flatMap((diagnostic) => diagnostic.path === null ? [] : [diagnostic.path])),
+		collector,
+		discoveredDecisionPaths: new Set(discovery.inventory.decisions),
+		manifestPath,
+		parsedDecisionsByPath: new Map(decisions.map((decision) => [decision.path, decision])),
+		validAgentContextPaths,
+		validTopLevelContextPaths
+	};
+	for (const referencedPathValue of Object.keys(manifest.context ?? {}).sort(compareExactStrings)) validateContextRelationship(parseRepositoryPath(referencedPathValue), `/context/${escapeJsonPointerSegment(referencedPathValue)}`, validationContext.validTopLevelContextPaths, validationContext);
+	for (const referencedPathValue of Object.keys(manifest.decisions ?? {}).sort(compareExactStrings)) validateDecisionRelationship(parseRepositoryPath(referencedPathValue), `/decisions/${escapeJsonPointerSegment(referencedPathValue)}`, validationContext);
+	for (const agentId of Object.keys(manifest.agents ?? {}).sort(compareExactStrings)) {
+		const agent = manifest.agents?.[agentId];
+		if (agent === void 0) continue;
+		const escapedAgentId = escapeJsonPointerSegment(agentId);
+		for (const referencedPath of [...agent.context ?? []].sort(compareExactStrings)) validateContextRelationship(referencedPath, `/agents/${escapedAgentId}/context`, validationContext.validAgentContextPaths, validationContext, agentId);
+		for (const referencedPath of [...agent.decisions ?? []].sort(compareExactStrings)) validateDecisionRelationship(referencedPath, `/agents/${escapedAgentId}/decisions`, validationContext, agentId);
+	}
+	return collector.finalize();
+};
+//#endregion
+//#region src/integration-validation/parser.ts
+var START = "<!-- moldea:start -->";
+var END = "<!-- moldea:end -->";
+/** Finds one ordered marker pair on complete lines, matching the skill writer's region semantics. */
+var parseManagedIntegrationRegion = (text) => {
+	const start = text.indexOf(START);
+	const end = text.indexOf(END);
+	if (start < 0 || end < start || text.indexOf(START, start + 21) >= 0 || text.indexOf(END, end + 19) >= 0) return null;
+	const startsLine = (offset) => offset === 0 || offset === 1 && text[0] === "" || text[offset - 1] === "\n";
+	if (!startsLine(start) || !startsLine(end)) return null;
+	const afterStart = start + 21;
+	const lineEnding = text.startsWith("\r\n", afterStart) ? "\r\n" : text[afterStart] === "\n" ? "\n" : null;
+	if (lineEnding === null) return null;
+	const afterEnd = end + 19;
+	const endLength = text.startsWith("\r\n", afterEnd) ? 2 : text[afterEnd] === "\n" ? 1 : 0;
+	if (endLength === 0 && afterEnd !== text.length) return null;
+	return {
+		start,
+		end: afterEnd + endLength,
+		lineEnding
+	};
+};
+/**
+* Extracts the relative installation path from the fixed relevance-gate command without executing it.
+* @returns The safe installation path or the reason it could not be obtained.
+*/
+var parseIntegrationBlock = (text) => {
+	const region = parseManagedIntegrationRegion(text);
+	if (region === null) return {
+		kind: "missing",
+		reason: text.includes(START) || text.includes(END) ? "block-invalid" : "block-missing"
+	};
+	const matches = text.slice(region.start, region.end).matchAll(/^node "<repo-root>\/([^"\r\n]+)\/scripts\/relevance-gate\.mjs"(?:[ \t\r]|$)/gm);
+	const first = matches.next().value;
+	if (first === void 0 || !matches.next().done) return {
+		kind: "missing",
+		reason: "skill-path-missing"
+	};
+	const skillPath = first[1];
+	if (skillPath === void 0 || !/^[A-Za-z0-9._/-]+$/.test(skillPath) || skillPath.startsWith("/") || skillPath.endsWith("/") || skillPath.includes("//") || /(?:^|\/)\.{1,2}(?:\/|$)/.test(skillPath)) return {
+		kind: "missing",
+		reason: "skill-path-invalid"
+	};
+	return {
+		kind: "found",
+		skillPath
+	};
+};
+//#endregion
+//#region src/integration-validation/inspection.ts
+var AGENTS_PATH = parseRepositoryPath("/AGENTS.md");
+/**
+* Reads bounded untrusted text with a reservation for decoding and temporary string copies.
+* @returns Decoded text or null for invalid UTF-8, with its reservation-release operation.
+* @throws
+* - ENTRY_NOT_FOUND: The requested repository entry was not found.
+* - ENTRY_NOT_FILE: The requested repository entry is not a file.
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+* - RESOURCE_LIMIT_EXCEEDED: A named repository resource limit was exceeded.
+* - ABORTED: The Core operation was aborted.
+* - ABORTED: The repository operation was aborted.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during the operation.
+* - INVALID_SOURCE_DATA: The repository source returned invalid data.
+*/
+var readText = async (ledger, path) => {
+	const source = await ledger.readSourceFile(path);
+	const reservation = source.bytes.byteLength * 8;
+	let isReserved = false;
+	try {
+		ledger.reserve(reservation);
+		isReserved = true;
+		let text;
+		try {
+			text = new TextDecoder("utf-8", { fatal: true }).decode(source.bytes);
+		} catch {
+			text = null;
+		}
+		return {
+			text,
+			release: () => ledger.release(reservation)
+		};
+	} catch (error) {
+		if (isReserved) ledger.release(reservation);
+		throw error;
+	} finally {
+		source.release();
+	}
+};
+/** Distinguishes missing and non-regular files without an extra entry lookup or following symlinks. */
+var getAbsentKind = (error) => error instanceof RepositorySourceException ? error.code === "ENTRY_NOT_FOUND" ? "missing" : error.code === "ENTRY_NOT_FILE" ? "non-regular" : null : null;
+/**
+* Checks the root integration against its installed asset with at most two reads and two lookups.
+* @returns Completed content-free integration warnings, never an execution or runtime-wiring claim.
+* @throws
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+* - RESOURCE_LIMIT_EXCEEDED: A named repository resource limit was exceeded.
+* - ABORTED: The Core operation was aborted.
+* - ABORTED: The repository operation was aborted.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during the operation.
+* - INVALID_SOURCE_DATA: The repository source returned invalid data.
+*/
+var inspectCodingAgentIntegration = async (reader, limits, signal) => {
+	const ledger = getRetainedMemory(reader);
+	const collector = createCoreDiagnosticCollector(limits, "validate-project");
+	const report = (code, details) => {
+		collector.add({
+			code,
+			path: AGENTS_PATH,
+			subject: AGENTS_PATH,
+			qualifier: null,
+			entity: { integrationPath: AGENTS_PATH },
+			details
+		});
+		return collector.finalize();
+	};
+	let document;
+	try {
+		document = await readText(ledger, AGENTS_PATH);
+	} catch (error) {
+		const entryKind = getAbsentKind(error);
+		if (entryKind !== null) return report("MOLDEA_INTEGRATION_BLOCK_MISSING", { entryKind });
+		throw error;
+	}
+	try {
+		if (document.text === null) return report("MOLDEA_INTEGRATION_BLOCK_MISSING", {
+			entryKind: "file",
+			reason: "invalid-utf8"
+		});
+		const parsed = parseIntegrationBlock(document.text);
+		if (parsed.kind === "missing") return report(parsed.reason.startsWith("block-") ? "MOLDEA_INTEGRATION_BLOCK_MISSING" : "MOLDEA_INTEGRATION_SKILL_MISSING", {
+			entryKind: "file",
+			reason: parsed.reason
+		});
+		const { skillPath } = parsed;
+		for (const file of ["SKILL.md", "scripts/relevance-gate.mjs"]) {
+			const path = parseRepositoryPath(`/${skillPath}/${file}`);
+			const entry = await reader.getEntry(path, signal === void 0 ? void 0 : { signal });
+			if (entry?.type !== "file") return report("MOLDEA_INTEGRATION_SKILL_MISSING", {
+				referencedPath: `/${skillPath}`,
+				missingFile: path,
+				entryKind: entry?.type ?? "missing"
+			});
+		}
+		const assetPath = parseRepositoryPath(`/${skillPath}/assets/managed-agents-block.md`);
+		let asset;
+		try {
+			asset = await readText(ledger, assetPath);
+		} catch (error) {
+			const entryKind = getAbsentKind(error);
+			if (entryKind !== null) return report("MOLDEA_INTEGRATION_SKILL_MISSING", {
+				referencedPath: `/${skillPath}`,
+				missingFile: assetPath,
+				entryKind
+			});
+			throw error;
+		}
+		try {
+			if (asset.text === null) return report("MOLDEA_INTEGRATION_BLOCK_STALE", {
+				referencedPath: `/${skillPath}`,
+				reason: "invalid-utf8-asset"
+			});
+			const region = parseManagedIntegrationRegion(document.text);
+			let occurrences = 0;
+			let offset = 0;
+			while ((offset = asset.text.indexOf("{{skill-path}}", offset)) !== -1) {
+				occurrences++;
+				offset += 14;
+			}
+			const renderedReservation = (asset.text.length + occurrences * skillPath.length) * 8;
+			ledger.reserve(renderedReservation);
+			try {
+				const expected = asset.text.replaceAll("{{skill-path}}", skillPath).replace(/\r\n?/g, "\n").replaceAll("\n", region.lineEnding);
+				if (document.text.slice(region.start, region.end) !== expected) return report("MOLDEA_INTEGRATION_BLOCK_STALE", { referencedPath: `/${skillPath}` });
+			} finally {
+				ledger.release(renderedReservation);
+			}
+			return collector.finalize();
+		} finally {
+			asset.release();
+		}
+	} finally {
+		document.release();
+	}
+};
+//#endregion
+//#region src/impact-pattern-validation/inspection.ts
+/** Identifies the canonical document owning an impact relationship. */
+var getOwner = (owner) => {
+	if (owner.kind === "context") return {
+		subject: parseRepositoryPath(owner.id),
+		entity: { contextPath: parseRepositoryPath(owner.id) }
+	};
+	if (owner.kind === "decision") return {
+		subject: parseRepositoryPath(owner.id),
+		entity: { decisionId: parseDecisionIdFromPath(parseRepositoryPath(owner.id)) ?? owner.id }
+	};
+	const agentId = owner.agentId ?? owner.id;
+	return {
+		subject: parseRepositoryPath(`/moldea/agents/${agentId}/instruction.md`),
+		entity: {
+			agentId,
+			...owner.kind === "tool" || owner.kind === "skill" ? {
+				capabilityId: owner.id,
+				capabilityKind: owner.kind
+			} : {}
+		}
+	};
+};
+/** Groups patterns by their complete fixed directory prefix to share source traversal. */
+var groupPatterns = (manifest) => {
+	const groups = /* @__PURE__ */ new Map();
+	for (const declaration of collectManifestScopeDeclarations(manifest)) {
+		if (declaration.field !== "affectedBy" || declaration.declaration.kind !== "glob") continue;
+		const pattern = declaration.declaration.pattern;
+		const segments = pattern.slice(1).split("/");
+		const wildcard = segments.findIndex((segment) => segment.includes("*"));
+		const prefix = parseRepositoryPath("/" + segments.slice(0, wildcard).join("/"));
+		const group = groups.get(prefix) ?? [];
+		group.push({
+			declaration,
+			pattern,
+			segments
+		});
+		groups.set(prefix, group);
+	}
+	return groups;
+};
+/**
+* Checks globs only after required inspection, sharing bounded traversals and stopping on matches.
+* @returns Completed warnings, or no warnings when any traversal exhausts its resource budget.
+* @throws
+* - ABORTED: The Core operation was aborted.
+* - ABORTED: The repository operation was aborted.
+* - ENTRY_NOT_FOUND: The requested repository entry was not found.
+* - ENTRY_NOT_DIRECTORY: The requested repository entry is not a directory.
+* - PROVIDER_INCOMPLETE: The repository provider cannot expose a complete result.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during the operation.
+* - INVALID_SOURCE_DATA: The repository source returned invalid data.
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+*/
+var inspectImpactPatterns = async (reader, manifest, limits, signal) => {
+	const unmatched = [];
+	try {
+		for (const [prefix, patterns] of groupPatterns(manifest)) {
+			const pending = new Set(patterns);
+			if ((await reader.getEntry(prefix, signal === void 0 ? void 0 : { signal }))?.type === "directory") for await (const candidate of reader.iterateEntries({
+				prefix,
+				...signal === void 0 ? {} : { signal }
+			})) {
+				if (candidate.type !== "file") continue;
+				for (const pattern of pending) if (matchesRepositoryGlob(pattern.segments, candidate.path)) pending.delete(pattern);
+				if (pending.size === 0) break;
+			}
+			unmatched.push(...pending);
+		}
+	} catch (error) {
+		if (error instanceof CoreOperationException && error.code === "RESOURCE_LIMIT_EXCEEDED" && error.limit === "maxEntries" || error instanceof RepositorySourceException && error.code === "RESOURCE_LIMIT_EXCEEDED") return {
+			completed: false,
+			diagnostics: []
+		};
+		throw error;
+	}
+	const collector = createCoreDiagnosticCollector(limits, "validate-project");
+	for (const { declaration, pattern } of unmatched) {
+		const { subject, entity } = getOwner(declaration.owner);
+		collector.add({
+			code: "MOLDEA_IMPACT_PATTERN_UNMATCHED",
+			path: parseRepositoryPath("/moldea/moldea.yaml"),
+			pointer: declaration.pointer,
+			subject,
+			qualifier: pattern,
+			entity,
+			details: {
+				pattern,
+				owner: subject
+			}
+		});
+	}
+	return {
+		completed: true,
+		diagnostics: collector.finalize()
+	};
+};
+//#endregion
+//#region src/warning-acceptance/acceptance.ts
+var identity = (entry) => JSON.stringify([
+	entry.code,
+	entry.subject,
+	entry.qualifier ?? null
+]);
+/**
+* Applies explicit manifest acceptances only to checks that completed, retaining all findings.
+* @returns Normalized diagnostics with acceptance flags, reasons, and obsolete-acceptance warnings.
+* @throws
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+*/
+var applyWarningAcceptances = (diagnostics, entries, completed, limits) => {
+	const acceptances = new Map(entries.map((entry, index) => [identity(entry), {
+		entry,
+		index
+	}]));
+	const matched = /* @__PURE__ */ new Set();
+	const results = diagnostics.map((diagnostic) => {
+		if (diagnostic.severity !== "warning" || !diagnostic.acceptable || !completed.has(diagnostic.code)) return diagnostic;
+		const key = identity(diagnostic);
+		const acceptance = acceptances.get(key);
+		if (acceptance === void 0) return diagnostic;
+		matched.add(key);
+		return freezeRecursively({
+			...diagnostic,
+			accepted: true,
+			reason: acceptance.entry.reason
+		});
+	});
+	const collector = createCoreDiagnosticCollector(limits, "validate-project");
+	for (const [key, { entry, index }] of acceptances) {
+		if (matched.has(key) || !completed.has(entry.code)) continue;
+		const pointer = `/acceptedWarnings/${index}`;
+		collector.add({
+			code: "MOLDEA_ACCEPTANCE_UNMATCHED",
+			path: parseRepositoryPath("/moldea/moldea.yaml"),
+			pointer,
+			subject: parseRepositoryPath("/moldea/moldea.yaml"),
+			qualifier: pointer,
+			details: {
+				code: entry.code,
+				subject: entry.subject,
+				qualifier: entry.qualifier ?? null
+			}
+		});
+	}
+	return normalizeDiagnostics([...results, ...collector.finalize()]);
+};
+//#endregion
+//#region src/mirrors/index.ts
+var addDiagnostics$3 = (collector, diagnostics) => {
+	for (const diagnostic of diagnostics) collector.merge(diagnostic);
+};
+/** Adds one declaration-owned mirror diagnostic with safe target metadata. */
+var addMirrorDiagnostic = (collector, code, manifestPath, mirrorPath, pointer, agentId, entry) => {
+	collector.add({
+		code,
+		details: {
+			...entry === void 0 ? {} : { actualType: entry.type },
+			mirrorPath
+		},
+		entity: { agentId },
+		path: manifestPath,
+		pointer
+	});
+};
+/** Resolves, normalizes, and compares one declared mirror. */
+var inspectMirror = async (repository, manifestPath, canonicalInstruction, mirrorPath, pointer, agentId, options, collector, operationOptions, signal) => {
+	const entry = await repository.getEntry(mirrorPath, operationOptions);
+	if (entry === null) {
+		addMirrorDiagnostic(collector, "MOLDEA_MIRROR_MISSING", manifestPath, mirrorPath, pointer, agentId);
+		return null;
+	}
+	if (entry.type === "symlink") {
+		addMirrorDiagnostic(collector, "MOLDEA_MIRROR_SYMLINK", manifestPath, mirrorPath, pointer, agentId, entry);
+		return null;
+	}
+	if (entry.type !== "file") {
+		addMirrorDiagnostic(collector, "MOLDEA_MIRROR_NOT_FILE", manifestPath, mirrorPath, pointer, agentId, entry);
+		return null;
+	}
+	const mirrorResult = await readRepositoryTextAsset(repository, mirrorPath, options.limits, signal);
+	addDiagnostics$3(collector, mirrorResult.diagnostics);
+	if (mirrorResult.asset === null) return null;
+	if (mirrorResult.asset.content !== canonicalInstruction.content) {
+		addMirrorDiagnostic(collector, "MOLDEA_MIRROR_STALE", manifestPath, mirrorPath, pointer, agentId);
+		return null;
+	}
+	return {
+		byteLength: mirrorResult.asset.utf8ByteLength,
+		canonicalDigest: canonicalInstruction.digest,
+		digest: mirrorResult.asset.digest,
+		path: mirrorPath,
+		scalarLength: mirrorResult.asset.scalarLength
+	};
+};
+/**
+* Compares every declared mirror with its available normalized canonical instruction.
+* @param repository The budget-aware reader for the active inspection session.
+* @param manifestPath The canonical manifest path used for declaration diagnostics.
+* @param agents The registered agent assets and normalized instruction prerequisites.
+* @param options The immutable Core configuration snapshot.
+* @param signal Optional cancellation forwarded to every mirror lookup and read.
+* @returns Deeply immutable index-ready mirrors and deterministic diagnostics.
+* @throws
+* - INVALID_REPOSITORY_PATH: A repository path is invalid.
+* - ENTRY_NOT_FOUND: A confirmed mirror file disappeared from the reader snapshot.
+* - ENTRY_NOT_FILE: A confirmed mirror file changed type during inspection.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during mirror inspection.
+* - INVALID_SOURCE_DATA: The repository reader returned invalid contract data.
+* - RESOURCE_LIMIT_EXCEEDED: A Core or repository resource limit was exceeded.
+* - ABORTED: Mirror inspection or a repository operation was aborted.
+*/
+var inspectMirrors = async (repository, manifestPath, agents, options, signal) => {
+	options = createCoreOperationOptionsSnapshot(options);
+	const collector = createCoreDiagnosticCollector(options.limits, "validate-project");
+	const agentMirrors = [];
+	const operationOptions = signal === void 0 ? void 0 : { signal };
+	for (const agent of [...agents].sort((left, right) => compareExactStrings(left.id, right.id))) {
+		const mirrors = [];
+		if (agent.instruction !== null) {
+			const declaredMirrors = [...agent.declaration.mirrors ?? []].sort(compareExactStrings);
+			for (const [index, mirrorPath] of declaredMirrors.entries()) {
+				const mirror = await inspectMirror(repository, manifestPath, agent.instruction, mirrorPath, `/agents/${escapeJsonPointerSegment(agent.id)}/mirrors/${index}`, agent.id, options, collector, operationOptions, signal);
+				if (mirror !== null) mirrors.push(mirror);
+			}
+		}
+		agentMirrors.push({
+			id: agent.id,
+			mirrors
+		});
+	}
+	const diagnostics = collector.finalize();
+	return freezeRecursively({
+		agentMirrors,
+		diagnostics,
+		valid: diagnostics.length === 0
+	});
+};
+//#endregion
+//#region src/project-assets/index.ts
+var addDiagnostics$2 = (collector, diagnostics) => {
+	for (const diagnostic of diagnostics) collector.merge(diagnostic);
+};
+/**
+* Reads and validates the project foundation before canonical enumeration.
+* @param repository The coherent source-neutral reader for the active inspection session.
+* @param path The canonical project path when its exact entry is a regular file.
+* @param options The immutable Core configuration snapshot.
+* @param signal Optional cancellation forwarded to the repository read.
+* @returns The deeply immutable project asset or deterministic content diagnostics.
+* @throws
+* - ENTRY_NOT_FOUND: The located project file disappeared from the snapshot.
+* - ENTRY_NOT_FILE: The located project entry changed type during inspection.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during the project read.
+* - INVALID_SOURCE_DATA: The repository reader returned invalid contract data.
+* - RESOURCE_LIMIT_EXCEEDED: A Core or repository resource limit was exceeded.
+* - ABORTED: Project inspection or the repository read was aborted.
+*/
+var readProjectFile = async (repository, path, options, signal) => {
+	options = createCoreOperationOptionsSnapshot(options);
+	const collector = createCoreDiagnosticCollector(options.limits, "validate-project");
+	let project = null;
+	if (path !== null) {
+		const result = await readRepositoryTextAsset(repository, path, options.limits, signal);
+		addDiagnostics$2(collector, result.diagnostics);
+		if (result.asset !== null) {
+			if (hasNonWhitespace(result.asset.content)) project = result.asset;
+			else collector.add({
+				code: "MOLDEA_PROJECT_FILE_EMPTY",
+				path: result.asset.path
+			});
+		}
+	}
+	const diagnostics = collector.finalize();
+	return freezeRecursively({
+		diagnostics,
+		project,
+		valid: diagnostics.length === 0
+	});
+};
+/**
+* Reads the project foundation and every discovered focused-context asset.
+* @param repository The coherent source-neutral reader for the active inspection session.
+* @param manifest The normalized manifest used to attach context relationships, when valid.
+* @param discovery The canonical inventory and path-owned structural diagnostics.
+* @param options The immutable Core configuration snapshot.
+* @param signal Optional cancellation forwarded to every repository read.
+* @param projectFile Optional project foundation already read before canonical enumeration.
+* @returns Deeply immutable valid assets and deterministic content diagnostics.
+* @throws
+* - ENTRY_NOT_FOUND: A discovered project or context file disappeared from the snapshot.
+* - ENTRY_NOT_FILE: A discovered project or context entry changed type during inspection.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during asset reads.
+* - INVALID_SOURCE_DATA: The repository reader returned invalid contract data.
+* - RESOURCE_LIMIT_EXCEEDED: A Core or repository resource limit was exceeded.
+* - ABORTED: Project asset inspection or a repository operation was aborted.
+*/
+var readProjectAssets = async (repository, manifest, discovery, options, signal, projectFile) => {
+	options = createCoreOperationOptionsSnapshot(options);
+	const collector = createCoreDiagnosticCollector(options.limits, "validate-project");
+	const context = [];
+	const inspectedProject = projectFile ?? await readProjectFile(repository, discovery.inventory.project, options, signal);
+	addDiagnostics$2(collector, inspectedProject.diagnostics);
+	for (const path of [...discovery.inventory.context].sort(compareExactStrings)) {
+		const result = await readRepositoryTextAsset(repository, path, options.limits, signal);
+		addDiagnostics$2(collector, result.diagnostics);
+		if (result.asset === null) continue;
+		if (!hasNonWhitespace(result.asset.content)) {
+			collector.add({
+				code: "MOLDEA_CONTEXT_FILE_EMPTY",
+				path
+			});
+			continue;
+		}
+		context.push({
+			asset: result.asset,
+			relationships: manifest?.context?.[path] ?? null
+		});
+	}
+	const diagnostics = collector.finalize();
+	return freezeRecursively({
+		context,
+		diagnostics,
+		project: inspectedProject.project,
+		valid: diagnostics.length === 0
+	});
+};
+//#endregion
+//#region src/project-index/index.ts
+var createIndexedDecisions = (decisions, manifest) => {
+	return [...decisions].sort((left, right) => compareExactStrings(left.id, right.id) || compareExactStrings(left.path, right.path)).map((decision) => ({
+		decision,
+		relationships: manifest.value.decisions?.[decision.path] ?? null
+	}));
+};
+var createIndexedAgents = (agents, agentMirrors) => {
+	const mirrorsByAgent = new Map(agentMirrors.map((entry) => [entry.id, entry.mirrors]));
+	const indexedAgents = [];
+	if (mirrorsByAgent.size !== agents.length) return null;
+	for (const agent of [...agents].sort((left, right) => compareExactStrings(left.id, right.id))) {
+		const mirrors = mirrorsByAgent.get(agent.id);
+		if (agent.description === null || agent.instruction === null || mirrors === void 0) return null;
+		indexedAgents.push({
+			context: [...agent.declaration.context ?? []].sort(compareExactStrings),
+			decisions: [...agent.declaration.decisions ?? []].sort(compareExactStrings),
+			declaration: agent.declaration,
+			description: agent.description,
+			handoffDescription: agent.handoffDescription,
+			id: agent.id,
+			instruction: agent.instruction,
+			mirrors: [...mirrors].sort((left, right) => compareExactStrings(left.path, right.path))
+		});
+	}
+	return indexedAgents;
+};
+/**
+* Constructs one deterministic provisional index from complete universal validation outputs.
+* @param input The normalized assets and relationships retained by universal inspection.
+* @returns The deeply immutable project index, or null when a required asset is unavailable.
+*/
+var createProjectIndex = (input) => {
+	const agents = createIndexedAgents(input.agents, input.agentMirrors);
+	if (agents === null) return null;
+	const unresolved = input.manifest.value.unresolved ?? createNullPrototypeRecord([]);
+	return freezeRecursively({
+		agents,
+		context: [...input.context].sort((left, right) => compareExactStrings(left.asset.path, right.asset.path)),
+		decisions: createIndexedDecisions(input.decisions, input.manifest),
+		formatVersion: 1,
+		manifest: input.manifest,
+		project: input.project,
+		runtimes: [...input.runtimes].sort((left, right) => compareExactStrings(left.asset.path, right.asset.path)),
+		unresolved
+	});
+};
+//#endregion
+//#region src/export-inventory/inventory.ts
+/** Identifies syntax-only source formats with explicit runtime export semantics. */
+var isSupportedExportSource = (path) => !/\.d\.(?:ts|tsx|mts|cts)$/.test(path) && /\.(?:ts|tsx|mts|cts|js|mjs|jsx)$/.test(path);
+/**
+* Reads and parses a declared source once, retaining only its export-name set.
+* @returns A conclusive inventory or the precise reason analysis could not run.
+* @throws
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+* - RESOURCE_LIMIT_EXCEEDED: A named repository resource limit was exceeded.
+* - ABORTED: The Core operation was aborted.
+* - ABORTED: The repository operation was aborted.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during the operation.
+* - INVALID_SOURCE_DATA: The repository source returned invalid data.
+* - ENTRY_NOT_FOUND: The requested repository entry was not found.
+* - ENTRY_NOT_FILE: The requested repository entry is not a file.
+*/
+var readExportInventory = async (reader, path) => {
+	if (!isSupportedExportSource(path)) return {
+		kind: "not-checked",
+		reason: "unsupported-file-type"
+	};
+	const ledger = getRetainedMemory(reader);
+	const source = await ledger.readSourceFile(path);
+	const reservation = 65536 + source.bytes.byteLength * 520;
+	try {
+		if (!ledger.tryReserve(reservation)) return {
+			kind: "not-checked",
+			reason: "resource-limit"
+		};
+		try {
+			const { inventoryExports } = await import("./syntax-CVvExx4R.js");
+			const result = inventoryExports(path, source.bytes);
+			if (result.kind === "parsed") {
+				let bytes = 64;
+				for (const name of result.names) bytes += 64 + name.length * 2;
+				ledger.reserve(bytes);
+			}
+			return result;
+		} finally {
+			ledger.release(reservation);
+		}
+	} finally {
+		source.release();
+	}
+};
+//#endregion
+//#region src/repository-reference-validation/index.ts
+var childPointer = (pointer, segment) => {
+	return `${pointer}/${escapeJsonPointerSegment(segment)}`;
+};
+var compareNullableStrings = (left, right) => {
+	if (left === void 0) return right === void 0 ? 0 : -1;
+	return right === void 0 ? 1 : compareExactStrings(left, right);
+};
+var compareReferences = (left, right) => {
+	return compareExactStrings(left.path, right.path) || compareNullableStrings(left.symbol, right.symbol);
+};
+/** Adds sorted repository-reference array entries with their normalized indexes. */
+var addReferenceCandidates = (candidates, references, pointer, entity, relationship) => {
+	for (const [index, reference] of [...references ?? []].sort(compareReferences).entries()) candidates.push({
+		entity,
+		kind: "reference",
+		path: reference.path,
+		pointer: childPointer(pointer, String(index)),
+		...relationship === void 0 ? {} : { relationship },
+		...reference.symbol === void 0 ? {} : { symbol: reference.symbol }
+	});
+};
+/** Adds sorted exact impact paths while retaining skipped glob indexes. */
+var addImpactCandidates = (candidates, affectedBy, pointer, entity) => {
+	for (const [index, pattern] of [...affectedBy ?? []].sort(compareExactStrings).entries()) {
+		if (pattern.includes("*")) continue;
+		candidates.push({
+			entity,
+			kind: "impact",
+			path: parseRepositoryPath(pattern),
+			pointer: childPointer(pointer, String(index))
+		});
+	}
+};
+/** Adds repository-backed declarations owned by one context or decision relationship. */
+var addRelationshipCandidates = (candidates, relationship, pointer, entity) => {
+	addReferenceCandidates(candidates, relationship.bindings, childPointer(pointer, "bindings"), entity, pointer.startsWith("/context/") ? "context-binding" : "decision-binding");
+	addImpactCandidates(candidates, relationship.affectedBy, childPointer(pointer, "affectedBy"), entity);
+};
+/** Adds related repository references from sorted unresolved requirements. */
+var addUnresolvedCandidates = (candidates, requirements, pointer, entity) => {
+	for (const requirementId of Object.keys(requirements ?? {}).sort(compareExactStrings)) {
+		const requirement = requirements?.[requirementId];
+		if (requirement === void 0) continue;
+		addReferenceCandidates(candidates, requirement.related, childPointer(childPointer(pointer, requirementId), "related"), entity);
+	}
+};
+/** Adds one capability's implementation, optional bindings, and exact impact paths. */
+var addCapabilityCandidates = (candidates, capability, capabilityKind, capabilityId, agentId, collectionPointer, additionalReferences = []) => {
+	const capabilityPointer = childPointer(collectionPointer, capabilityId);
+	const capabilityEntity = {
+		agentId,
+		capabilityId,
+		capabilityKind
+	};
+	candidates.push({
+		entity: capabilityEntity,
+		kind: `${capabilityKind}-implementation`,
+		relationship: `${capabilityKind}-implementation`,
+		...capability.implementation.symbol === void 0 ? {} : { symbol: capability.implementation.symbol },
+		path: capability.implementation.path,
+		pointer: childPointer(capabilityPointer, "implementation")
+	});
+	for (const [property, reference] of [["registration", capability.registration], ...additionalReferences]) if (reference !== void 0) candidates.push({
+		entity: capabilityEntity,
+		kind: "reference",
+		path: reference.path,
+		pointer: childPointer(capabilityPointer, property),
+		relationship: `${capabilityKind}-${property === "inputSchema" ? "input-schema" : property === "outputSchema" ? "output-schema" : "registration"}`,
+		...reference.symbol === void 0 ? {} : { symbol: reference.symbol }
+	});
+	addImpactCandidates(candidates, capability.affectedBy, childPointer(capabilityPointer, "affectedBy"), capabilityEntity);
+};
+/** Adds all repository-backed declarations owned by one normalized agent. */
+var addAgentCandidates = (candidates, agentId, agent) => {
+	const pointer = `/agents/${escapeJsonPointerSegment(agentId)}`;
+	const entity = { agentId };
+	const bindingsPointer = childPointer(pointer, "bindings");
+	const bindings = agent.bindings;
+	for (const property of [
+		"runtimeAgent",
+		"inputSchema",
+		"outputSchema",
+		"instructionLoader"
+	]) {
+		const reference = bindings?.[property];
+		if (reference !== void 0) candidates.push({
+			entity,
+			kind: "reference",
+			path: reference.path,
+			pointer: childPointer(bindingsPointer, property),
+			relationship: {
+				runtimeAgent: "runtime-agent",
+				inputSchema: "agent-input-schema",
+				outputSchema: "agent-output-schema",
+				instructionLoader: "instruction-loader"
+			}[property],
+			...reference.symbol === void 0 ? {} : { symbol: reference.symbol }
+		});
+	}
+	for (const variableId of Object.keys(bindings?.variableProviders ?? {}).sort(compareExactStrings)) {
+		const reference = bindings?.variableProviders?.[variableId];
+		if (reference !== void 0) candidates.push({
+			entity: {
+				agentId,
+				variableId
+			},
+			relationship: "variable-provider",
+			...reference.symbol === void 0 ? {} : { symbol: reference.symbol },
+			kind: "reference",
+			path: reference.path,
+			pointer: childPointer(childPointer(bindingsPointer, "variableProviders"), variableId)
+		});
+	}
+	addImpactCandidates(candidates, agent.affectedBy, childPointer(pointer, "affectedBy"), entity);
+	const toolsPointer = childPointer(pointer, "tools");
+	for (const capabilityId of Object.keys(agent.tools ?? {}).sort(compareExactStrings)) {
+		const capability = agent.tools?.[capabilityId];
+		if (capability !== void 0) addCapabilityCandidates(candidates, capability, "tool", capabilityId, agentId, toolsPointer, [["inputSchema", capability.inputSchema], ["outputSchema", capability.outputSchema]]);
+	}
+	const skillsPointer = childPointer(pointer, "skills");
+	for (const capabilityId of Object.keys(agent.skills ?? {}).sort(compareExactStrings)) {
+		const capability = agent.skills?.[capabilityId];
+		if (capability !== void 0) addCapabilityCandidates(candidates, capability, "skill", capabilityId, agentId, skillsPointer);
+	}
+	addUnresolvedCandidates(candidates, agent.unresolved, childPointer(pointer, "unresolved"), entity);
+};
+/** Collects every repository-backed manifest declaration in deterministic pointer order. */
+var collectCandidates = (manifest) => {
+	const candidates = [];
+	for (const property of ["context", "decisions"]) {
+		const relationships = manifest[property];
+		for (const referencedPath of Object.keys(relationships ?? {}).sort(compareExactStrings)) {
+			const relationship = relationships?.[referencedPath];
+			if (relationship === void 0) continue;
+			const pointer = childPointer(`/${property}`, referencedPath);
+			const decisionId = property === "decisions" ? parseDecisionIdFromPath(parseRepositoryPath(referencedPath)) : null;
+			addRelationshipCandidates(candidates, relationship, pointer, decisionId === null ? { contextPath: parseRepositoryPath(referencedPath) } : { decisionId });
+		}
+	}
+	addUnresolvedCandidates(candidates, manifest.unresolved, "/unresolved", null);
+	for (const agentId of Object.keys(manifest.agents ?? {}).sort(compareExactStrings)) {
+		const agent = manifest.agents?.[agentId];
+		if (agent !== void 0) addAgentCandidates(candidates, agentId, agent);
+	}
+	return candidates.sort((left, right) => compareExactStrings(left.pointer, right.pointer));
+};
+/** Tests whether discovery already owns a diagnostic for a path or one of its ancestors. */
+var isBlockedPath$1 = (path, blockedPaths) => {
+	let candidate = path;
+	while (candidate.length > 0) {
+		if (blockedPaths.has(candidate)) return true;
+		const separatorIndex = candidate.lastIndexOf("/");
+		if (separatorIndex <= 0) return false;
+		candidate = candidate.slice(0, separatorIndex);
+	}
+	return false;
+};
+/** Creates normalized diagnostic details for one failed exact lookup. */
+var createCandidateDetails = (candidate, entry) => {
+	const details = { [candidate.kind === "impact" ? "impactPath" : "referencedPath"]: candidate.path };
+	if (entry !== null) details["actualType"] = entry.type;
+	if (candidate.kind === "tool-implementation" || candidate.kind === "skill-implementation") details["reason"] = entry === null ? "missing" : entry.type === "symlink" ? "symlink" : "not-file";
+	return details;
+};
+/** Selects the most-specific diagnostic code for one failed exact lookup. */
+var getCandidateCode = (candidate, entry) => {
+	if (entry?.type === "file") return null;
+	if (candidate.kind === "tool-implementation") return "MOLDEA_TOOL_IMPLEMENTATION_MISSING";
+	if (candidate.kind === "skill-implementation") return "MOLDEA_SKILL_IMPLEMENTATION_MISSING";
+	if (candidate.kind === "impact") return entry === null ? "MOLDEA_IMPACT_PATH_MISSING" : "MOLDEA_IMPACT_PATH_NOT_FILE";
+	if (entry === null) return "MOLDEA_REFERENCE_MISSING";
+	return entry.type === "symlink" ? "MOLDEA_REFERENCE_SYMLINK" : "MOLDEA_REFERENCE_NOT_FILE";
+};
+/** Adds the one most-specific diagnostic for a resolved repository candidate. */
+var validateCandidate = (candidate, entry, manifestPath, collector) => {
+	const code = getCandidateCode(candidate, entry);
+	if (code === null) return;
+	collector.add({
+		code,
+		details: createCandidateDetails(candidate, entry),
+		entity: candidate.entity,
+		path: manifestPath,
+		pointer: candidate.pointer
+	});
+};
+/**
+* Validates every manifest repository reference, binding, and exact impact path.
+* @param repository The budget-aware reader for the active inspection session.
+* @param manifestPath The canonical manifest path used for diagnostics.
+* @param manifest The normalized valid manifest contract to inspect.
+* @param discovery Canonical discovery state used to suppress dependent path diagnostics.
+* @param limits The resource limits applied to emitted diagnostics.
+* @param signal Optional cancellation forwarded to exact repository lookups.
+* @param coverage Operation-owned binding coverage populated only for regular files.
+* @returns Deeply immutable deterministic repository-reference diagnostics.
+* @throws
+* - INVALID_REPOSITORY_PATH: The repository path is invalid.
+* - ENTRY_NOT_FOUND: The requested repository entry was not found.
+* - ENTRY_NOT_FILE: The requested repository entry is not a file.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during the operation.
+* - INVALID_SOURCE_DATA: The repository source returned invalid data.
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+* - RESOURCE_LIMIT_EXCEEDED: A named repository resource limit was exceeded.
+* - ABORTED: The Core operation was aborted.
+* - ABORTED: The repository operation was aborted.
+*/
+var validateRepositoryReferences = async (repository, manifestPath, manifest, discovery, limits, signal, coverage = []) => {
+	const collector = createCoreDiagnosticCollector(limits, "validate-project");
+	const blockedPaths = new Set(discovery.diagnostics.flatMap((diagnostic) => diagnostic.path === null ? [] : [diagnostic.path]));
+	const inventories = /* @__PURE__ */ new Map();
+	const entryCache = /* @__PURE__ */ new Map();
+	const operationOptions = signal === void 0 ? void 0 : { signal };
+	for (const candidate of collectCandidates(manifest)) {
+		if (isBlockedPath$1(candidate.path, blockedPaths)) continue;
+		let entryPromise = entryCache.get(candidate.path);
+		if (entryPromise === void 0) {
+			entryPromise = repository.getEntry(candidate.path, operationOptions);
+			entryCache.set(candidate.path, entryPromise);
+		}
+		const entry = await entryPromise;
+		validateCandidate(candidate, entry, manifestPath, collector);
+		if (entry?.type !== "file" || candidate.relationship === void 0) continue;
+		if (coverage.length >= limits.maxCoverage) throw new CoreOperationException({
+			code: "RESOURCE_LIMIT_EXCEEDED",
+			operation: "validate-project",
+			limit: "maxCoverage",
+			limitMaximum: limits.maxCoverage,
+			observedUsage: coverage.length + 1,
+			nextAction: "reduce-input-or-increase-limit"
+		});
+		const base = {
+			entity: candidate.entity ?? {},
+			relationship: candidate.relationship,
+			path: candidate.path,
+			symbol: candidate.symbol ?? null,
+			fileCheck: "passed"
+		};
+		let record;
+		if (candidate.symbol === void 0) record = {
+			...base,
+			exportCheck: "not-checked",
+			exportNotCheckedReason: "no-symbol"
+		};
+		else {
+			let inventory = inventories.get(candidate.path);
+			if (inventory === void 0) {
+				inventory = await readExportInventory(repository, candidate.path);
+				inventories.set(candidate.path, inventory);
+			}
+			if (inventory.kind === "not-checked") record = {
+				...base,
+				exportCheck: "not-checked",
+				exportNotCheckedReason: inventory.reason
+			};
+			else if (!inventory.complete) record = {
+				...base,
+				exportCheck: "not-checked",
+				exportNotCheckedReason: "unresolved-exports"
+			};
+			else if (inventory.names.has(candidate.symbol)) record = {
+				...base,
+				exportCheck: "passed"
+			};
+			else {
+				record = {
+					...base,
+					exportCheck: "failed"
+				};
+				collector.add({
+					code: "MOLDEA_REFERENCE_EXPORT_MISSING",
+					entity: candidate.entity,
+					path: manifestPath,
+					pointer: candidate.pointer,
+					details: {
+						referencedPath: candidate.path,
+						symbol: candidate.symbol,
+						relationship: candidate.relationship
+					}
+				});
+			}
+		}
+		reserveRetainedBytesIfTracked(repository, 512 + JSON.stringify(record).length * 2);
+		coverage.push(record);
+	}
+	return collector.finalize();
+};
+//#endregion
+//#region src/runtime-guidance/index.ts
+var addDiagnostics$1 = (collector, diagnostics) => {
+	for (const diagnostic of diagnostics) collector.merge(diagnostic);
+};
+var isBlockedPath = (path, blockedPaths) => {
+	let candidate = path;
+	while (candidate.length > 0) {
+		if (blockedPaths.has(candidate)) return true;
+		const separatorIndex = candidate.lastIndexOf("/");
+		if (separatorIndex <= 0) return false;
+		candidate = candidate.slice(0, separatorIndex);
+	}
+	return false;
+};
+/**
+* Reads all discovered runtime guidance and validates every manifest guidance relationship.
+* @param repository The coherent source-neutral repository reader.
+* @param manifestPath The canonical manifest path used for relationship diagnostics.
+* @param manifest The normalized manifest declaring optional agent guidance paths, when valid.
+* @param discovery The canonical inventory and path-owned structural diagnostics.
+* @param options The immutable Core configuration snapshot.
+* @param signal Optional cancellation forwarded to every repository read.
+* @returns Deeply immutable valid guidance assets and deterministic diagnostics.
+* @throws
+* - ENTRY_NOT_FOUND: A discovered guidance file disappeared from the reader snapshot.
+* - ENTRY_NOT_FILE: A discovered guidance entry is no longer a regular file.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during guidance reads.
+* - INVALID_SOURCE_DATA: The repository reader returned invalid contract data.
+* - RESOURCE_LIMIT_EXCEEDED: A Core or repository resource limit was exceeded.
+* - ABORTED: Guidance inspection or a repository operation was aborted.
+*/
+var readRuntimeGuidance = async (repository, manifestPath, manifest, discovery, options, signal) => {
+	options = createCoreOperationOptionsSnapshot(options);
+	const collector = createCoreDiagnosticCollector(options.limits, "validate-project");
+	const runtimes = [];
+	const discoveredPaths = new Set(discovery.inventory.runtimeGuidance);
+	const blockedPaths = new Set(discovery.diagnostics.flatMap((diagnostic) => diagnostic.path === null ? [] : [diagnostic.path]));
+	for (const path of [...discoveredPaths].sort(compareExactStrings)) {
+		const result = await readRepositoryTextAsset(repository, path, options.limits, signal);
+		addDiagnostics$1(collector, result.diagnostics);
+		if (result.asset === null) continue;
+		if (!hasNonWhitespace(result.asset.content)) {
+			collector.add({
+				code: "MOLDEA_RUNTIME_GUIDANCE_EMPTY",
+				path
+			});
+			continue;
+		}
+		runtimes.push({ asset: result.asset });
+	}
+	for (const agentId of Object.keys(manifest?.agents ?? {}).sort(compareExactStrings)) {
+		const guidance = manifest?.agents?.[agentId]?.runtime.guidance;
+		if (guidance === void 0 || discoveredPaths.has(guidance) || isBlockedPath(guidance, blockedPaths)) continue;
+		collector.add({
+			code: "MOLDEA_RUNTIME_GUIDANCE_MISSING",
+			details: { referencedPath: guidance },
+			entity: { agentId },
+			path: manifestPath,
+			pointer: `/agents/${escapeJsonPointerSegment(agentId)}/runtime/guidance`
+		});
+	}
+	const diagnostics = collector.finalize();
+	return freezeRecursively({
+		diagnostics,
+		runtimes,
+		valid: diagnostics.length === 0
+	});
+};
+//#endregion
+//#region src/universal-project-inspection/index.ts
+var MOLDEA_ROOT = parseRepositoryPath("/moldea");
+var MANIFEST_PATH = parseRepositoryPath("/moldea/moldea.yaml");
+var PROJECT_PATH = parseRepositoryPath("/moldea/project.md");
+var addDiagnostics = (collector, diagnostics) => {
+	for (const diagnostic of diagnostics) collector.merge(diagnostic);
+};
+/**
+* Executes every universal repository-format phase with syntax-only export checks.
+* @param context The shared inspection session and optional cancellation signal.
+* @param options The immutable Core configuration snapshot.
+* @returns The frozen provisional index only when no universal diagnostic remains.
+* @throws
+* - INVALID_REPOSITORY_PATH: The repository path is invalid.
+* - ENTRY_NOT_FOUND: The requested repository entry was not found.
+* - ENTRY_NOT_FILE: The requested repository entry is not a file.
+* - ENTRY_NOT_DIRECTORY: The requested repository entry is not a directory.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during the operation.
+* - INVALID_SOURCE_DATA: The repository source returned invalid data.
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+* - RESOURCE_LIMIT_EXCEEDED: A named repository resource limit was exceeded.
+* - ABORTED: The Core operation was aborted.
+* - ABORTED: The repository operation was aborted.
+*/
+var inspectUniversalProject = async (context, options) => {
+	options = createCoreOperationOptionsSnapshot(options);
+	const { session, signal } = context;
+	const coverage = [];
+	const collector = createCoreDiagnosticCollector(options.limits, "validate-project");
+	const operationOptions = signal === void 0 ? void 0 : { signal };
+	const moldeaRoot = await session.reader.getEntry(MOLDEA_ROOT, operationOptions);
+	let manifestEntry = null;
+	let projectEntry = null;
+	let indexedManifest = null;
+	let formatVersion = null;
+	if (moldeaRoot?.type === "directory") {
+		manifestEntry = await session.reader.getEntry(MANIFEST_PATH, operationOptions);
+		if (manifestEntry?.type === "file") {
+			const content = await session.reader.readCompleteFile(MANIFEST_PATH, operationOptions);
+			const parsedManifest = await inspectManifestDocument({
+				content,
+				path: MANIFEST_PATH
+			}, options, "validate-project");
+			formatVersion = parsedManifest.formatVersion;
+			addDiagnostics(collector, parsedManifest.diagnostics);
+			if (parsedManifest.asset !== null && parsedManifest.manifest !== null) indexedManifest = {
+				asset: parsedManifest.asset,
+				value: parsedManifest.manifest
+			};
+		}
+		projectEntry = await session.reader.getEntry(PROJECT_PATH, operationOptions);
+	}
+	const projectFile = await readProjectFile(session.reader, projectEntry?.type === "file" ? PROJECT_PATH : null, options, signal);
+	addDiagnostics(collector, projectFile.diagnostics);
+	const discovery = await discoverCanonicalAssets(session.reader, options.limits, signal, {
+		manifest: manifestEntry,
+		moldeaRoot,
+		project: projectEntry
+	});
+	addDiagnostics(collector, discovery.diagnostics);
+	session.throwIfAborted();
+	const projectAssets = await readProjectAssets(session.reader, indexedManifest?.value ?? null, discovery, options, signal, projectFile);
+	addDiagnostics(collector, projectAssets.diagnostics);
+	const runtimeGuidance = await readRuntimeGuidance(session.reader, discovery.inventory.manifest ?? MANIFEST_PATH, indexedManifest?.value ?? null, discovery, options, signal);
+	addDiagnostics(collector, runtimeGuidance.diagnostics);
+	const decisionGraph = await readDecisionGraph(session.reader, discovery.inventory.decisions, options, signal);
+	addDiagnostics(collector, decisionGraph.diagnostics);
+	let agents = [];
+	let agentMirrors = [];
+	if (indexedManifest !== null) {
+		const manifestPath = indexedManifest.asset.path;
+		const agentAssets = await inspectAgentAssets(session.reader, indexedManifest.value, discovery, options, signal);
+		agents = agentAssets.agents;
+		addDiagnostics(collector, agentAssets.diagnostics);
+		addDiagnostics(collector, validateManifestRelationships(manifestPath, indexedManifest.value, discovery, decisionGraph.decisions, options.limits));
+		addDiagnostics(collector, await validateRepositoryReferences(session.reader, manifestPath, indexedManifest.value, discovery, options.limits, signal, coverage));
+		const mirrorInspection = await inspectMirrors(session.reader, manifestPath, agents, options, signal);
+		agentMirrors = mirrorInspection.agentMirrors;
+		addDiagnostics(collector, mirrorInspection.diagnostics);
+	}
+	session.throwIfAborted();
+	addDiagnostics(collector, await inspectCodingAgentIntegration(session.reader, options.limits, signal));
+	const patterns = indexedManifest === null ? {
+		completed: false,
+		diagnostics: []
+	} : await inspectImpactPatterns(session.reader, indexedManifest.value, options.limits, signal);
+	session.throwIfAborted();
+	addDiagnostics(collector, patterns.diagnostics);
+	const diagnostics = applyWarningAcceptances(collector.finalize(), indexedManifest?.value.acceptedWarnings ?? [], /* @__PURE__ */ new Set([...[
+		"MOLDEA_INTEGRATION_BLOCK_MISSING",
+		"MOLDEA_INTEGRATION_SKILL_MISSING",
+		"MOLDEA_INTEGRATION_BLOCK_STALE"
+	], ...patterns.completed ? ["MOLDEA_IMPACT_PATTERN_UNMATCHED"] : []]), options.limits);
+	const project = !diagnostics.some((diagnostic) => diagnostic.severity === "error") && indexedManifest !== null && projectAssets.project !== null ? createProjectIndex({
+		agentMirrors,
+		agents,
+		context: projectAssets.context,
+		decisions: decisionGraph.decisions,
+		manifest: indexedManifest,
+		project: projectAssets.project,
+		runtimes: runtimeGuidance.runtimes
+	}) : null;
+	return freezeRecursively({
+		diagnostics,
+		coverage,
+		formatVersion,
+		project
+	});
+};
+//#endregion
+//#region src/project-validation/index.ts
+var isRecord = (candidate) => {
+	return typeof candidate === "object" && candidate !== null && !Array.isArray(candidate);
+};
+var invalidArgument$1 = () => {
+	throw new CoreOperationException({
+		code: "INVALID_ARGUMENT",
+		operation: "validate-project"
+	});
+};
+var isRepositoryReader = (candidate) => {
+	return isRecord(candidate) && isRecord(candidate["snapshot"]) && typeof candidate["snapshot"]["id"] === "string" && typeof candidate["snapshot"]["sourceKind"] === "string" && typeof candidate["compare"] === "function" && typeof candidate["getEntry"] === "function" && typeof candidate["listEntriesPage"] === "function" && typeof candidate["readFilePage"] === "function";
+};
+var isAbortSignal = (candidate) => {
+	return isRecord(candidate) && typeof candidate["aborted"] === "boolean" && typeof candidate["addEventListener"] === "function" && typeof candidate["removeEventListener"] === "function";
+};
+var validateInput = (candidate) => {
+	try {
+		if (!isRecord(candidate)) return invalidArgument$1();
+		const repository = candidate["repository"];
+		const signal = candidate["signal"];
+		if (Reflect.ownKeys(candidate).some((key) => key !== "repository" && key !== "signal") || !isRepositoryReader(repository) || signal !== void 0 && !isAbortSignal(signal)) return invalidArgument$1();
+		return {
+			repository,
+			...signal === void 0 ? {} : { signal }
+		};
+	} catch (error) {
+		if (error instanceof CoreOperationException) throw error;
+		return invalidArgument$1();
+	}
+};
+/**
+* Inspects one coherent repository snapshot through universal file and export validation.
+* @param input The untrusted source-neutral reader and optional cancellation signal.
+* @param options The immutable Core configuration snapshot.
+* @returns A promise resolving to the frozen all-or-nothing project inspection result.
+* @throws
+* - INVALID_ARGUMENT: The Core operation received an invalid argument.
+* - INVALID_REPOSITORY_PATH: The repository path is invalid.
+* - ENTRY_NOT_FOUND: The requested repository entry was not found.
+* - ENTRY_NOT_FILE: The requested repository entry is not a file.
+* - ENTRY_NOT_DIRECTORY: The requested repository entry is not a directory.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during the operation.
+* - PROVIDER_INCOMPLETE: The repository provider cannot expose a complete result.
+* - INVALID_SOURCE_DATA: The repository source returned invalid data.
+* - RESOURCE_LIMIT_EXCEEDED: A named repository resource limit was exceeded.
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+* - ABORTED: The repository operation was aborted.
+* - ABORTED: The Core operation was aborted.
+*/
+var validateProjectState = async (input, options) => {
+	const validatedInput = validateInput(input);
+	const operationOptions = createCoreOperationOptionsSnapshot(options);
+	const session = createRepositoryInspectionSession(validatedInput.repository, operationOptions.limits, validatedInput.signal);
+	const universal = await inspectUniversalProject({
+		session,
+		...validatedInput.signal === void 0 ? {} : { signal: validatedInput.signal }
+	}, operationOptions);
+	session.throwIfAborted();
+	const counts = countDiagnosticsBySeverity(universal.diagnostics);
+	return freezeRecursively({
+		project: universal.project,
+		resourceUsage: session.getResourceUsage(),
+		result: {
+			diagnostics: universal.diagnostics,
+			...counts,
+			coverage: universal.coverage,
+			coverageCounts: countBindingCoverage(universal.coverage),
+			formatVersion: universal.formatVersion,
+			source: validatedInput.repository.snapshot,
+			summary: universal.project === null ? null : createProjectSummary(universal.project),
+			valid: counts.errorCount === 0
+		}
+	});
+};
+/**
+* Validates one project without returning canonical document bodies.
+* @param input The source-neutral reader and optional cancellation signal.
+* @param options The immutable operation limits.
+* @returns A promise resolving to the complete validation result.
+* @throws
+* - INVALID_ARGUMENT: The Core operation received an invalid argument.
+* - INVALID_REPOSITORY_PATH: The repository path is invalid.
+* - ENTRY_NOT_FOUND: The requested repository entry was not found.
+* - ENTRY_NOT_FILE: The requested repository entry is not a file.
+* - ENTRY_NOT_DIRECTORY: The requested repository entry is not a directory.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during the operation.
+* - PROVIDER_INCOMPLETE: The repository provider cannot expose a complete result.
+* - INVALID_SOURCE_DATA: The repository source returned invalid data.
+* - RESOURCE_LIMIT_EXCEEDED: A named repository resource limit was exceeded.
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+* - ABORTED: The repository operation was aborted.
+* - ABORTED: The Core operation was aborted.
+*/
+var validateProject = async (input, options) => (await validateProjectState(input, options)).result;
+//#endregion
+//#region src/project-inspection/index.ts
+var CURSOR_PREFIX = "core7";
+var PREPARED_FIXED_BYTES = 512;
+var PREPARED_ITEM_FIXED_BYTES = 64;
+var PREPARED_TEXT_BYTE_MULTIPLIER = 2;
+var PREPARED_VIEW_REFERENCE_BYTES = 8;
+var encoder = new TextEncoder();
+var invalidArgument = () => {
+	throw new CoreOperationException({
+		code: "INVALID_ARGUMENT",
+		operation: "create-project-inspection"
+	});
+};
+var resourceLimitExceeded = (limitMaximum, observedUsage) => {
+	throw new CoreOperationException({
+		code: "RESOURCE_LIMIT_EXCEEDED",
+		limit: "maxRetainedBytes",
+		limitMaximum,
+		nextAction: "reduce-input-or-increase-limit",
+		observedUsage,
+		operation: "create-project-inspection"
+	});
+};
+/** Serializes content-free inspection state with recursively sorted object keys. */
+var serializeDeterministically = (candidate) => {
+	if (candidate === null || typeof candidate !== "object") {
+		const serialized = JSON.stringify(candidate);
+		return serialized === void 0 ? "null" : serialized;
+	}
+	if (Array.isArray(candidate)) return `[${candidate.map((item) => serializeDeterministically(item)).join(",")}]`;
+	return `{${Object.entries(candidate).filter(([, value]) => value !== void 0).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, value]) => `${JSON.stringify(key)}:${serializeDeterministically(value)}`).join(",")}}`;
+};
+var createIdentity = (parts) => createRepositoryIdentity((function* () {
+	for (const part of parts) yield encoder.encode(part);
+})());
+var createItemBaseKey = (item) => {
+	if (item.kind === "agent") return [
+		"3",
+		item.agent.agentId,
+		item.agent.runtimeId
+	].join("\0");
+	if (item.kind === "metadata") return [
+		"0",
+		item.metadata.path,
+		item.metadata.kind,
+		item.metadata.agentId ?? "",
+		item.metadata.decisionId ?? "",
+		item.metadata.digest
+	].join(":");
+	if (item.kind === "diagnostic") return [
+		"1",
+		item.diagnostic.source,
+		item.diagnostic.code,
+		item.diagnostic.path ?? "",
+		createIdentity([serializeDeterministically(item.diagnostic)])
+	].join(":");
+	return [
+		"2",
+		item.coverage.path,
+		item.coverage.relationship,
+		item.coverage.entity.agentId ?? "",
+		createIdentity([serializeDeterministically(item.coverage)])
+	].join(":");
+};
+/** Assigns stable unique keys once without relying on collection offsets. */
+var createKeyedItems = (items) => {
+	const sorted = Array.from(items, (item) => ({
+		item,
+		key: createItemBaseKey(item)
+	})).sort((left, right) => left.key < right.key ? -1 : left.key > right.key ? 1 : 0);
+	let previousBaseKey = null;
+	let occurrence = 0;
+	for (const item of sorted) {
+		const baseKey = item.key;
+		occurrence = baseKey === previousBaseKey ? occurrence + 1 : 0;
+		previousBaseKey = baseKey;
+		item.key = `${baseKey}:${String(occurrence).padStart(10, "0")}`;
+	}
+	return sorted;
+};
+var createCursorChecksum = (inspectionDigest, lastKey, view) => createIdentity([
+	CURSOR_PREFIX,
+	inspectionDigest,
+	lastKey,
+	view
+]);
+var encodeCursor = (inspectionDigest, view, lastKey) => [
+	CURSOR_PREFIX,
+	view,
+	encodeURIComponent(lastKey),
+	inspectionDigest,
+	createCursorChecksum(inspectionDigest, lastKey, view)
+].join(":");
+var decodeCursor = (cursor, inspectionDigest, view) => {
+	if (cursor === void 0) return null;
+	const match = /^core7:(all|diagnostics|coverage|metadata):([^:]+):(sha256:[0-9a-f]{64}):(sha256:[0-9a-f]{64})$/u.exec(cursor);
+	if (match === null || match[1] !== view || match[3] !== inspectionDigest) return invalidArgument();
+	let lastKey;
+	try {
+		lastKey = decodeURIComponent(match[2]);
+	} catch {
+		return invalidArgument();
+	}
+	if (lastKey.length === 0 || match[4] !== createCursorChecksum(inspectionDigest, lastKey, view)) return invalidArgument();
+	return lastKey;
+};
+var createViews = (items) => freezeRecursively({
+	all: items,
+	diagnostics: items.filter(({ item }) => item.kind === "diagnostic"),
+	coverage: items.filter(({ item }) => item.kind === "coverage"),
+	metadata: items.filter(({ item }) => item.kind === "metadata" || item.kind === "agent")
+});
+var addRetainedBytes = (current, additional, retainedBeforePreparation, maximum) => {
+	const projectedUsage = retainedBeforePreparation + current + additional;
+	if (!Number.isSafeInteger(additional) || additional < 0 || !Number.isSafeInteger(projectedUsage) || projectedUsage > maximum) return resourceLimitExceeded(maximum, Number.isSafeInteger(projectedUsage) ? projectedUsage : Number.MAX_SAFE_INTEGER);
+	return current + additional;
+};
+/** Iterates every content-free inspection item without retaining preparation state. */
+var iterateProjectInspectionItems = function* (state) {
+	if (state.project !== null) for (const metadata of iterateProjectMetadata(state.project)) yield {
+		kind: "metadata",
+		metadata
+	};
+	for (const diagnostic of state.result.diagnostics) yield {
+		diagnostic,
+		kind: "diagnostic"
+	};
+	for (const coverage of state.result.coverage) yield {
+		coverage,
+		kind: "coverage"
+	};
+	if (state.project !== null) for (const agent of iterateProjectAgentAssignments(state.project)) yield {
+		agent,
+		kind: "agent"
+	};
+};
+/** Preflights the complete logical prepared-state cost before retaining its collections. */
+var estimatePreparedProjectInspection = (state, baseCounts, maximum) => {
+	const retainedBeforePreparation = state.resourceUsage.retainedBytes;
+	let bytes = addRetainedBytes(0, PREPARED_FIXED_BYTES, retainedBeforePreparation, maximum);
+	let metadataCount = 0;
+	for (const item of iterateProjectInspectionItems(state)) {
+		const key = `${createItemBaseKey(item)}:0000000000`;
+		const encodedBytes = encoder.encode(key).byteLength + encoder.encode(serializeDeterministically(item)).byteLength;
+		bytes = addRetainedBytes(bytes, PREPARED_ITEM_FIXED_BYTES + encodedBytes * PREPARED_TEXT_BYTE_MULTIPLIER + PREPARED_VIEW_REFERENCE_BYTES, retainedBeforePreparation, maximum);
+		if (item.kind === "metadata") metadataCount += 1;
+	}
+	const counts = {
+		agents: baseCounts.agents,
+		context: baseCounts.context,
+		decisions: baseCounts.decisions,
+		diagnostics: baseCounts.diagnostics,
+		errors: baseCounts.errors,
+		coverage: baseCounts.coverage,
+		metadata: metadataCount,
+		mirrors: baseCounts.mirrors,
+		runtimes: baseCounts.runtimes,
+		unresolved: baseCounts.unresolved,
+		warnings: baseCounts.warnings,
+		acceptedWarnings: baseCounts.acceptedWarnings
+	};
+	bytes = addRetainedBytes(bytes, encoder.encode(serializeDeterministically({
+		counts,
+		formatVersion: state.result.formatVersion,
+		inspectionDigest: "sha256:0000000000000000000000000000000000000000000000000000000000000000",
+		source: state.result.source,
+		summary: state.result.summary,
+		valid: state.result.valid
+	})).byteLength * PREPARED_TEXT_BYTE_MULTIPLIER, retainedBeforePreparation, maximum);
+	return {
+		counts,
+		preparedBytes: bytes
+	};
+};
+/** Creates the inspection digest without materializing a project-sized key projection. */
+var createInspectionDigest = (counts, coverageCounts, formatVersion, items, summary, valid) => createIdentity((function* () {
+	yield "core7-prepared-inspection";
+	yield serializeDeterministically({
+		counts,
+		coverageCounts,
+		formatVersion,
+		summary,
+		valid
+	});
+	for (const { key } of items) yield key;
+})());
+var findStartIndex = (items, lastKey) => {
+	if (lastKey === null) return 0;
+	let lower = 0;
+	let upper = items.length - 1;
+	while (lower <= upper) {
+		const middle = lower + Math.floor((upper - lower) / 2);
+		const candidate = items[middle];
+		if (candidate === void 0) return invalidArgument();
+		if (candidate.key === lastKey) return middle + 1;
+		if (candidate.key < lastKey) lower = middle + 1;
+		else upper = middle - 1;
+	}
+	return invalidArgument();
+};
+/** Creates the returned inspection from content-free state only. */
+var createPreparedProjectInspection = (input) => {
+	const { counts, coverageCounts, formatVersion, items, maxEntries, preparedBytes, resourceUsage: validationUsage, source, summary, valid } = input;
+	const views = createViews(items);
+	const inspectionDigest = createInspectionDigest(counts, coverageCounts, formatVersion, items, summary, valid);
+	const resourceUsage = freezeRecursively({
+		canonicalBytes: validationUsage.canonicalBytes,
+		peakRetainedBytes: Math.max(validationUsage.peakRetainedBytes, validationUsage.retainedBytes + preparedBytes),
+		preparedBytes,
+		retainedBytes: preparedBytes,
+		totalBytesRead: validationUsage.totalBytesRead
+	});
+	const readPage = (pageInput) => {
+		if (typeof pageInput !== "object" || pageInput === null || Reflect.ownKeys(pageInput).some((key) => key !== "cursor" && key !== "maxItems" && key !== "view") || !Number.isSafeInteger(pageInput.maxItems) || pageInput.maxItems < 1 || pageInput.maxItems > maxEntries || pageInput.cursor !== void 0 && typeof pageInput.cursor !== "string" || pageInput.view !== "all" && pageInput.view !== "diagnostics" && pageInput.view !== "coverage" && pageInput.view !== "metadata") return invalidArgument();
+		const viewItems = views[pageInput.view];
+		const startIndex = findStartIndex(viewItems, decodeCursor(pageInput.cursor, inspectionDigest, pageInput.view));
+		const records = viewItems.slice(startIndex, startIndex + pageInput.maxItems).map(({ item, key }, index) => {
+			return {
+				item,
+				nextCursor: startIndex + index + 1 >= viewItems.length ? null : encodeCursor(inspectionDigest, pageInput.view, key)
+			};
+		});
+		const nextCursor = records.at(-1)?.nextCursor ?? null;
+		return freezeRecursively({
+			counts,
+			coverageCounts,
+			formatVersion,
+			inspectionDigest,
+			page: {
+				isComplete: nextCursor === null,
+				nextCursor,
+				records,
+				totalItems: viewItems.length
+			},
+			source,
+			summary,
+			valid,
+			view: pageInput.view
+		});
+	};
+	return freezeRecursively({
+		counts,
+		coverageCounts,
+		formatVersion,
+		inspectionDigest,
+		readPage,
+		resourceUsage,
+		source,
+		summary,
+		valid
+	});
+};
+/**
+* Prepares one immutable content-free inspection for synchronous bounded page reads.
+* @param input The source-neutral reader and optional cancellation signal.
+* @param options The immutable operation limits.
+* @returns A promise resolving to the complete prepared inspection.
+* @throws
+* - INVALID_ARGUMENT: The Core operation received an invalid argument.
+* - INVALID_REPOSITORY_PATH: The repository path is invalid.
+* - ENTRY_NOT_FOUND: The requested repository entry was not found.
+* - ENTRY_NOT_FILE: The requested repository entry is not a file.
+* - ENTRY_NOT_DIRECTORY: The requested repository entry is not a directory.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during the operation.
+* - PROVIDER_INCOMPLETE: The repository provider cannot expose a complete result.
+* - INVALID_SOURCE_DATA: The repository source returned invalid data.
+* - RESOURCE_LIMIT_EXCEEDED: A named repository resource limit was exceeded.
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+* - ABORTED: The repository operation was aborted.
+* - ABORTED: The Core operation was aborted.
+*/
+var createProjectInspection = async (input, options) => {
+	const state = await validateProjectState(input, options);
+	const estimate = estimatePreparedProjectInspection(state, {
+		agents: state.result.summary?.counts.agents ?? 0,
+		context: state.result.summary?.counts.context ?? 0,
+		decisions: state.result.summary?.counts.decisions ?? 0,
+		diagnostics: state.result.diagnostics.length,
+		errors: state.result.errorCount,
+		coverage: state.result.coverage.length,
+		mirrors: state.result.summary?.counts.mirrors ?? 0,
+		runtimes: state.result.summary?.counts.runtimes ?? 0,
+		unresolved: state.result.summary?.counts.unresolved ?? 0,
+		warnings: state.result.warningCount,
+		acceptedWarnings: state.result.acceptedWarningCount
+	}, options.limits.maxRetainedBytes);
+	const counts = freezeRecursively(estimate.counts);
+	const items = freezeRecursively(createKeyedItems(iterateProjectInspectionItems(state)));
+	return createPreparedProjectInspection({
+		counts,
+		coverageCounts: state.result.coverageCounts,
+		formatVersion: state.result.formatVersion,
+		items,
+		maxEntries: options.limits.maxEntries,
+		preparedBytes: estimate.preparedBytes,
+		resourceUsage: state.resourceUsage,
+		source: state.result.source,
+		summary: state.result.summary,
+		valid: state.result.valid
+	});
+};
+//#endregion
+//#region src/core/index.ts
+var core_exports = /* @__PURE__ */ __exportAll({ createCore: () => createCore });
+/**
+* Creates one immutable Core instance from detached configuration snapshots.
+* @param options Optional resource-limit overrides.
+* @returns A frozen Core instance safe for concurrent independent operations.
+* @throws
+* - INVALID_RESOURCE_LIMIT: A Core resource limit is invalid.
+*/
+var createCore = (options) => {
+	const snapshot = normalizeCoreOptions(options);
+	return freezeRecursively({
+		calculateContentDigest: (input) => {
+			const operation = createCoreOperationOptionsSnapshot(snapshot);
+			return calculateContentDigest(input, operation.limits);
+		},
+		createProjectInspection: (input) => createProjectInspection(input, createCoreOperationOptionsSnapshot(snapshot)),
+		validateProject: (input) => validateProject(input, createCoreOperationOptionsSnapshot(snapshot)),
+		matchManifestScope: (input) => matchManifestScope(input, createCoreOperationOptionsSnapshot(snapshot)),
+		normalizeText: (input) => {
+			const operation = createCoreOperationOptionsSnapshot(snapshot);
+			return normalizeTextDocument(input, operation.limits, "normalize-text");
+		},
+		parseDecision: (input) => parseDecisionDocument(input, createCoreOperationOptionsSnapshot(snapshot)),
+		parseManifest: (input) => parseManifestDocument(input, createCoreOperationOptionsSnapshot(snapshot)),
+		readCanonicalContentPage: (input) => readCanonicalContentPage(input, createCoreOperationOptionsSnapshot(snapshot))
+	});
+};
+//#endregion
+export { createCore as n, parseIntegrationBlock as r, core_exports as t };
+
+//# sourceMappingURL=core-Cdeiu6xG.js.map