@moldea.ai/core 1.0.0

package/dist/index.js

@@ -0,0 +1,4609 @@
+import { REPOSITORY_ROOT, RepositoryPathException, RepositorySourceException, isRepositoryPath, parseRepositoryPath } from "@moldea.ai/repository";
+import { Exception } from "error-message-utils";
+import { Parser, isAlias, isMap, isScalar, isSeq, parseAllDocuments } from "yaml";
+//#region src/constants/index.ts
+var RECOGNIZED_RUNTIME_ADAPTER_IDS = Object.freeze([
+	"anthropic",
+	"claude-agent-sdk",
+	"cloudflare-agents",
+	"custom",
+	"eve",
+	"google-genai",
+	"langchain",
+	"langgraph",
+	"openai",
+	"openai-agents-sdk",
+	"pydantic-ai",
+	"vercel-ai-sdk"
+]);
+var SUPPORTED_REPOSITORY_FORMAT_VERSIONS = Object.freeze([1]);
+var DEFAULT_CORE_RESOURCE_LIMITS = Object.freeze({
+	maxDiagnostics: 1e4,
+	maxEntries: 1e5,
+	maxEvidence: 1e4,
+	maxFileBytes: 8388608,
+	maxManifestBytes: 2097152,
+	maxTotalBytesRead: 134217728
+});
+//#endregion
+//#region src/exceptions/index.ts
+var CONFIGURATION_ERROR_MESSAGES = {
+	DUPLICATE_ADAPTER_ID: "A runtime adapter ID is registered more than once.",
+	INVALID_ADAPTER_DEFINITION: "A runtime adapter definition is invalid.",
+	INVALID_RESOURCE_LIMIT: "A Core resource limit is invalid.",
+	RESERVED_ADAPTER_ID: "A reserved runtime adapter ID was supplied."
+};
+var OPERATION_ERROR_MESSAGES = {
+	ABORTED: "The Core operation was aborted.",
+	ADAPTER_EXECUTION_FAILED: "A runtime adapter failed during inspection.",
+	INVALID_ARGUMENT: "The Core operation received an invalid argument.",
+	RESOURCE_LIMIT_EXCEEDED: "A Core resource limit was exceeded."
+};
+var OPERATION_ERROR_RETRYABILITY = {
+	ABORTED: true,
+	ADAPTER_EXECUTION_FAILED: false,
+	INVALID_ARGUMENT: false,
+	RESOURCE_LIMIT_EXCEEDED: false
+};
+var attachCause = (exception, cause) => {
+	if (cause === void 0) return;
+	Object.defineProperty(exception, "cause", {
+		configurable: true,
+		enumerable: false,
+		value: cause,
+		writable: false
+	});
+};
+/** Represents invalid immutable Core configuration. */
+var CoreConfigurationException = class extends Exception {
+	code;
+	operation;
+	adapterId;
+	/** Creates a configuration exception with safe adapter metadata. */
+	constructor(options) {
+		super(CONFIGURATION_ERROR_MESSAGES[options.code], options.code);
+		this.code = options.code;
+		this.name = "CoreConfigurationException";
+		this.operation = options.operation;
+		this.adapterId = options.adapterId ?? null;
+		attachCause(this, options.cause);
+	}
+};
+/** Represents an operational failure that prevented Core from completing. */
+var CoreOperationException = class extends Exception {
+	code;
+	operation;
+	retryable;
+	adapterId;
+	agentId;
+	limit;
+	/** Creates an operation exception with derived retry and safe scope metadata. */
+	constructor(options) {
+		super(OPERATION_ERROR_MESSAGES[options.code], options.code);
+		this.code = options.code;
+		this.name = "CoreOperationException";
+		this.operation = options.operation;
+		this.retryable = OPERATION_ERROR_RETRYABILITY[options.code];
+		this.adapterId = options.adapterId ?? null;
+		this.agentId = options.agentId ?? null;
+		this.limit = options.limit ?? null;
+		attachCause(this, options.cause);
+	}
+};
+//#endregion
+//#region src/format-validation/index.ts
+var STABLE_ID_PATTERN$1 = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+var VARIABLE_ID_PATTERN = /^[A-Z][A-Z0-9_]*$/u;
+var WINDOWS_RESERVED_ID_PATTERN$1 = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])$/u;
+var LINE_BREAK_CHARACTERS = [
+	"\n",
+	"\r",
+	"…",
+	"\u2028",
+	"\u2029"
+];
+var UNSUPPORTED_GLOB_PATTERN = /[!?[\]{}]/u;
+var hasLineBreak = (value) => {
+	return LINE_BREAK_CHARACTERS.some((lineBreak) => value.includes(lineBreak));
+};
+/** Determines whether a code point belongs to the Repository Format version 1 whitespace set. */
+var isRepositoryFormatWhitespace = (codePoint) => {
+	return codePoint >= 9 && codePoint <= 13 || codePoint === 32 || codePoint === 133 || codePoint === 160 || codePoint === 5760 || codePoint >= 8192 && codePoint <= 8202 || codePoint === 8232 || codePoint === 8233 || codePoint === 8239 || codePoint === 8287 || codePoint === 12288;
+};
+/** Compares strings by exact Unicode code-point order without locale behavior. */
+var compareExactStrings = (left, right) => {
+	const leftScalars = left[Symbol.iterator]();
+	const rightScalars = right[Symbol.iterator]();
+	while (true) {
+		const leftScalar = leftScalars.next();
+		const rightScalar = rightScalars.next();
+		if (leftScalar.done === true) return rightScalar.done === true ? 0 : -1;
+		if (rightScalar.done === true) return 1;
+		const leftCodePoint = leftScalar.value.codePointAt(0) ?? 0;
+		const rightCodePoint = rightScalar.value.codePointAt(0) ?? 0;
+		if (leftCodePoint !== rightCodePoint) return leftCodePoint < rightCodePoint ? -1 : 1;
+	}
+};
+/** Counts Unicode scalar values in valid JavaScript text. */
+var countUnicodeScalars$1 = (value) => {
+	const scalars = value[Symbol.iterator]();
+	let count = 0;
+	while (scalars.next().done !== true) count += 1;
+	return count;
+};
+/** Determines whether a JavaScript string contains only Unicode scalar values. */
+var isUnicodeScalarText = (value) => {
+	for (let index = 0; index < value.length; index += 1) {
+		const codeUnit = value.charCodeAt(index);
+		if (codeUnit >= 55296 && codeUnit <= 56319) {
+			if (index + 1 >= value.length) return false;
+			const nextCodeUnit = value.charCodeAt(index + 1);
+			if (nextCodeUnit < 56320 || nextCodeUnit > 57343) return false;
+			index += 1;
+			continue;
+		}
+		if (codeUnit >= 56320 && codeUnit <= 57343) return false;
+	}
+	return true;
+};
+/** Determines whether a value contains at least one non-whitespace scalar. */
+var hasNonWhitespace = (value) => {
+	for (const scalar of value) if (!isRepositoryFormatWhitespace(scalar.codePointAt(0) ?? 0)) return true;
+	return false;
+};
+/** Determines whether a value begins or ends with version 1 whitespace. */
+var hasSurroundingWhitespace = (value) => {
+	const firstCodePoint = value.codePointAt(0);
+	const lastCodePoint = value.codePointAt(value.length - 1);
+	return firstCodePoint !== void 0 && isRepositoryFormatWhitespace(firstCodePoint) || lastCodePoint !== void 0 && isRepositoryFormatWhitespace(lastCodePoint);
+};
+/** Removes only Repository Format version 1 whitespace from both edges. */
+var trimRepositoryFormatWhitespace = (value) => {
+	let start = 0;
+	let end = value.length;
+	while (start < end) {
+		const codePoint = value.codePointAt(start);
+		if (codePoint === void 0 || !isRepositoryFormatWhitespace(codePoint)) break;
+		start += codePoint > 65535 ? 2 : 1;
+	}
+	while (end > start) {
+		const codePoint = value.codePointAt(end - 1);
+		if (codePoint === void 0 || !isRepositoryFormatWhitespace(codePoint)) break;
+		end -= 1;
+	}
+	return value.slice(start, end);
+};
+/** Determines whether a string is non-empty and contains no line break. */
+var isNonEmptySingleLine = (value) => {
+	return value.length > 0 && !hasLineBreak(value);
+};
+/** Determines whether a value satisfies stable moldea ID syntax. */
+var isStableId$1 = (value) => {
+	return value.length <= 64 && STABLE_ID_PATTERN$1.test(value);
+};
+/** Determines whether an otherwise valid stable ID is filesystem-reserved. */
+var isReservedId = (value) => WINDOWS_RESERVED_ID_PATTERN$1.test(value);
+/** Determines whether a value satisfies runtime-variable ID syntax. */
+var isVariableId = (value) => {
+	return value.length <= 64 && VARIABLE_ID_PATTERN.test(value);
+};
+/** Determines whether a parsed capability description satisfies version 1 limits. */
+var isCapabilityDescription = (value) => {
+	const scalarLength = countUnicodeScalars$1(value);
+	return scalarLength >= 1 && scalarLength <= 1e3 && !hasSurroundingWhitespace(value) && !hasLineBreak(value) && !value.includes("\0") && !value.includes("{{") && !value.includes("}}");
+};
+/** Parses a non-root repository-format logical path without throwing. */
+var parseManifestPath = (value) => {
+	return value !== "/" && isRepositoryPath(value) ? parseRepositoryPath(value) : null;
+};
+/** Determines whether a path is the canonical manifest path. */
+var isCanonicalManifestPath = (path) => {
+	return path === "/moldea/moldea.yaml";
+};
+/** Extracts the stable millisecond ID from one canonical immediate decision path. */
+var parseDecisionIdFromPath = (path) => {
+	const match = /^\/moldea\/decisions\/(\d{13})-([a-z0-9]+(?:-[a-z0-9]+)*)\.md$/u.exec(path);
+	const id = match?.[1];
+	const slug = match?.[2];
+	return id !== void 0 && slug !== void 0 && isStableId$1(slug) ? id : null;
+};
+/** Determines whether a path is an allowed focused-context relationship key. */
+var isContextPath = (path, allowProject) => {
+	if (allowProject && path === "/moldea/project.md") return true;
+	return path.startsWith("/moldea/context/") && path.endsWith(".md");
+};
+/** Determines whether a path has the canonical immediate decision filename shape. */
+var isDecisionPath = (path) => {
+	return parseDecisionIdFromPath(path) !== null;
+};
+/** Determines whether a path is canonical runtime guidance. */
+var isRuntimeGuidancePath = (path) => {
+	return path.startsWith("/moldea/runtimes/") && path.endsWith(".md");
+};
+/** Determines whether a mirror path is outside canonical moldea content. */
+var isMirrorPath = (path) => {
+	return path !== "/moldea" && !path.startsWith("/moldea/");
+};
+/** Determines whether an impact path contains prohibited glob metacharacters. */
+var hasUnsupportedGlobMetacharacter = (value) => {
+	return UNSUPPORTED_GLOB_PATTERN.test(value);
+};
+/** Determines whether a string satisfies the version 1 simple-glob grammar. */
+var isSimpleGlob = (value) => {
+	if (hasUnsupportedGlobMetacharacter(value) || value.includes("***")) return false;
+	if (value.slice(1).split("/").some((segment) => segment.includes("**") && segment !== "**")) return false;
+	return value.includes("*") && isRepositoryPath(value.replaceAll("*", "x"));
+};
+/** Determines whether a repository-reference symbol has the common safe shape. */
+var isRepositorySymbol = (value) => {
+	return isNonEmptySingleLine(value) && !value.includes("\0");
+};
+/** Determines whether a canonical moldea reference incorrectly carries a symbol. */
+var isCanonicalMoldeaPath = (path) => {
+	return path === "/moldea" || path.startsWith("/moldea/");
+};
+/** Sorts repository references by path and then optional symbol. */
+var sortRepositoryReferences = (references) => {
+	return [...references].sort((left, right) => {
+		return compareExactStrings(left.path, right.path) || compareExactStrings(left.symbol ?? "", right.symbol ?? "");
+	});
+};
+//#endregion
+//#region src/immutable/index.ts
+/**
+* Recursively freezes a Core-owned value without cloning it.
+* @param value The detached acyclic value whose already-frozen objects are deeply frozen.
+* @returns The same value with every mutable reachable object frozen.
+*/
+var freezeRecursively = (value) => {
+	if (typeof value !== "object" || value === null || Object.isFrozen(value)) return value;
+	for (const key of Reflect.ownKeys(value)) {
+		const child = value[key];
+		freezeRecursively(child);
+	}
+	return Object.freeze(value);
+};
+/**
+* Creates a record that cannot collide with prototype-chain properties.
+* @param entries The own string-keyed entries to assign.
+* @returns A mutable null-prototype record for later normalization and freezing.
+*/
+var createNullPrototypeRecord = (entries) => {
+	const record = Object.create(null);
+	for (const [key, value] of entries) record[key] = value;
+	return record;
+};
+//#endregion
+//#region src/diagnostic-utilities/index.ts
+var CORE_DIAGNOSTIC_MESSAGES = {
+	MOLDEA_AGENT_DESCRIPTION_INVALID: "The agent description is invalid.",
+	MOLDEA_AGENT_DESCRIPTION_MISSING: "The agent description is missing.",
+	MOLDEA_AGENT_DIRECTORY_MISSING: "The registered agent directory is missing.",
+	MOLDEA_AGENT_DIRECTORY_UNREGISTERED: "The agent directory is not registered.",
+	MOLDEA_AGENT_HANDOFF_DESCRIPTION_INVALID: "The agent handoff description is invalid.",
+	MOLDEA_AGENT_IDENTITY_INVALID: "The agent instruction identity is invalid.",
+	MOLDEA_AGENT_INSTRUCTION_EMPTY: "The agent instruction is empty.",
+	MOLDEA_AGENT_INSTRUCTION_MISSING: "The agent instruction is missing.",
+	MOLDEA_CANONICAL_ASSET_SYMLINK: "The canonical asset is a symlink.",
+	MOLDEA_CANONICAL_PATH_UNRECOGNIZED: "The canonical path is unrecognized.",
+	MOLDEA_CAPABILITY_DESCRIPTION_INVALID: "The capability description is invalid.",
+	MOLDEA_CAPABILITY_DESCRIPTION_MISSING: "The capability description is missing.",
+	MOLDEA_CONTEXT_FILE_EMPTY: "The focused context file is empty.",
+	MOLDEA_CONTEXT_PATH_INVALID: "The context relationship path is invalid.",
+	MOLDEA_CONTEXT_RELATIONSHIP_EMPTY: "The declared relationship has no bindings or impact paths.",
+	MOLDEA_DECISION_BODY_EMPTY: "The decision Markdown body is empty.",
+	MOLDEA_DECISION_CREATED_AT_INVALID: "The decision createdAt value is invalid.",
+	MOLDEA_DECISION_FILENAME_INVALID: "The decision path or filename is invalid.",
+	MOLDEA_DECISION_FRONTMATTER_INVALID: "The decision frontmatter is invalid.",
+	MOLDEA_DECISION_FRONTMATTER_MISSING: "The decision frontmatter or its delimiters are missing.",
+	MOLDEA_DECISION_ID_DUPLICATE: "The decision ID is duplicated.",
+	MOLDEA_DECISION_PROPERTY_UNKNOWN: "The decision frontmatter contains an unknown property.",
+	MOLDEA_DECISION_REFERENCE_MISSING: "The referenced decision does not exist.",
+	MOLDEA_DECISION_RELATIONSHIP_INACTIVE: "The referenced decision is not accepted.",
+	MOLDEA_DECISION_SELF_SUPERSESSION: "The decision supersedes itself.",
+	MOLDEA_DECISION_STATUS_INVALID: "The decision status is invalid.",
+	MOLDEA_DECISION_SUPERSEDED_ORPHAN: "The superseded decision has no active supersession relationship.",
+	MOLDEA_DECISION_SUPERSESSION_CYCLE: "The decision supersession graph contains a cycle.",
+	MOLDEA_DECISION_SUPERSESSION_STATUS_INVALID: "The decision supersession relationship has inconsistent statuses.",
+	MOLDEA_DECISION_TIMESTAMP_MISMATCH: "The decision filename timestamp and createdAt value do not match.",
+	MOLDEA_ENTRY_TYPE_INVALID: "The repository entry type is invalid.",
+	MOLDEA_RUNTIME_ADAPTER_FORMAT_UNSUPPORTED: "The configured runtime adapter does not support the repository format version.",
+	MOLDEA_RUNTIME_ADAPTER_UNAVAILABLE: "The declared runtime adapter is unavailable.",
+	MOLDEA_RUNTIME_ID_INVALID: "The runtime adapter ID is invalid.",
+	MOLDEA_GLOB_INVALID: "The impact pattern is invalid.",
+	MOLDEA_ID_DUPLICATE: "An ID is duplicated within its required scope.",
+	MOLDEA_ID_INVALID: "The ID is invalid.",
+	MOLDEA_ID_RESERVED: "The ID uses a reserved filesystem name.",
+	MOLDEA_IMPACT_PATH_MISSING: "The exact impact path does not exist.",
+	MOLDEA_IMPACT_PATH_NOT_FILE: "The exact impact path is not a regular file.",
+	MOLDEA_MANIFEST_MISSING: "The project manifest is missing.",
+	MOLDEA_MANIFEST_PATH_INVALID: "The manifest path is not the canonical manifest path.",
+	MOLDEA_MANIFEST_PROPERTY_UNKNOWN: "The manifest contains an unknown property.",
+	MOLDEA_MANIFEST_ROOT_INVALID: "The manifest root is not a mapping.",
+	MOLDEA_MANIFEST_VALUE_INVALID: "The manifest value is invalid.",
+	MOLDEA_MANIFEST_VERSION_INVALID: "The manifest version is not a valid integer major version.",
+	MOLDEA_MANIFEST_VERSION_MISSING: "The manifest version is missing.",
+	MOLDEA_MANIFEST_VERSION_UNSUPPORTED: "The manifest version is unsupported.",
+	MOLDEA_MIRROR_PATH_DUPLICATE: "The mirror path is assigned more than once.",
+	MOLDEA_MIRROR_PATH_INSIDE_MOLDEA: "The mirror path is inside /moldea.",
+	MOLDEA_MIRROR_PATH_INVALID: "The mirror path is invalid.",
+	MOLDEA_MIRROR_MISSING: "The declared mirror does not exist.",
+	MOLDEA_MIRROR_NOT_FILE: "The declared mirror is not a regular file.",
+	MOLDEA_MIRROR_STALE: "The declared mirror differs from its canonical instruction.",
+	MOLDEA_MIRROR_SYMLINK: "The declared mirror is a symlink.",
+	MOLDEA_PATH_DUPLICATE: "The path is duplicated.",
+	MOLDEA_PATH_INVALID: "The manifest logical path is invalid.",
+	MOLDEA_PATTERN_DUPLICATE: "The impact pattern is duplicated.",
+	MOLDEA_PROJECT_FILE_EMPTY: "The project file is empty.",
+	MOLDEA_PROJECT_FILE_MISSING: "The project file is missing.",
+	MOLDEA_REFERENCE_MISSING: "The referenced repository path does not exist.",
+	MOLDEA_REFERENCE_NOT_FILE: "The referenced repository path is not a regular file.",
+	MOLDEA_REFERENCE_SYMLINK: "The referenced repository path is a symlink.",
+	MOLDEA_RUNTIME_GUIDANCE_EMPTY: "The runtime guidance is empty.",
+	MOLDEA_RUNTIME_GUIDANCE_MISSING: "The referenced runtime guidance does not exist.",
+	MOLDEA_SKILL_IMPLEMENTATION_MISSING: "The registered skill implementation is missing.",
+	MOLDEA_SYMBOL_FORBIDDEN: "A canonical moldea reference must not include a symbol.",
+	MOLDEA_SYMBOL_INVALID: "The repository-reference symbol is invalid.",
+	MOLDEA_TEXT_EMPTY: "The required text document is empty.",
+	MOLDEA_TEXT_INVALID_UNICODE: "The text document contains an invalid Unicode scalar representation.",
+	MOLDEA_TEXT_INVALID_UTF8: "The text document is not valid UTF-8.",
+	MOLDEA_TEXT_NUL_FORBIDDEN: "The text document contains a forbidden NUL character.",
+	MOLDEA_TOOL_IMPLEMENTATION_MISSING: "The registered tool implementation is missing.",
+	MOLDEA_VARIABLE_ID_INVALID: "The runtime-variable ID is invalid.",
+	MOLDEA_VARIABLE_PLACEHOLDER_MALFORMED: "The agent instruction contains a malformed runtime-variable placeholder.",
+	MOLDEA_VARIABLE_PROVIDER_UNDECLARED: "A variable-provider binding exists for an undeclared variable.",
+	MOLDEA_VARIABLE_UNDECLARED: "The agent instruction references an undeclared runtime variable.",
+	MOLDEA_VARIABLE_UNUSED: "The declared runtime variable is unused by the agent instruction.",
+	MOLDEA_YAML_DUPLICATE_KEY: "The YAML document contains a duplicate mapping key.",
+	MOLDEA_YAML_FEATURE_UNSUPPORTED: "The YAML document uses an unsupported feature.",
+	MOLDEA_YAML_MALFORMED: "The YAML document is malformed.",
+	MOLDEA_YAML_MULTIPLE_DOCUMENTS: "The YAML stream contains more than one document."
+};
+var ENTITY_KEYS = [
+	"agentId",
+	"capabilityKind",
+	"capabilityId",
+	"decisionId",
+	"variableId",
+	"adapterId"
+];
+var CORE_DIAGNOSTIC_BUDGET = Symbol("core-diagnostic-budget");
+/** Creates a detached limits view with one diagnostic budget for a complete Core operation. */
+var createCoreOperationResourceLimits = (limits) => {
+	if (limits[CORE_DIAGNOSTIC_BUDGET] !== void 0) return limits;
+	return Object.freeze({
+		...limits,
+		[CORE_DIAGNOSTIC_BUDGET]: { count: 0 }
+	});
+};
+/** Registers raw diagnostics against the shared operation budget before normalization. */
+var registerCoreDiagnosticCandidates = (limits, amount, operation, fallbackCount = 0, adapterId) => {
+	const budget = limits[CORE_DIAGNOSTIC_BUDGET];
+	const currentCount = budget?.count ?? fallbackCount;
+	if (amount > limits.maxDiagnostics - currentCount) throw new CoreOperationException({
+		...adapterId === void 0 ? {} : { adapterId },
+		code: "RESOURCE_LIMIT_EXCEEDED",
+		limit: "maxDiagnostics",
+		operation
+	});
+	if (budget !== void 0) budget.count += amount;
+	return fallbackCount + amount;
+};
+var compareNullableStrings$2 = (left, right) => {
+	if (left === null) return right === null ? 0 : -1;
+	return right === null ? 1 : compareExactStrings(left, right);
+};
+/**
+* Normalizes trusted JSON-scalar diagnostic metadata.
+* @param details The optional detached metadata record.
+* @returns A frozen null-prototype record with canonical key order.
+*/
+var normalizeDiagnosticDetails = (details) => {
+	return freezeRecursively(createNullPrototypeRecord(Object.entries(details ?? {}).sort(([left], [right]) => compareExactStrings(left, right)).map(([key, value]) => [key, typeof value === "number" && Object.is(value, -0) ? 0 : value])));
+};
+/**
+* Normalizes a trusted diagnostic entity into canonical key order.
+* @param entity The optional diagnostic entity.
+* @returns The frozen normalized entity or `null`.
+*/
+var normalizeDiagnosticEntity = (entity) => {
+	if (entity === void 0 || entity === null) return null;
+	return freezeRecursively(createNullPrototypeRecord(ENTITY_KEYS.flatMap((key) => {
+		const value = entity[key];
+		return value === void 0 ? [] : [[key, value]];
+	})));
+};
+/** Serializes unordered diagnostic details with explicit exact-code-point key ordering. */
+var serializeDiagnosticDetails = (details) => {
+	const entries = Object.entries(details).sort(([left], [right]) => compareExactStrings(left, right));
+	return JSON.stringify(entries);
+};
+var serializeDiagnostic = (diagnostic) => {
+	const entity = diagnostic.entity === null ? null : ENTITY_KEYS.map((key) => [key, diagnostic.entity?.[key] ?? null]);
+	const range = diagnostic.range === null ? null : [
+		diagnostic.range.start.line,
+		diagnostic.range.start.column,
+		diagnostic.range.start.offset,
+		diagnostic.range.end.line,
+		diagnostic.range.end.column,
+		diagnostic.range.end.offset
+	];
+	return JSON.stringify([
+		diagnostic.code,
+		serializeDiagnosticDetails(diagnostic.details),
+		entity,
+		diagnostic.message,
+		diagnostic.path,
+		diagnostic.pointer,
+		range,
+		diagnostic.source
+	]);
+};
+var compareRanges = (left, right) => {
+	if (left === null) return right === null ? 0 : -1;
+	if (right === null) return 1;
+	return left.start.line - right.start.line || left.start.column - right.start.column || left.start.offset - right.start.offset || left.end.line - right.end.line || left.end.column - right.end.column || left.end.offset - right.end.offset;
+};
+var readEntityValue = (entity, key) => {
+	return entity?.[key] ?? "";
+};
+var compareDiagnostics = (left, right) => {
+	return compareNullableStrings$2(left.path, right.path) || compareRanges(left.range, right.range) || compareNullableStrings$2(left.pointer, right.pointer) || compareExactStrings(left.source, right.source) || compareExactStrings(left.code, right.code) || compareExactStrings(readEntityValue(left.entity, "agentId"), readEntityValue(right.entity, "agentId")) || compareExactStrings(readEntityValue(left.entity, "capabilityKind"), readEntityValue(right.entity, "capabilityKind")) || compareExactStrings(readEntityValue(left.entity, "capabilityId"), readEntityValue(right.entity, "capabilityId")) || compareExactStrings(readEntityValue(left.entity, "decisionId"), readEntityValue(right.entity, "decisionId")) || compareExactStrings(readEntityValue(left.entity, "variableId"), readEntityValue(right.entity, "variableId")) || compareExactStrings(readEntityValue(left.entity, "adapterId"), readEntityValue(right.entity, "adapterId")) || compareExactStrings(serializeDiagnosticDetails(left.details), serializeDiagnosticDetails(right.details)) || compareExactStrings(left.message, right.message);
+};
+/**
+* Creates one normalized, immutable Core diagnostic.
+* @param input The trusted Core-owned diagnostic fields to normalize.
+* @returns A deeply immutable public diagnostic value.
+*/
+var createCoreDiagnostic = (input) => {
+	const message = CORE_DIAGNOSTIC_MESSAGES[input.code];
+	if (message === void 0) throw new TypeError("The requested Core diagnostic is not implemented.");
+	return freezeRecursively({
+		code: input.code,
+		details: normalizeDiagnosticDetails(input.details),
+		entity: normalizeDiagnosticEntity(input.entity),
+		message,
+		path: input.path,
+		pointer: input.pointer ?? null,
+		range: input.range ?? null,
+		source: "core"
+	});
+};
+/**
+* Deduplicates and sorts already-normalized Core and adapter diagnostics.
+* @param candidates The immutable diagnostics to combine.
+* @returns A frozen deterministic diagnostic collection.
+*/
+var normalizeDiagnostics = (candidates) => {
+	const diagnostics = /* @__PURE__ */ new Map();
+	for (const diagnostic of candidates) {
+		const key = serializeDiagnostic(diagnostic);
+		if (diagnostics.has(key)) continue;
+		diagnostics.set(key, diagnostic);
+	}
+	return freezeRecursively([...diagnostics.values()].sort(compareDiagnostics));
+};
+/**
+* Creates a deterministic, deduplicating diagnostic collector for one operation.
+* @param limits The Core resource limits governing diagnostic output.
+* @param operation The operation reported by resource failures.
+* @returns A collector that freezes and sorts its final diagnostic array.
+*/
+var createCoreDiagnosticCollector = (limits, operation) => {
+	const diagnostics = /* @__PURE__ */ new Map();
+	let proposalCount = 0;
+	let fallbackRawCount = 0;
+	const retain = (input) => {
+		const diagnostic = createCoreDiagnostic(input);
+		const key = serializeDiagnostic(diagnostic);
+		proposalCount += 1;
+		if (!diagnostics.has(key)) diagnostics.set(key, diagnostic);
+	};
+	return {
+		add: (input) => {
+			fallbackRawCount = registerCoreDiagnosticCandidates(limits, 1, operation, fallbackRawCount);
+			retain(input);
+		},
+		merge: retain,
+		finalize: () => normalizeDiagnostics([...diagnostics.values()]),
+		get size() {
+			return proposalCount;
+		}
+	};
+};
+/**
+* Escapes one JSON Pointer reference token.
+* @param value The decoded mapping key or array index token.
+* @returns The RFC 6901 escaped token.
+*/
+var escapeJsonPointerSegment = (value) => {
+	return value.replaceAll("~", "~0").replaceAll("/", "~1");
+};
+//#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$1 = (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$1(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/options/index.ts
+/** Creates an operation-local options view with one shared raw-diagnostic budget. */
+var createCoreOperationOptionsSnapshot = (options) => {
+	return Object.freeze({
+		adapters: options.adapters,
+		limits: createCoreOperationResourceLimits(options.limits)
+	});
+};
+var RESOURCE_LIMIT_KEYS = [
+	"maxEntries",
+	"maxTotalBytesRead",
+	"maxFileBytes",
+	"maxManifestBytes",
+	"maxDiagnostics",
+	"maxEvidence"
+];
+var STABLE_ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/u;
+var WINDOWS_RESERVED_ID_PATTERN = /^(?:con|prn|aux|nul|com[1-9]|lpt[1-9])$/u;
+var compareStrings = (left, right) => {
+	if (left < right) return -1;
+	if (left > right) return 1;
+	return 0;
+};
+var invalidAdapter = (adapterId) => {
+	throw new CoreConfigurationException({
+		...adapterId === void 0 ? {} : { adapterId },
+		code: "INVALID_ADAPTER_DEFINITION",
+		operation: "create-core"
+	});
+};
+var isRecord$3 = (value) => {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+var isStableId = (value) => {
+	return value.length >= 1 && value.length <= 64 && STABLE_ID_PATTERN.test(value);
+};
+/**
+* Validates, copies, fills, and freezes all configured resource limits.
+* @param candidate The untrusted optional limit overrides.
+* @returns The complete frozen resource limits.
+* @throws
+* - INVALID_RESOURCE_LIMIT: A Core resource limit is invalid.
+*/
+var normalizeLimits = (candidate) => {
+	if (candidate === void 0) return DEFAULT_CORE_RESOURCE_LIMITS;
+	if (!isRecord$3(candidate)) throw new CoreConfigurationException({
+		code: "INVALID_RESOURCE_LIMIT",
+		operation: "create-core"
+	});
+	const knownKeys = new Set(RESOURCE_LIMIT_KEYS);
+	if (Object.keys(candidate).some((key) => !knownKeys.has(key))) throw new CoreConfigurationException({
+		code: "INVALID_RESOURCE_LIMIT",
+		operation: "create-core"
+	});
+	const normalized = { ...DEFAULT_CORE_RESOURCE_LIMITS };
+	for (const key of RESOURCE_LIMIT_KEYS) {
+		const value = candidate[key];
+		if (value === void 0) continue;
+		if (!Number.isSafeInteger(value) || value <= 0) throw new CoreConfigurationException({
+			code: "INVALID_RESOURCE_LIMIT",
+			operation: "create-core"
+		});
+		normalized[key] = value;
+	}
+	return freezeRecursively(normalized);
+};
+/**
+* Snapshots one adapter definition without freezing caller-owned state.
+* @param candidate The untrusted adapter definition.
+* @returns A frozen detached adapter snapshot.
+* @throws
+* - RESERVED_ADAPTER_ID: A reserved runtime adapter ID was supplied.
+* - INVALID_ADAPTER_DEFINITION: A runtime adapter definition is invalid.
+*/
+var normalizeAdapter = (candidate) => {
+	if (!isRecord$3(candidate)) return invalidAdapter();
+	const id = candidate["id"];
+	if (typeof id !== "string" || !isStableId(id) || WINDOWS_RESERVED_ID_PATTERN.test(id)) return invalidAdapter();
+	if (id === "custom") throw new CoreConfigurationException({
+		adapterId: id,
+		code: "RESERVED_ADAPTER_ID",
+		operation: "create-core"
+	});
+	if (!RECOGNIZED_RUNTIME_ADAPTER_IDS.includes(id)) return invalidAdapter(id);
+	const versions = candidate["supportedRepositoryFormatVersions"];
+	const inspect = candidate["inspect"];
+	if (!Array.isArray(versions) || versions.length === 0 || typeof inspect !== "function") return invalidAdapter(id);
+	const supportedVersions = /* @__PURE__ */ new Set();
+	for (const version of versions) {
+		if (!SUPPORTED_REPOSITORY_FORMAT_VERSIONS.includes(version) || supportedVersions.has(version)) return invalidAdapter(id);
+		supportedVersions.add(version);
+	}
+	const inspectReference = inspect;
+	return freezeRecursively({
+		id,
+		inspect: async (context) => inspectReference.call(candidate, context),
+		supportedRepositoryFormatVersions: [...supportedVersions].sort((left, right) => left - right)
+	});
+};
+/**
+* Validates, snapshots, and deterministically sorts the configured adapter registry.
+* @param candidate The untrusted optional adapter definitions.
+* @returns The frozen adapter snapshots in canonical ID order.
+* @throws
+* - DUPLICATE_ADAPTER_ID: A runtime adapter ID is registered more than once.
+* - RESERVED_ADAPTER_ID: A reserved runtime adapter ID was supplied.
+* - INVALID_ADAPTER_DEFINITION: A runtime adapter definition is invalid.
+*/
+var normalizeAdapters = (candidate) => {
+	if (candidate === void 0) return Object.freeze([]);
+	if (!Array.isArray(candidate)) return invalidAdapter();
+	const adapters = Array.from(candidate, (adapter) => normalizeAdapter(adapter));
+	const ids = /* @__PURE__ */ new Set();
+	for (const adapter of adapters) {
+		if (ids.has(adapter.id)) throw new CoreConfigurationException({
+			adapterId: adapter.id,
+			code: "DUPLICATE_ADAPTER_ID",
+			operation: "create-core"
+		});
+		ids.add(adapter.id);
+	}
+	return freezeRecursively(adapters.sort((left, right) => compareStrings(left.id, right.id)));
+};
+/**
+* Validates and snapshots caller-owned Core construction options.
+* @param options The optional adapters and resource-limit overrides.
+* @returns A deeply frozen, deterministically ordered configuration snapshot.
+* @throws
+* - DUPLICATE_ADAPTER_ID: A runtime adapter ID is registered more than once.
+* - RESERVED_ADAPTER_ID: A reserved runtime adapter ID was supplied.
+* - INVALID_ADAPTER_DEFINITION: A runtime adapter definition is invalid.
+* - INVALID_RESOURCE_LIMIT: A Core resource limit is invalid.
+*/
+var normalizeCoreOptions = (options) => {
+	if (options !== void 0 && !isRecord$3(options)) return invalidAdapter();
+	return freezeRecursively({
+		adapters: normalizeAdapters(options?.["adapters"]),
+		limits: normalizeLimits(options?.["limits"])
+	});
+};
+//#endregion
+//#region src/source-location/index.ts
+var findLineIndex = (lineStarts, offset) => {
+	let lower = 0;
+	let upper = lineStarts.length - 1;
+	while (lower < upper) {
+		const middle = Math.ceil((lower + upper) / 2);
+		if ((lineStarts[middle] ?? 0) <= offset) lower = middle;
+		else upper = middle - 1;
+	}
+	return lower;
+};
+/**
+* Creates an efficient UTF-16-offset to Unicode-scalar source locator.
+* @param value The already-normalized valid Unicode scalar text.
+* @returns A locator producing one-based lines and columns with zero-based scalar offsets.
+*/
+var createSourceLocator = (value) => {
+	const scalarOffsets = new Uint32Array(value.length + 1);
+	const lineStarts = [0];
+	let scalarOffset = 0;
+	for (let codeUnitOffset = 0; codeUnitOffset < value.length;) {
+		const codePoint = value.codePointAt(codeUnitOffset);
+		const width = codePoint !== void 0 && codePoint > 65535 ? 2 : 1;
+		scalarOffsets[codeUnitOffset] = scalarOffset;
+		for (let interiorOffset = 1; interiorOffset < width; interiorOffset += 1) scalarOffsets[codeUnitOffset + interiorOffset] = scalarOffset;
+		codeUnitOffset += width;
+		scalarOffset += 1;
+		scalarOffsets[codeUnitOffset] = scalarOffset;
+		if (codePoint === 10) lineStarts.push(codeUnitOffset);
+	}
+	const locatePosition = (candidateOffset) => {
+		const codeUnitOffset = Math.max(0, Math.min(value.length, candidateOffset));
+		const lineIndex = findLineIndex(lineStarts, codeUnitOffset);
+		const lineStart = lineStarts[lineIndex] ?? 0;
+		const positionScalarOffset = scalarOffsets[codeUnitOffset] ?? 0;
+		return {
+			column: positionScalarOffset - (scalarOffsets[lineStart] ?? 0) + 1,
+			line: lineIndex + 1,
+			offset: positionScalarOffset
+		};
+	};
+	return Object.freeze({ locateRange: (startOffset, endOffset) => ({
+		end: locatePosition(endOffset),
+		start: locatePosition(startOffset)
+	}) });
+};
+//#endregion
+//#region src/text/index.ts
+var encoder = new TextEncoder();
+var decoder = new TextDecoder("utf-8", {
+	fatal: true,
+	ignoreBOM: true
+});
+var isRecord$2 = (value) => {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+/**
+* Measures valid scalar UTF-8 bytes and stops once the operation budget is exceeded.
+* @param value The decoded string to measure without lossy replacement.
+* @param maximumByteLength The threshold after which measurement may stop early.
+* @returns The measured bytes, a value above the threshold, or `null` for invalid Unicode.
+*/
+var measureScalarUtf8ByteLength = (value, maximumByteLength) => {
+	let byteLength = 0;
+	for (let index = 0; index < value.length; index += 1) {
+		const codeUnit = value.charCodeAt(index);
+		if (codeUnit >= 55296 && codeUnit <= 56319) {
+			if (index + 1 >= value.length) return null;
+			const nextCodeUnit = value.charCodeAt(index + 1);
+			if (nextCodeUnit < 56320 || nextCodeUnit > 57343) return null;
+			byteLength += 4;
+			if (byteLength > maximumByteLength) return byteLength;
+			index += 1;
+			continue;
+		}
+		if (codeUnit >= 56320 && codeUnit <= 57343) return null;
+		byteLength += codeUnit <= 127 ? 1 : codeUnit <= 2047 ? 2 : 3;
+		if (byteLength > maximumByteLength) return byteLength;
+	}
+	return byteLength;
+};
+var countUnicodeScalars = (value) => {
+	let count = 0;
+	for (let index = 0; index < value.length; count += 1) {
+		const codePoint = value.codePointAt(index);
+		if (codePoint === void 0) break;
+		index += codePoint > 65535 ? 2 : 1;
+	}
+	return count;
+};
+/**
+* Collects every normalized NUL location or rejects when the diagnostic budget is exhausted.
+* @param value The normalized scalar text to inspect.
+* @param path The logical document path attached to each diagnostic.
+* @param diagnostics The operation collector receiving every NUL diagnostic.
+* @throws
+* - RESOURCE_LIMIT_EXCEEDED: A Core resource limit was exceeded.
+*/
+var collectNulDiagnostics = (value, path, diagnostics) => {
+	let column = 1;
+	let line = 1;
+	let offset = 0;
+	for (const scalar of value) {
+		if (scalar === "\0") diagnostics.add({
+			code: "MOLDEA_TEXT_NUL_FORBIDDEN",
+			path,
+			range: {
+				end: {
+					column: column + 1,
+					line,
+					offset: offset + 1
+				},
+				start: {
+					column,
+					line,
+					offset
+				}
+			}
+		});
+		if (scalar === "\n") {
+			column = 1;
+			line += 1;
+		} else column += 1;
+		offset += 1;
+	}
+};
+var invalidArgument$1 = (operation) => {
+	throw new CoreOperationException({
+		code: "INVALID_ARGUMENT",
+		operation
+	});
+};
+var enforceFileLimit = (byteLength, limits, operation, limit) => {
+	if (byteLength <= limits[limit]) return;
+	throw new CoreOperationException({
+		code: "RESOURCE_LIMIT_EXCEEDED",
+		limit,
+		operation
+	});
+};
+var invalidResult = (diagnostics) => {
+	return freezeRecursively({
+		diagnostics: [...diagnostics],
+		text: null,
+		valid: false
+	});
+};
+/**
+* Validates one public text input, enforces its source-byte budget, and decodes strict UTF-8.
+* @param input The untrusted public text-document input.
+* @param limits The immutable Core resource limits.
+* @param operation The public operation requesting the input.
+* @param limit The source-byte limit applied by the operation.
+* @param diagnostics The operation collector receiving text diagnostics.
+* @returns Decoded text or a frozen structural failure 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 readInput = (input, limits, operation, limit, diagnostics) => {
+	if (!isRecord$2(input)) return invalidArgument$1(operation);
+	const pathCandidate = input["path"];
+	const content = input["content"];
+	if (typeof pathCandidate !== "string" || typeof content !== "string" && !(content instanceof Uint8Array)) return invalidArgument$1(operation);
+	const path = parseRepositoryPath(pathCandidate);
+	if (typeof content === "string") {
+		const byteLength = measureScalarUtf8ByteLength(content, limits[limit]);
+		if (byteLength === null) {
+			diagnostics.add({
+				code: "MOLDEA_TEXT_INVALID_UNICODE",
+				path
+			});
+			return invalidResult(diagnostics.finalize());
+		}
+		enforceFileLimit(byteLength, limits, operation, limit);
+		return {
+			path,
+			value: content
+		};
+	}
+	enforceFileLimit(content.byteLength, limits, operation, limit);
+	const bytes = new Uint8Array(content);
+	try {
+		return {
+			path,
+			value: decoder.decode(bytes)
+		};
+	} catch {
+		diagnostics.add({
+			code: "MOLDEA_TEXT_INVALID_UTF8",
+			path
+		});
+		return invalidResult(diagnostics.finalize());
+	}
+};
+/**
+* Validates and normalizes one text document under an operation-specific resource budget.
+* @param input The logical path and decoded string or exact source bytes.
+* @param limits The immutable Core resource limits.
+* @param operation The public Core operation requesting normalization.
+* @param limit The source-byte limit applied by the operation.
+* @returns A frozen normalized result or structural text diagnostics.
+* @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 normalizeTextDocument = (input, limits, operation, limit = "maxFileBytes") => {
+	const diagnostics = createCoreDiagnosticCollector(limits, operation);
+	const decoded = readInput(input, limits, operation, limit, diagnostics);
+	if ("valid" in decoded) return decoded;
+	const value = (decoded.value.startsWith("") ? decoded.value.slice(1) : decoded.value).replace(/\r\n?/gu, "\n");
+	collectNulDiagnostics(value, decoded.path, diagnostics);
+	if (diagnostics.size > 0) return invalidResult(diagnostics.finalize());
+	return freezeRecursively({
+		diagnostics: [],
+		text: freezeRecursively({
+			scalarLength: countUnicodeScalars(value),
+			utf8ByteLength: encoder.encode(value).byteLength,
+			value
+		}),
+		valid: true
+	});
+};
+var toLowercaseHex = (bytes) => {
+	let value = "";
+	for (const byte of bytes) value += byte.toString(16).padStart(2, "0");
+	return value;
+};
+/**
+* Calculates the canonical digest for already-normalized text.
+* @param text The validated normalized text to encode and hash.
+* @returns A promise resolving to the canonical lowercase SHA-256 digest.
+*/
+var calculateNormalizedTextDigest = async (text) => {
+	const bytes = encoder.encode(text.value);
+	return `sha256:${toLowercaseHex(new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", bytes)))}`;
+};
+/**
+* Calculates the normalized SHA-256 digest for one text document.
+* @param input The logical path and decoded string or exact source bytes.
+* @param limits The immutable Core resource limits.
+* @returns A promise resolving to a frozen digest result or structural text diagnostics.
+* @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 calculateContentDigest = async (input, limits) => {
+	const normalized = normalizeTextDocument(input, limits, "calculate-content-digest");
+	if (!normalized.valid || normalized.text === null) return freezeRecursively({
+		diagnostics: normalized.diagnostics,
+		digest: null,
+		text: null,
+		valid: false
+	});
+	return freezeRecursively({
+		diagnostics: [],
+		digest: await calculateNormalizedTextDigest(normalized.text),
+		text: normalized.text,
+		valid: true
+	});
+};
+//#endregion
+//#region src/yaml/index.ts
+var CORE_TAGS = /* @__PURE__ */ new Set([
+	"tag:yaml.org,2002:bool",
+	"tag:yaml.org,2002:float",
+	"tag:yaml.org,2002:int",
+	"tag:yaml.org,2002:map",
+	"tag:yaml.org,2002:null",
+	"tag:yaml.org,2002:seq",
+	"tag:yaml.org,2002:str"
+]);
+var toRange = (range, locator) => {
+	return locator.locateRange(range?.[0] ?? 0, range?.[1] ?? range?.[0] ?? 0);
+};
+var addUnsupportedFeature = (diagnostics, path, range, reason) => {
+	diagnostics.add({
+		code: "MOLDEA_YAML_FEATURE_UNSUPPORTED",
+		details: { reason },
+		path,
+		range
+	});
+};
+var isUnicodeScalarString = (value) => {
+	for (let index = 0; index < value.length; index += 1) {
+		const codeUnit = value.charCodeAt(index);
+		if (codeUnit >= 55296 && codeUnit <= 56319) {
+			const nextCodeUnit = value.charCodeAt(index + 1);
+			if (!(nextCodeUnit >= 56320 && nextCodeUnit <= 57343)) return false;
+			index += 1;
+		} else if (codeUnit >= 56320 && codeUnit <= 57343) return false;
+	}
+	return true;
+};
+var isCoreTagCompatible = (node) => {
+	switch (node.tag) {
+		case "tag:yaml.org,2002:bool": return isScalar(node) && typeof node.value === "boolean";
+		case "tag:yaml.org,2002:float": return isScalar(node) && typeof node.value === "number";
+		case "tag:yaml.org,2002:int": return isScalar(node) && typeof node.value === "bigint";
+		case "tag:yaml.org,2002:map": return isMap(node);
+		case "tag:yaml.org,2002:null": return isScalar(node) && node.value === null;
+		case "tag:yaml.org,2002:seq": return isSeq(node);
+		case "tag:yaml.org,2002:str": return isScalar(node) && typeof node.value === "string";
+		default: return false;
+	}
+};
+var convertNode = (node, path, locator, diagnostics) => {
+	const range = toRange(node.range, locator);
+	if (isAlias(node)) {
+		addUnsupportedFeature(diagnostics, path, range, "alias");
+		return null;
+	}
+	if ("anchor" in node && typeof node.anchor === "string") addUnsupportedFeature(diagnostics, path, range, "anchor");
+	if (node.tag !== void 0) {
+		if (!CORE_TAGS.has(node.tag)) {
+			addUnsupportedFeature(diagnostics, path, range, "custom-tag");
+			return null;
+		}
+		if (!isCoreTagCompatible(node)) {
+			diagnostics.add({
+				code: "MOLDEA_YAML_MALFORMED",
+				details: { reason: "tag-value" },
+				path,
+				range
+			});
+			return null;
+		}
+	}
+	if (isScalar(node)) {
+		const value = node.value;
+		if (value !== null && typeof value !== "string" && typeof value !== "number" && typeof value !== "bigint" && typeof value !== "boolean") {
+			diagnostics.add({
+				code: "MOLDEA_YAML_MALFORMED",
+				details: { reason: "scalar-type" },
+				path,
+				range
+			});
+			return null;
+		}
+		if (typeof value === "string" && !isUnicodeScalarString(value)) {
+			diagnostics.add({
+				code: "MOLDEA_YAML_MALFORMED",
+				details: { reason: "invalid-unicode" },
+				path,
+				range
+			});
+			return null;
+		}
+		return {
+			kind: "scalar",
+			range,
+			source: node.source,
+			style: node.type ?? null,
+			value
+		};
+	}
+	if (isSeq(node)) {
+		const items = [];
+		for (const item of node.items) {
+			if (item === null) {
+				items.push({
+					kind: "scalar",
+					range,
+					source: "",
+					style: null,
+					value: null
+				});
+				continue;
+			}
+			const converted = convertNode(item, path, locator, diagnostics);
+			if (converted !== null) items.push(converted);
+		}
+		return {
+			items,
+			kind: "sequence",
+			range
+		};
+	}
+	if (isMap(node)) {
+		const entries = [];
+		for (const pair of node.items) {
+			const key = convertNode(pair.key, path, locator, diagnostics);
+			const value = pair.value === null ? {
+				kind: "scalar",
+				range: key?.range ?? range,
+				source: "",
+				style: null,
+				value: null
+			} : convertNode(pair.value, path, locator, diagnostics);
+			if (key?.kind === "scalar" && key.value === "<<" && key.style === "PLAIN") addUnsupportedFeature(diagnostics, path, key.range, "merge-key");
+			if (key !== null && value !== null) entries.push({
+				key,
+				value
+			});
+		}
+		return {
+			entries,
+			kind: "mapping",
+			range
+		};
+	}
+	diagnostics.add({
+		code: "MOLDEA_YAML_MALFORMED",
+		details: { reason: "node-type" },
+		path,
+		range
+	});
+	return null;
+};
+var addParserDiagnostic = (code, start, end, path, locator, diagnostics) => {
+	if (code === "BAD_DIRECTIVE") return;
+	if (code === "DUPLICATE_KEY") {
+		diagnostics.add({
+			code: "MOLDEA_YAML_DUPLICATE_KEY",
+			path,
+			range: locator.locateRange(start, end)
+		});
+		return;
+	}
+	if (code === "TAG_RESOLVE_FAILED") return;
+	diagnostics.add({
+		code: "MOLDEA_YAML_MALFORMED",
+		details: { reason: code === "RESOURCE_EXHAUSTION" ? "resource-exhaustion" : "syntax" },
+		path,
+		range: locator.locateRange(start, end)
+	});
+};
+/**
+* Parses one normalized YAML 1.2 Core Schema document into parser-neutral nodes.
+* @param value The normalized manifest text.
+* @param path The logical source path used by diagnostics.
+* @param locator The scalar-aware source locator for the normalized text.
+* @param diagnostics The operation diagnostic collector.
+* @returns The private parsed tree only when the YAML substrate is trustworthy.
+*/
+var parseStrictYaml = (value, path, locator, diagnostics) => {
+	const initialDiagnosticCount = diagnostics.size;
+	for (const token of new Parser().parse(value)) if (token.type === "directive") addUnsupportedFeature(diagnostics, path, locator.locateRange(token.offset, token.offset + token.source.length), "directive");
+	const documents = parseAllDocuments(value, {
+		intAsBigInt: true,
+		keepSourceTokens: true,
+		logLevel: "silent",
+		merge: false,
+		prettyErrors: false,
+		resolveKnownTags: false,
+		schema: "core",
+		strict: true,
+		uniqueKeys: true,
+		version: "1.2"
+	});
+	if (documents.length > 1) {
+		const range = documents[1]?.range;
+		diagnostics.add({
+			code: "MOLDEA_YAML_MULTIPLE_DOCUMENTS",
+			path,
+			range: locator.locateRange(range?.[0] ?? 0, range?.[0] ?? 0)
+		});
+	}
+	for (const document of documents) for (const error of [...document.errors, ...document.warnings]) addParserDiagnostic(error.code, error.pos[0], error.pos[1], path, locator, diagnostics);
+	if (documents.length > 1 || diagnostics.size > initialDiagnosticCount) return {
+		valid: false,
+		value: null
+	};
+	const document = documents[0];
+	if (document === void 0 || document.contents === null) return {
+		valid: true,
+		value: {
+			kind: "scalar",
+			range: locator.locateRange(0, 0),
+			source: "",
+			style: null,
+			value: null
+		}
+	};
+	const parsedValue = convertNode(document.contents, path, locator, diagnostics);
+	return {
+		valid: parsedValue !== null && diagnostics.size === initialDiagnosticCount,
+		value: diagnostics.size === initialDiagnosticCount ? parsedValue : null
+	};
+};
+//#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 limits and adapter snapshots.
+* @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);
+	return freezeRecursively({
+		decision: {
+			asset: {
+				content: normalized.text.value,
+				digest,
+				path,
+				scalarLength: normalized.text.scalarLength,
+				utf8ByteLength: normalized.text.utf8ByteLength
+			},
+			body: sections.body,
+			createdAt: metadata.createdAt,
+			id: decisionId,
+			path,
+			status: metadata.status,
+			supersedes: metadata.supersedes
+		},
+		diagnostics: diagnostics.finalize(),
+		valid: true
+	});
+};
+//#endregion
+//#region src/manifest-validation/index.ts
+var childPointer$1 = (pointer, key) => {
+	return `${pointer}/${escapeJsonPointerSegment(key)}`;
+};
+var addInvalidValue = (context, pointer, range, reason, entity = null) => {
+	context.diagnostics.add({
+		code: "MOLDEA_MANIFEST_VALUE_INVALID",
+		details: { reason },
+		entity,
+		path: context.path,
+		pointer,
+		range
+	});
+};
+var readMapping = (node, pointer, allowedProperties, context, entity = null) => {
+	if (node.kind !== "mapping") {
+		addInvalidValue(context, pointer, node.range, "mapping-required", entity);
+		return null;
+	}
+	const entries = /* @__PURE__ */ new Map();
+	for (const entry of node.entries) {
+		if (entry.key.kind !== "scalar" || typeof entry.key.value !== "string") {
+			addInvalidValue(context, pointer, entry.key.range, "string-key-required", entity);
+			continue;
+		}
+		const key = entry.key.value;
+		if (allowedProperties !== null && !allowedProperties.has(key)) {
+			context.diagnostics.add({
+				code: "MOLDEA_MANIFEST_PROPERTY_UNKNOWN",
+				entity,
+				path: context.path,
+				pointer: childPointer$1(pointer, key),
+				range: entry.key.range
+			});
+			continue;
+		}
+		entries.set(key, {
+			key: entry.key,
+			value: entry.value
+		});
+	}
+	return entries;
+};
+var readString = (entry, pointer, context, options = {}) => {
+	if (entry === void 0) {
+		if (options.required === true) addInvalidValue(context, pointer, null, "required", options.entity ?? null);
+		return null;
+	}
+	if (entry.value.kind !== "scalar" || typeof entry.value.value !== "string") {
+		addInvalidValue(context, pointer, entry.value.range, "string-required", options.entity ?? null);
+		return null;
+	}
+	const value = entry.value.value;
+	if (!hasNonWhitespace(value) || options.singleLine === true && !isNonEmptySingleLine(value)) {
+		addInvalidValue(context, pointer, entry.value.range, "string-invalid", options.entity ?? null);
+		return null;
+	}
+	return value;
+};
+var validateStableId = (value, range, pointer, context, entity = null) => {
+	if (!isStableId$1(value)) {
+		context.diagnostics.add({
+			code: "MOLDEA_ID_INVALID",
+			entity,
+			path: context.path,
+			pointer,
+			range
+		});
+		return false;
+	}
+	if (isReservedId(value)) {
+		context.diagnostics.add({
+			code: "MOLDEA_ID_RESERVED",
+			entity,
+			path: context.path,
+			pointer,
+			range
+		});
+		return false;
+	}
+	return true;
+};
+var readReference = (node, pointer, context, entity = null) => {
+	const entries = readMapping(node, pointer, /* @__PURE__ */ new Set(["path", "symbol"]), context, entity);
+	if (entries === null) return null;
+	const pathEntry = entries.get("path");
+	if (pathEntry?.value.kind !== "scalar" || typeof pathEntry.value.value !== "string") {
+		context.diagnostics.add({
+			code: "MOLDEA_PATH_INVALID",
+			details: { reason: pathEntry === void 0 ? "missing" : "type" },
+			entity,
+			path: context.path,
+			pointer: childPointer$1(pointer, "path"),
+			range: pathEntry?.value.range ?? null
+		});
+		return null;
+	}
+	const path = parseManifestPath(pathEntry.value.value);
+	if (path === null) {
+		context.diagnostics.add({
+			code: "MOLDEA_PATH_INVALID",
+			entity,
+			path: context.path,
+			pointer: childPointer$1(pointer, "path"),
+			range: pathEntry.value.range
+		});
+		return null;
+	}
+	const symbolEntry = entries.get("symbol");
+	if (symbolEntry === void 0) return { path };
+	if (symbolEntry.value.kind !== "scalar" || typeof symbolEntry.value.value !== "string" || !isRepositorySymbol(symbolEntry.value.value)) {
+		context.diagnostics.add({
+			code: "MOLDEA_SYMBOL_INVALID",
+			entity,
+			path: context.path,
+			pointer: childPointer$1(pointer, "symbol"),
+			range: symbolEntry.value.range
+		});
+		return null;
+	}
+	if (isCanonicalMoldeaPath(path)) {
+		context.diagnostics.add({
+			code: "MOLDEA_SYMBOL_FORBIDDEN",
+			entity,
+			path: context.path,
+			pointer: childPointer$1(pointer, "symbol"),
+			range: symbolEntry.value.range
+		});
+		return null;
+	}
+	return {
+		path,
+		symbol: symbolEntry.value.value
+	};
+};
+var readReferenceList = (node, pointer, context, entity = null) => {
+	if (node.kind !== "sequence" || node.items.length === 0) {
+		addInvalidValue(context, pointer, node.range, "non-empty-sequence-required", entity);
+		return [];
+	}
+	const references = [];
+	const seen = /* @__PURE__ */ new Set();
+	node.items.forEach((item, index) => {
+		const reference = readReference(item, childPointer$1(pointer, String(index)), context, entity);
+		if (reference === null) return;
+		const key = `${reference.path}\0${reference.symbol ?? ""}`;
+		if (seen.has(key)) {
+			context.diagnostics.add({
+				code: "MOLDEA_PATH_DUPLICATE",
+				entity,
+				path: context.path,
+				pointer: childPointer$1(pointer, String(index)),
+				range: item.range
+			});
+			return;
+		}
+		seen.add(key);
+		references.push(reference);
+	});
+	return sortRepositoryReferences(references);
+};
+var readAffectedBy = (node, pointer, context, entity = null) => {
+	if (node.kind !== "sequence" || node.items.length === 0) {
+		addInvalidValue(context, pointer, node.range, "non-empty-sequence-required", entity);
+		return [];
+	}
+	const values = [];
+	const seen = /* @__PURE__ */ new Set();
+	node.items.forEach((item, index) => {
+		const itemPointer = childPointer$1(pointer, String(index));
+		if (item.kind !== "scalar" || typeof item.value !== "string") {
+			addInvalidValue(context, itemPointer, item.range, "string-required", entity);
+			return;
+		}
+		const isGlob = item.value.includes("*") || hasUnsupportedGlobMetacharacter(item.value);
+		if (!(isGlob ? isSimpleGlob(item.value) : parseManifestPath(item.value) !== null)) {
+			context.diagnostics.add({
+				code: isGlob ? "MOLDEA_GLOB_INVALID" : "MOLDEA_PATH_INVALID",
+				entity,
+				path: context.path,
+				pointer: itemPointer,
+				range: item.range
+			});
+			return;
+		}
+		if (seen.has(item.value)) {
+			context.diagnostics.add({
+				code: isGlob ? "MOLDEA_PATTERN_DUPLICATE" : "MOLDEA_PATH_DUPLICATE",
+				entity,
+				path: context.path,
+				pointer: itemPointer,
+				range: item.range
+			});
+			return;
+		}
+		seen.add(item.value);
+		values.push(item.value);
+	});
+	return values.sort(compareExactStrings);
+};
+var readRelationship = (node, pointer, context) => {
+	const entries = readMapping(node, pointer, /* @__PURE__ */ new Set(["affectedBy", "bindings"]), context);
+	if (entries === null) return null;
+	const bindingsEntry = entries.get("bindings");
+	const affectedByEntry = entries.get("affectedBy");
+	if (bindingsEntry === void 0 && affectedByEntry === void 0) context.diagnostics.add({
+		code: "MOLDEA_CONTEXT_RELATIONSHIP_EMPTY",
+		path: context.path,
+		pointer,
+		range: node.range
+	});
+	return {
+		...bindingsEntry === void 0 ? {} : { bindings: readReferenceList(bindingsEntry.value, childPointer$1(pointer, "bindings"), context) },
+		...affectedByEntry === void 0 ? {} : { affectedBy: readAffectedBy(affectedByEntry.value, childPointer$1(pointer, "affectedBy"), context) }
+	};
+};
+var readRelationshipRecord = (node, pointer, kind, context) => {
+	const entries = readMapping(node, pointer, null, context);
+	if (entries === null) return null;
+	const normalized = [];
+	for (const [key, entry] of [...entries].sort(([left], [right]) => compareExactStrings(left, right))) {
+		const path = parseManifestPath(key);
+		if (!(path !== null && (kind === "context" ? isContextPath(path, true) : isDecisionPath(path)))) {
+			context.diagnostics.add({
+				code: kind === "context" ? "MOLDEA_CONTEXT_PATH_INVALID" : "MOLDEA_DECISION_FILENAME_INVALID",
+				path: context.path,
+				pointer: childPointer$1(pointer, key),
+				range: entry.key.range
+			});
+			continue;
+		}
+		const relationship = readRelationship(entry.value, childPointer$1(pointer, key), context);
+		if (relationship !== null) normalized.push([key, relationship]);
+	}
+	return createNullPrototypeRecord(normalized);
+};
+var readPathList = (node, pointer, kind, context, entity) => {
+	if (node.kind !== "sequence") {
+		addInvalidValue(context, pointer, node.range, "sequence-required", entity);
+		return [];
+	}
+	const paths = [];
+	const seen = /* @__PURE__ */ new Set();
+	node.items.forEach((item, index) => {
+		const itemPointer = childPointer$1(pointer, String(index));
+		if (item.kind !== "scalar" || typeof item.value !== "string") {
+			addInvalidValue(context, itemPointer, item.range, "string-required", entity);
+			return;
+		}
+		const path = parseManifestPath(item.value);
+		if (!(path !== null && (kind === "context" ? isContextPath(path, false) : kind === "decision" ? isDecisionPath(path) : isMirrorPath(path))) || path === null) {
+			const code = kind === "context" ? "MOLDEA_CONTEXT_PATH_INVALID" : kind === "decision" ? "MOLDEA_DECISION_FILENAME_INVALID" : path !== null && !isMirrorPath(path) ? "MOLDEA_MIRROR_PATH_INSIDE_MOLDEA" : "MOLDEA_MIRROR_PATH_INVALID";
+			context.diagnostics.add({
+				code,
+				entity,
+				path: context.path,
+				pointer: itemPointer,
+				range: item.range
+			});
+			return;
+		}
+		if (seen.has(path)) {
+			context.diagnostics.add({
+				code: kind === "mirror" ? "MOLDEA_MIRROR_PATH_DUPLICATE" : "MOLDEA_PATH_DUPLICATE",
+				entity,
+				path: context.path,
+				pointer: itemPointer,
+				range: item.range
+			});
+			return;
+		}
+		if (kind === "mirror" && context.mirrorPaths.has(path)) {
+			context.diagnostics.add({
+				code: "MOLDEA_MIRROR_PATH_DUPLICATE",
+				entity,
+				path: context.path,
+				pointer: itemPointer,
+				range: item.range
+			});
+			return;
+		}
+		seen.add(path);
+		if (kind === "mirror") context.mirrorPaths.add(path);
+		paths.push(path);
+	});
+	return paths.sort(compareExactStrings);
+};
+var readRuntime = (node, pointer, context, agentId) => {
+	const entity = { agentId };
+	const entries = readMapping(node, pointer, /* @__PURE__ */ new Set(["guidance", "id"]), context, entity);
+	if (entries === null) return null;
+	const idEntry = entries.get("id");
+	if (idEntry?.value.kind !== "scalar" || typeof idEntry.value.value !== "string") {
+		context.diagnostics.add({
+			code: "MOLDEA_RUNTIME_ID_INVALID",
+			entity,
+			path: context.path,
+			pointer: childPointer$1(pointer, "id"),
+			range: idEntry?.value.range ?? null
+		});
+		return null;
+	}
+	const id = idEntry.value.value;
+	if (!isStableId$1(id) || isReservedId(id) || !RECOGNIZED_RUNTIME_ADAPTER_IDS.includes(id)) context.diagnostics.add({
+		code: "MOLDEA_RUNTIME_ID_INVALID",
+		entity,
+		path: context.path,
+		pointer: childPointer$1(pointer, "id"),
+		range: idEntry.value.range
+	});
+	else context.runtimeLocations.push({
+		adapterId: id,
+		agentId,
+		path: context.path,
+		pointer: childPointer$1(pointer, "id"),
+		range: idEntry.value.range
+	});
+	const guidanceEntry = entries.get("guidance");
+	let guidance = null;
+	if (guidanceEntry !== void 0) {
+		if (guidanceEntry.value.kind === "scalar" && typeof guidanceEntry.value.value === "string") {
+			const candidate = parseManifestPath(guidanceEntry.value.value);
+			if (candidate !== null && isRuntimeGuidancePath(candidate)) guidance = candidate;
+			else context.diagnostics.add({
+				code: "MOLDEA_PATH_INVALID",
+				details: { reason: "runtime-guidance" },
+				entity,
+				path: context.path,
+				pointer: childPointer$1(pointer, "guidance"),
+				range: guidanceEntry.value.range
+			});
+		} else context.diagnostics.add({
+			code: "MOLDEA_PATH_INVALID",
+			details: { reason: "runtime-guidance" },
+			entity,
+			path: context.path,
+			pointer: childPointer$1(pointer, "guidance"),
+			range: guidanceEntry.value.range
+		});
+	}
+	return {
+		id,
+		...guidance === null ? {} : { guidance }
+	};
+};
+var readVariables = (node, pointer, context, agentId) => {
+	const entries = readMapping(node, pointer, null, context, { agentId });
+	if (entries === null) return null;
+	const normalized = [];
+	for (const [variableId, entry] of [...entries].sort(([left], [right]) => compareExactStrings(left, right))) {
+		const entity = {
+			agentId,
+			variableId
+		};
+		if (!isVariableId(variableId)) context.diagnostics.add({
+			code: "MOLDEA_VARIABLE_ID_INVALID",
+			entity,
+			path: context.path,
+			pointer: childPointer$1(pointer, variableId),
+			range: entry.key.range
+		});
+		const variablePointer = childPointer$1(pointer, variableId);
+		const variableEntries = readMapping(entry.value, variablePointer, /* @__PURE__ */ new Set(["description"]), context, entity);
+		if (variableEntries === null) continue;
+		const description = readString(variableEntries.get("description"), childPointer$1(variablePointer, "description"), context, {
+			entity,
+			required: true
+		});
+		if (description !== null) normalized.push([variableId, { description }]);
+	}
+	return createNullPrototypeRecord(normalized);
+};
+var readBindings = (node, pointer, context, agentId, declaredVariables) => {
+	const entity = { agentId };
+	const entries = readMapping(node, pointer, /* @__PURE__ */ new Set([
+		"inputSchema",
+		"instructionLoader",
+		"outputSchema",
+		"runtimeAgent",
+		"variableProviders"
+	]), context, entity);
+	if (entries === null) return null;
+	const referenceProperty = (key) => {
+		const entry = entries.get(key);
+		return entry === void 0 ? null : readReference(entry.value, childPointer$1(pointer, key), context, entity);
+	};
+	const inputSchema = referenceProperty("inputSchema");
+	const instructionLoader = referenceProperty("instructionLoader");
+	const outputSchema = referenceProperty("outputSchema");
+	const runtimeAgent = referenceProperty("runtimeAgent");
+	const providersEntry = entries.get("variableProviders");
+	let variableProviders = null;
+	if (providersEntry !== void 0) {
+		const providers = readMapping(providersEntry.value, childPointer$1(pointer, "variableProviders"), null, context, entity);
+		if (providers !== null) {
+			const normalized = [];
+			for (const [variableId, providerEntry] of [...providers].sort(([left], [right]) => compareExactStrings(left, right))) {
+				const variableEntity = {
+					agentId,
+					variableId
+				};
+				const providerPointer = childPointer$1(childPointer$1(pointer, "variableProviders"), variableId);
+				if (!isVariableId(variableId)) context.diagnostics.add({
+					code: "MOLDEA_VARIABLE_ID_INVALID",
+					entity: variableEntity,
+					path: context.path,
+					pointer: providerPointer,
+					range: providerEntry.key.range
+				});
+				else if (!declaredVariables.has(variableId)) context.diagnostics.add({
+					code: "MOLDEA_VARIABLE_PROVIDER_UNDECLARED",
+					entity: variableEntity,
+					path: context.path,
+					pointer: providerPointer,
+					range: providerEntry.key.range
+				});
+				const reference = readReference(providerEntry.value, providerPointer, context, variableEntity);
+				if (reference !== null) normalized.push([variableId, reference]);
+			}
+			variableProviders = createNullPrototypeRecord(normalized);
+		}
+	}
+	return {
+		...runtimeAgent === null ? {} : { runtimeAgent },
+		...inputSchema === null ? {} : { inputSchema },
+		...outputSchema === null ? {} : { outputSchema },
+		...instructionLoader === null ? {} : { instructionLoader },
+		...variableProviders === null ? {} : { variableProviders }
+	};
+};
+var readCapability$1 = (node, pointer, context, agentId, capabilityId, kind) => {
+	const entity = {
+		agentId,
+		capabilityId,
+		capabilityKind: kind
+	};
+	const entries = readMapping(node, pointer, kind === "tool" ? /* @__PURE__ */ new Set([
+		"affectedBy",
+		"description",
+		"implementation",
+		"inputSchema",
+		"name",
+		"outputSchema",
+		"registration"
+	]) : /* @__PURE__ */ new Set([
+		"affectedBy",
+		"description",
+		"implementation",
+		"name",
+		"registration"
+	]), context, entity);
+	if (entries === null) return null;
+	const name = readString(entries.get("name"), childPointer$1(pointer, "name"), context, {
+		entity,
+		required: true,
+		singleLine: true
+	});
+	const descriptionEntry = entries.get("description");
+	let description = null;
+	if (descriptionEntry === void 0) context.diagnostics.add({
+		code: "MOLDEA_CAPABILITY_DESCRIPTION_MISSING",
+		entity,
+		path: context.path,
+		pointer: childPointer$1(pointer, "description")
+	});
+	else if (descriptionEntry.value.kind !== "scalar" || typeof descriptionEntry.value.value !== "string" || !isCapabilityDescription(descriptionEntry.value.value)) context.diagnostics.add({
+		code: "MOLDEA_CAPABILITY_DESCRIPTION_INVALID",
+		entity,
+		path: context.path,
+		pointer: childPointer$1(pointer, "description"),
+		range: descriptionEntry.value.range
+	});
+	else description = descriptionEntry.value.value;
+	const implementationEntry = entries.get("implementation");
+	let implementation = null;
+	if (implementationEntry === void 0) context.diagnostics.add({
+		code: kind === "tool" ? "MOLDEA_TOOL_IMPLEMENTATION_MISSING" : "MOLDEA_SKILL_IMPLEMENTATION_MISSING",
+		entity,
+		path: context.path,
+		pointer: childPointer$1(pointer, "implementation")
+	});
+	else implementation = readReference(implementationEntry.value, childPointer$1(pointer, "implementation"), context, entity);
+	const optionalReference = (key) => {
+		const entry = entries.get(key);
+		return entry === void 0 ? null : readReference(entry.value, childPointer$1(pointer, key), context, entity);
+	};
+	const registration = optionalReference("registration");
+	const inputSchema = kind === "tool" ? optionalReference("inputSchema") : null;
+	const outputSchema = kind === "tool" ? optionalReference("outputSchema") : null;
+	const affectedByEntry = entries.get("affectedBy");
+	const affectedBy = affectedByEntry === void 0 ? null : readAffectedBy(affectedByEntry.value, childPointer$1(pointer, "affectedBy"), context, entity);
+	if (name === null || description === null || implementation === null) return null;
+	return {
+		name,
+		description,
+		implementation,
+		...registration === null ? {} : { registration },
+		...inputSchema === null ? {} : { inputSchema },
+		...outputSchema === null ? {} : { outputSchema },
+		...affectedBy === null ? {} : { affectedBy }
+	};
+};
+var readCapabilities = (node, pointer, context, agentId, kind) => {
+	const entries = readMapping(node, pointer, null, context, { agentId });
+	if (entries === null) return null;
+	const normalized = [];
+	for (const [capabilityId, entry] of [...entries].sort(([left], [right]) => compareExactStrings(left, right))) {
+		const entity = {
+			agentId,
+			capabilityId,
+			capabilityKind: kind
+		};
+		const capabilityPointer = childPointer$1(pointer, capabilityId);
+		validateStableId(capabilityId, entry.key.range, capabilityPointer, context, entity);
+		const capability = readCapability$1(entry.value, capabilityPointer, context, agentId, capabilityId, kind);
+		if (capability !== null) normalized.push([capabilityId, capability]);
+	}
+	return createNullPrototypeRecord(normalized);
+};
+var readUnresolved = (node, pointer, context, agentId) => {
+	const entries = readMapping(node, pointer, null, context, agentId === void 0 ? null : { agentId });
+	if (entries === null) return null;
+	const normalized = [];
+	for (const [requirementId, entry] of [...entries].sort(([left], [right]) => compareExactStrings(left, right))) {
+		const entity = agentId === void 0 ? null : { agentId };
+		const requirementPointer = childPointer$1(pointer, requirementId);
+		validateStableId(requirementId, entry.key.range, requirementPointer, context, entity);
+		const requirementEntries = readMapping(entry.value, requirementPointer, /* @__PURE__ */ new Set([
+			"category",
+			"description",
+			"effect",
+			"reference",
+			"related",
+			"resolution"
+		]), context, entity);
+		if (requirementEntries === null) continue;
+		const category = readString(requirementEntries.get("category"), childPointer$1(requirementPointer, "category"), context, {
+			...entity === null ? {} : { entity },
+			required: true
+		});
+		if (category !== null && !isStableId$1(category)) context.diagnostics.add({
+			code: "MOLDEA_ID_INVALID",
+			entity,
+			path: context.path,
+			pointer: childPointer$1(requirementPointer, "category"),
+			range: requirementEntries.get("category")?.value.range ?? null
+		});
+		const effectEntry = requirementEntries.get("effect");
+		let effect = null;
+		if (effectEntry?.value.kind === "scalar" && (effectEntry.value.value === "blocking" || effectEntry.value.value === "warning" || effectEntry.value.value === "informational")) effect = effectEntry.value.value;
+		else addInvalidValue(context, childPointer$1(requirementPointer, "effect"), effectEntry?.value.range ?? null, effectEntry === void 0 ? "required" : "enum", entity);
+		const description = readString(requirementEntries.get("description"), childPointer$1(requirementPointer, "description"), context, {
+			...entity === null ? {} : { entity },
+			required: true
+		});
+		const resolution = readString(requirementEntries.get("resolution"), childPointer$1(requirementPointer, "resolution"), context, {
+			...entity === null ? {} : { entity },
+			required: true
+		});
+		const relatedEntry = requirementEntries.get("related");
+		const related = relatedEntry === void 0 ? null : readReferenceList(relatedEntry.value, childPointer$1(requirementPointer, "related"), context, entity);
+		const reference = readString(requirementEntries.get("reference"), childPointer$1(requirementPointer, "reference"), context, {
+			...entity === null ? {} : { entity },
+			singleLine: true
+		});
+		if (category !== null && effect !== null && description !== null && resolution !== null) normalized.push([requirementId, {
+			category,
+			effect,
+			description,
+			resolution,
+			...related === null ? {} : { related },
+			...reference === null ? {} : { reference }
+		}]);
+	}
+	return createNullPrototypeRecord(normalized);
+};
+var findMappingProperty = (node, property) => {
+	if (node.kind !== "mapping") return null;
+	for (const entry of node.entries) if (entry.key.kind === "scalar" && entry.key.value === property) return entry.value;
+	return null;
+};
+/**
+* Detects a supported repository-format version without treating the remaining manifest as valid.
+* @param node The trustworthy strict-YAML manifest root.
+* @returns The supported parsed version when its declaration is independently unambiguous.
+*/
+var detectSupportedManifestVersion = (node) => {
+	if (node.kind !== "mapping") return null;
+	const versionNode = findMappingProperty(node, "version");
+	return versionNode?.kind === "scalar" && versionNode.value === 1n ? 1 : null;
+};
+var validateAgentOwnedIdUniqueness = (node, pointer, context, agentId) => {
+	const seen = /* @__PURE__ */ new Set();
+	for (const property of [
+		"tools",
+		"skills",
+		"unresolved"
+	]) {
+		const record = findMappingProperty(node, property);
+		if (record?.kind !== "mapping") continue;
+		for (const entry of record.entries) {
+			if (entry.key.kind !== "scalar" || typeof entry.key.value !== "string") continue;
+			if (seen.has(entry.key.value)) context.diagnostics.add({
+				code: "MOLDEA_ID_DUPLICATE",
+				entity: { agentId },
+				path: context.path,
+				pointer: childPointer$1(childPointer$1(pointer, property), entry.key.value),
+				range: entry.key.range
+			});
+			seen.add(entry.key.value);
+		}
+	}
+};
+var readAgent = (node, pointer, context, agentId) => {
+	const entity = { agentId };
+	const entries = readMapping(node, pointer, /* @__PURE__ */ new Set([
+		"affectedBy",
+		"bindings",
+		"context",
+		"decisions",
+		"runtime",
+		"mirrors",
+		"skills",
+		"tools",
+		"unresolved",
+		"variables"
+	]), context, entity);
+	if (entries === null) return null;
+	validateAgentOwnedIdUniqueness(node, pointer, context, agentId);
+	const runtimeEntry = entries.get("runtime");
+	let runtime = null;
+	if (runtimeEntry === void 0) addInvalidValue(context, childPointer$1(pointer, "runtime"), null, "required", entity);
+	else runtime = readRuntime(runtimeEntry.value, childPointer$1(pointer, "runtime"), context, agentId);
+	const variablesEntry = entries.get("variables");
+	const variables = variablesEntry === void 0 ? null : readVariables(variablesEntry.value, childPointer$1(pointer, "variables"), context, agentId);
+	const declaredVariables = new Set(Object.keys(variables ?? {}));
+	const bindingsEntry = entries.get("bindings");
+	const bindings = bindingsEntry === void 0 ? null : readBindings(bindingsEntry.value, childPointer$1(pointer, "bindings"), context, agentId, declaredVariables);
+	const contextEntry = entries.get("context");
+	const contextPaths = contextEntry === void 0 ? null : readPathList(contextEntry.value, childPointer$1(pointer, "context"), "context", context, entity);
+	const decisionsEntry = entries.get("decisions");
+	const decisions = decisionsEntry === void 0 ? null : readPathList(decisionsEntry.value, childPointer$1(pointer, "decisions"), "decision", context, entity);
+	const toolsEntry = entries.get("tools");
+	const tools = toolsEntry === void 0 ? null : readCapabilities(toolsEntry.value, childPointer$1(pointer, "tools"), context, agentId, "tool");
+	const skillsEntry = entries.get("skills");
+	const skills = skillsEntry === void 0 ? null : readCapabilities(skillsEntry.value, childPointer$1(pointer, "skills"), context, agentId, "skill");
+	const affectedByEntry = entries.get("affectedBy");
+	const affectedBy = affectedByEntry === void 0 ? null : readAffectedBy(affectedByEntry.value, childPointer$1(pointer, "affectedBy"), context, entity);
+	const mirrorsEntry = entries.get("mirrors");
+	const mirrors = mirrorsEntry === void 0 ? null : readPathList(mirrorsEntry.value, childPointer$1(pointer, "mirrors"), "mirror", context, entity);
+	const unresolvedEntry = entries.get("unresolved");
+	const unresolved = unresolvedEntry === void 0 ? null : readUnresolved(unresolvedEntry.value, childPointer$1(pointer, "unresolved"), context, agentId);
+	if (runtime === null) return null;
+	return {
+		runtime,
+		...contextPaths === null ? {} : { context: contextPaths },
+		...decisions === null ? {} : { decisions },
+		...variables === null ? {} : { variables },
+		...bindings === null ? {} : { bindings },
+		...tools === null ? {} : { tools },
+		...skills === null ? {} : { skills },
+		...affectedBy === null ? {} : { affectedBy },
+		...mirrors === null ? {} : { mirrors },
+		...unresolved === null ? {} : { unresolved }
+	};
+};
+var readAgents = (node, pointer, context) => {
+	const entries = readMapping(node, pointer, null, context);
+	if (entries === null) return null;
+	const normalized = [];
+	for (const [agentId, entry] of [...entries].sort(([left], [right]) => compareExactStrings(left, right))) {
+		const agentPointer = childPointer$1(pointer, agentId);
+		validateStableId(agentId, entry.key.range, agentPointer, context, { agentId });
+		const agent = readAgent(entry.value, agentPointer, context, agentId);
+		if (agent !== null) normalized.push([agentId, agent]);
+	}
+	return createNullPrototypeRecord(normalized);
+};
+/**
+* Validates and normalizes a strict YAML document as a version 1 moldea manifest.
+* @param node The parser-neutral YAML root node.
+* @param path The canonical or caller-supplied logical manifest path.
+* @param diagnostics The operation diagnostic collector.
+* @param runtimeLocations Mutable private source locations populated for repository inspection.
+* @returns The normalized manifest when its supported version can be interpreted.
+*/
+var validateManifest = (node, path, diagnostics, runtimeLocations) => {
+	const context = {
+		diagnostics,
+		mirrorPaths: /* @__PURE__ */ new Set(),
+		path,
+		runtimeLocations
+	};
+	if (node.kind !== "mapping") {
+		diagnostics.add({
+			code: "MOLDEA_MANIFEST_ROOT_INVALID",
+			path,
+			range: node.range
+		});
+		return null;
+	}
+	const versionNode = findMappingProperty(node, "version");
+	if (versionNode === null) {
+		diagnostics.add({
+			code: "MOLDEA_MANIFEST_VERSION_MISSING",
+			path,
+			pointer: "/version"
+		});
+		return null;
+	}
+	if (!(versionNode.kind === "scalar" && typeof versionNode.value === "bigint") || versionNode.kind !== "scalar" || versionNode.value <= 0n) {
+		diagnostics.add({
+			code: "MOLDEA_MANIFEST_VERSION_INVALID",
+			path,
+			pointer: "/version",
+			range: versionNode.range
+		});
+		return null;
+	}
+	if (versionNode.value !== 1n) {
+		diagnostics.add({
+			code: "MOLDEA_MANIFEST_VERSION_UNSUPPORTED",
+			path,
+			pointer: "/version",
+			range: versionNode.range
+		});
+		return null;
+	}
+	const entries = readMapping(node, "", /* @__PURE__ */ new Set([
+		"agents",
+		"context",
+		"decisions",
+		"unresolved",
+		"version"
+	]), context);
+	if (entries === null) return null;
+	const contextEntry = entries.get("context");
+	const contextRelationships = contextEntry === void 0 ? null : readRelationshipRecord(contextEntry.value, "/context", "context", context);
+	const decisionsEntry = entries.get("decisions");
+	const decisionRelationships = decisionsEntry === void 0 ? null : readRelationshipRecord(decisionsEntry.value, "/decisions", "decision", context);
+	const unresolvedEntry = entries.get("unresolved");
+	const unresolved = unresolvedEntry === void 0 ? null : readUnresolved(unresolvedEntry.value, "/unresolved", context);
+	const agentsEntry = entries.get("agents");
+	const agents = agentsEntry === void 0 ? null : readAgents(agentsEntry.value, "/agents", context);
+	return {
+		version: 1,
+		...contextRelationships === null ? {} : { context: contextRelationships },
+		...decisionRelationships === null ? {} : { decisions: decisionRelationships },
+		...unresolved === null ? {} : { unresolved },
+		...agents === null ? {} : { agents }
+	};
+};
+//#endregion
+//#region src/manifest/index.ts
+/**
+* Inspects one complete manifest while retaining an independently trustworthy supported version.
+* @param input The canonical logical path and exact manifest text or bytes.
+* @param options The immutable Core limits and adapter snapshots.
+* @param operation The owning public or repository-level operation for typed failures.
+* @returns Frozen inspection state with all-or-nothing manifest assets and values.
+* @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 inspectManifestDocument = async (input, options, operation = "parse-manifest") => {
+	options = createCoreOperationOptionsSnapshot(options);
+	const normalized = normalizeTextDocument(input, options.limits, operation, "maxManifestBytes");
+	const path = parseRepositoryPath(input.path);
+	const diagnostics = createCoreDiagnosticCollector(options.limits, operation);
+	if (!isCanonicalManifestPath(path)) diagnostics.add({
+		code: "MOLDEA_MANIFEST_PATH_INVALID",
+		path
+	});
+	for (const diagnostic of normalized.diagnostics) diagnostics.merge(diagnostic);
+	if (!normalized.valid || normalized.text === null) return freezeRecursively({
+		asset: null,
+		diagnostics: diagnostics.finalize(),
+		formatVersion: null,
+		manifest: null,
+		runtimeLocations: [],
+		valid: false
+	});
+	const locator = createSourceLocator(normalized.text.value);
+	const parsed = parseStrictYaml(normalized.text.value, path, locator, diagnostics);
+	const formatVersion = parsed.value === null ? null : detectSupportedManifestVersion(parsed.value);
+	const runtimeLocations = [];
+	const manifest = parsed.valid && parsed.value !== null ? validateManifest(parsed.value, path, diagnostics, runtimeLocations) : null;
+	if (manifest === null || diagnostics.size > 0) return freezeRecursively({
+		asset: null,
+		diagnostics: diagnostics.finalize(),
+		formatVersion,
+		manifest: null,
+		runtimeLocations,
+		valid: false
+	});
+	const digest = await calculateNormalizedTextDigest(normalized.text);
+	return freezeRecursively({
+		asset: {
+			content: normalized.text.value,
+			digest,
+			path,
+			scalarLength: normalized.text.scalarLength,
+			utf8ByteLength: normalized.text.utf8ByteLength
+		},
+		diagnostics: diagnostics.finalize(),
+		formatVersion,
+		manifest,
+		runtimeLocations,
+		valid: true
+	});
+};
+/**
+* Parses and validates one complete version 1 manifest document.
+* @param input The canonical logical path and exact manifest text or bytes.
+* @param options The immutable Core limits and adapter snapshots.
+* @returns A frozen all-or-nothing manifest 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 parseManifestDocument = async (input, options) => {
+	const inspection = await inspectManifestDocument(input, options);
+	return freezeRecursively({
+		asset: inspection.asset,
+		diagnostics: inspection.diagnostics,
+		manifest: inspection.manifest,
+		valid: inspection.valid
+	});
+};
+//#endregion
+//#region src/adapter-availability/index.ts
+/**
+* Validates adapter availability and format support before any runtime adapter runs.
+* @param locations The recognized runtime declarations retained from manifest parsing.
+* @param formatVersion The active repository-format version.
+* @param options The immutable Core adapter registry and limits.
+* @returns Frozen deterministic preflight diagnostics.
+* @throws
+* - RESOURCE_LIMIT_EXCEEDED: The raw Core diagnostic limit was exceeded.
+*/
+var validateRuntimeAdapterAvailability = (locations, formatVersion, options) => {
+	const diagnostics = createCoreDiagnosticCollector(options.limits, "inspect-project");
+	const adapters = new Map(options.adapters.map((adapter) => [adapter.id, adapter]));
+	for (const location of locations) {
+		if (location.adapterId === "custom") continue;
+		const adapter = adapters.get(location.adapterId);
+		if (adapter === void 0) {
+			diagnostics.add({
+				code: "MOLDEA_RUNTIME_ADAPTER_UNAVAILABLE",
+				entity: {
+					adapterId: location.adapterId,
+					agentId: location.agentId
+				},
+				path: location.path,
+				pointer: location.pointer,
+				range: location.range
+			});
+			continue;
+		}
+		if (!adapter.supportedRepositoryFormatVersions.includes(formatVersion)) diagnostics.add({
+			code: "MOLDEA_RUNTIME_ADAPTER_FORMAT_UNSUPPORTED",
+			entity: {
+				adapterId: location.adapterId,
+				agentId: location.agentId
+			},
+			path: location.path,
+			pointer: location.pointer,
+			range: location.range
+		});
+	}
+	return diagnostics.finalize();
+};
+//#endregion
+//#region src/adapter-validation/index.ts
+var EVIDENCE_KINDS = /* @__PURE__ */ new Set([
+	"runtime-package",
+	"language",
+	"agent-definition",
+	"instruction-loader",
+	"schema",
+	"tool-registration",
+	"skill-registration",
+	"handoff-registration",
+	"variable-provider",
+	"runtime-pattern"
+]);
+var DIAGNOSTIC_ENTITY_KEYS = /* @__PURE__ */ new Set([
+	"agentId",
+	"capabilityKind",
+	"capabilityId",
+	"decisionId",
+	"variableId",
+	"adapterId"
+]);
+var POSITION_KEYS = /* @__PURE__ */ new Set([
+	"line",
+	"column",
+	"offset"
+]);
+var RANGE_KEYS = /* @__PURE__ */ new Set(["start", "end"]);
+var REFERENCE_KEYS = /* @__PURE__ */ new Set(["path", "symbol"]);
+var EVIDENCE_KEYS = /* @__PURE__ */ new Set([
+	"source",
+	"kind",
+	"agentId",
+	"capabilityKind",
+	"capabilityId",
+	"runtimeName",
+	"references",
+	"details"
+]);
+var DIAGNOSTIC_KEYS = /* @__PURE__ */ new Set([
+	"source",
+	"code",
+	"message",
+	"path",
+	"pointer",
+	"range",
+	"entity",
+	"details"
+]);
+var ADAPTER_RESULT_KEYS = /* @__PURE__ */ new Set(["evidence", "diagnostics"]);
+var ADAPTER_CODE_PATTERN = /^[A-Z][A-Z0-9_]*$/u;
+var isRecord$1 = (candidate) => {
+	return typeof candidate === "object" && candidate !== null && !Array.isArray(candidate);
+};
+var invalidAdapterResult = (adapterId) => {
+	throw new CoreOperationException({
+		adapterId,
+		cause: /* @__PURE__ */ new TypeError("The runtime adapter result is invalid."),
+		code: "ADAPTER_EXECUTION_FAILED",
+		operation: "validate-adapter"
+	});
+};
+var registerRawOutput = (outputCounts, key, amount, context) => {
+	const limit = key === "diagnostics" ? "maxDiagnostics" : "maxEvidence";
+	if (key === "diagnostics") {
+		outputCounts.diagnostics = registerCoreDiagnosticCandidates(context.limits, amount, "validate-adapter", outputCounts.diagnostics, context.adapterId);
+		return;
+	}
+	if (amount > context.limits[limit] - outputCounts[key]) throw new CoreOperationException({
+		adapterId: context.adapterId,
+		code: "RESOURCE_LIMIT_EXCEEDED",
+		limit,
+		operation: "validate-adapter"
+	});
+	outputCounts[key] += amount;
+};
+var hasOnlyKeys = (candidate, keys) => {
+	return Reflect.ownKeys(candidate).every((key) => typeof key === "string" && keys.has(key));
+};
+var isSafeString = (candidate) => {
+	return typeof candidate === "string" && isUnicodeScalarText(candidate) && !candidate.includes("\0");
+};
+var normalizeDetails = (candidate, adapterId) => {
+	if (!isRecord$1(candidate)) return invalidAdapterResult(adapterId);
+	const entries = [];
+	for (const key of Reflect.ownKeys(candidate)) {
+		if (typeof key !== "string" || !isUnicodeScalarText(key) || key.includes("\0")) return invalidAdapterResult(adapterId);
+		const descriptor = Object.getOwnPropertyDescriptor(candidate, key);
+		if (descriptor === void 0 || !descriptor.enumerable || !("value" in descriptor)) return invalidAdapterResult(adapterId);
+		const detail = descriptor.value;
+		if (detail !== null && typeof detail !== "boolean" && !(typeof detail === "string" && isUnicodeScalarText(detail) && !detail.includes("\0")) && !(typeof detail === "number" && Number.isFinite(detail))) return invalidAdapterResult(adapterId);
+		entries.push([key, typeof detail === "number" && Object.is(detail, -0) ? 0 : detail]);
+	}
+	return normalizeDiagnosticDetails(createNullPrototypeRecord(entries));
+};
+var normalizePosition = (candidate, adapterId) => {
+	if (!isRecord$1(candidate) || !hasOnlyKeys(candidate, POSITION_KEYS) || !Number.isSafeInteger(candidate["line"]) || !Number.isSafeInteger(candidate["column"]) || !Number.isSafeInteger(candidate["offset"]) || candidate["line"] < 1 || candidate["column"] < 1 || candidate["offset"] < 0) return invalidAdapterResult(adapterId);
+	return freezeRecursively({
+		column: candidate["column"],
+		line: candidate["line"],
+		offset: candidate["offset"]
+	});
+};
+var normalizeRange = (candidate, adapterId) => {
+	if (candidate === null) return null;
+	if (!isRecord$1(candidate) || !hasOnlyKeys(candidate, RANGE_KEYS)) return invalidAdapterResult(adapterId);
+	const start = normalizePosition(candidate["start"], adapterId);
+	const end = normalizePosition(candidate["end"], adapterId);
+	if (!(end.line > start.line || end.line === start.line && end.column >= start.column) || end.offset < start.offset) return invalidAdapterResult(adapterId);
+	return freezeRecursively({
+		end,
+		start
+	});
+};
+var isJsonPointer = (candidate) => {
+	return isUnicodeScalarText(candidate) && !candidate.includes("\0") && (candidate === "" || candidate.startsWith("/") && !/~(?![01])/u.test(candidate));
+};
+var readCapability = (agent, capabilityKind, capabilityId) => {
+	const capabilities = capabilityKind === "tool" ? agent.declaration.tools : agent.declaration.skills;
+	return capabilities !== void 0 && Object.hasOwn(capabilities, capabilityId) ? capabilities[capabilityId] : void 0;
+};
+var normalizeEntity = (candidate, context) => {
+	if (candidate === null) return null;
+	if (!isRecord$1(candidate) || !hasOnlyKeys(candidate, DIAGNOSTIC_ENTITY_KEYS)) return invalidAdapterResult(context.adapterId);
+	const entity = {};
+	for (const key of DIAGNOSTIC_ENTITY_KEYS) {
+		const candidateValue = candidate[key];
+		if (candidateValue === void 0) continue;
+		if (!isSafeString(candidateValue) || candidateValue.length === 0) return invalidAdapterResult(context.adapterId);
+		entity[key] = candidateValue;
+	}
+	const agentId = entity["agentId"];
+	const agent = agentId === void 0 ? void 0 : context.agentsById.get(agentId);
+	if (agentId !== void 0 && agent === void 0) return invalidAdapterResult(context.adapterId);
+	if (entity["adapterId"] !== void 0 && entity["adapterId"] !== context.adapterId) return invalidAdapterResult(context.adapterId);
+	const capabilityKind = entity["capabilityKind"];
+	const capabilityId = entity["capabilityId"];
+	if (capabilityKind === void 0 !== (capabilityId === void 0) || capabilityKind !== void 0 && capabilityKind !== "tool" && capabilityKind !== "skill" || capabilityKind !== void 0 && capabilityId !== void 0 && (agent === void 0 || readCapability(agent, capabilityKind, capabilityId) === void 0)) return invalidAdapterResult(context.adapterId);
+	const variableId = entity["variableId"];
+	if (variableId !== void 0 && (agent === void 0 || agent.declaration.variables === void 0 || !Object.hasOwn(agent.declaration.variables, variableId))) return invalidAdapterResult(context.adapterId);
+	const decisionId = entity["decisionId"];
+	if (decisionId !== void 0 && !context.decisionIds.has(decisionId)) return invalidAdapterResult(context.adapterId);
+	return normalizeDiagnosticEntity(entity);
+};
+var normalizeReference = (candidate, adapterId) => {
+	if (!isRecord$1(candidate) || !hasOnlyKeys(candidate, REFERENCE_KEYS)) return invalidAdapterResult(adapterId);
+	const pathCandidate = candidate["path"];
+	const symbolCandidate = candidate["symbol"];
+	if (typeof pathCandidate !== "string" || !isRepositoryPath(pathCandidate)) return invalidAdapterResult(adapterId);
+	const path = parseRepositoryPath(pathCandidate);
+	if (symbolCandidate !== void 0 && (typeof symbolCandidate !== "string" || !isUnicodeScalarText(symbolCandidate) || !isRepositorySymbol(symbolCandidate) || isCanonicalMoldeaPath(path))) return invalidAdapterResult(adapterId);
+	return freezeRecursively({
+		path,
+		...symbolCandidate === void 0 ? {} : { symbol: symbolCandidate }
+	});
+};
+var normalizeReferences = (candidate, adapterId) => {
+	if (!Array.isArray(candidate) || candidate.length === 0) return invalidAdapterResult(adapterId);
+	const references = candidate.map((reference) => normalizeReference(reference, adapterId));
+	const referenceKeys = /* @__PURE__ */ new Set();
+	for (const reference of references) {
+		const key = JSON.stringify([reference.path, reference.symbol ?? null]);
+		if (referenceKeys.has(key)) return invalidAdapterResult(adapterId);
+		referenceKeys.add(key);
+	}
+	return freezeRecursively(sortRepositoryReferences(references));
+};
+var normalizeEvidence = (candidate, context) => {
+	if (!isRecord$1(candidate) || !hasOnlyKeys(candidate, EVIDENCE_KEYS)) return invalidAdapterResult(context.adapterId);
+	const source = candidate["source"];
+	const kind = candidate["kind"];
+	const agentId = candidate["agentId"];
+	const capabilityKind = candidate["capabilityKind"];
+	const capabilityId = candidate["capabilityId"];
+	const runtimeName = candidate["runtimeName"];
+	if (source !== context.adapterId || typeof kind !== "string" || !EVIDENCE_KINDS.has(kind) || agentId !== null && !isSafeString(agentId) || capabilityKind !== null && capabilityKind !== "tool" && capabilityKind !== "skill" || capabilityId !== null && !isSafeString(capabilityId) || runtimeName !== null && (!isSafeString(runtimeName) || !isNonEmptySingleLine(runtimeName) || hasSurroundingWhitespace(runtimeName))) return invalidAdapterResult(context.adapterId);
+	const scopedAgent = agentId === null ? void 0 : context.agentsById.get(agentId);
+	if (agentId !== null && scopedAgent === void 0 || capabilityKind === null !== (capabilityId === null) || capabilityKind !== null && capabilityId !== null && (scopedAgent === void 0 || readCapability(scopedAgent, capabilityKind, capabilityId) === void 0)) return invalidAdapterResult(context.adapterId);
+	return freezeRecursively({
+		agentId,
+		capabilityId,
+		capabilityKind,
+		details: normalizeDetails(candidate["details"], context.adapterId),
+		kind,
+		references: normalizeReferences(candidate["references"], context.adapterId),
+		runtimeName,
+		source
+	});
+};
+var validateEvidenceReferences = async (evidence, context) => {
+	const entries = /* @__PURE__ */ new Map();
+	const operationOptions = context.signal === void 0 ? void 0 : { signal: context.signal };
+	for (const item of evidence) for (const reference of item.references) {
+		let entry = entries.get(reference.path);
+		if (entry === void 0 && !entries.has(reference.path)) {
+			entry = await context.repository.getEntry(reference.path, operationOptions);
+			entries.set(reference.path, entry);
+		}
+		if (entry?.type !== "file") return invalidAdapterResult(context.adapterId);
+	}
+};
+var normalizeDiagnostic = (candidate, context) => {
+	if (!isRecord$1(candidate) || !hasOnlyKeys(candidate, DIAGNOSTIC_KEYS)) return invalidAdapterResult(context.adapterId);
+	const source = candidate["source"];
+	const code = candidate["code"];
+	const message = candidate["message"];
+	const pathCandidate = candidate["path"];
+	const pointer = candidate["pointer"];
+	const namespace = `${context.adapterId.toUpperCase().replaceAll("-", "_")}_`;
+	if (source !== context.adapterId || !isSafeString(code) || !ADAPTER_CODE_PATTERN.test(code) || !code.startsWith(namespace) || code.length === namespace.length || !isSafeString(message) || message.length === 0 || pathCandidate !== null && (typeof pathCandidate !== "string" || !isRepositoryPath(pathCandidate)) || pointer !== null && (typeof pointer !== "string" || !isJsonPointer(pointer))) return invalidAdapterResult(context.adapterId);
+	const path = pathCandidate === null ? null : parseRepositoryPath(pathCandidate);
+	const range = normalizeRange(candidate["range"], context.adapterId);
+	if (path === null && (pointer !== null || range !== null)) return invalidAdapterResult(context.adapterId);
+	return freezeRecursively({
+		code,
+		details: normalizeDetails(candidate["details"], context.adapterId),
+		entity: normalizeEntity(candidate["entity"], context),
+		message,
+		path,
+		pointer,
+		range,
+		source
+	});
+};
+var compareNullableStrings$1 = (left, right) => {
+	return left === null ? right === null ? 0 : -1 : right === null ? 1 : compareExactStrings(left, right);
+};
+var compareEvidence = (left, right) => {
+	const leftReferences = JSON.stringify(left.references.map((reference) => [reference.path, reference.symbol ?? null]));
+	const rightReferences = JSON.stringify(right.references.map((reference) => [reference.path, reference.symbol ?? null]));
+	return compareExactStrings(left.source, right.source) || compareExactStrings(left.kind, right.kind) || compareNullableStrings$1(left.agentId, right.agentId) || compareNullableStrings$1(left.capabilityKind, right.capabilityKind) || compareNullableStrings$1(left.capabilityId, right.capabilityId) || compareNullableStrings$1(left.runtimeName, right.runtimeName) || compareExactStrings(leftReferences, rightReferences) || compareExactStrings(serializeDiagnosticDetails(left.details), serializeDiagnosticDetails(right.details));
+};
+var serializeEvidence = (evidence) => {
+	return JSON.stringify([
+		evidence.source,
+		evidence.kind,
+		evidence.agentId,
+		evidence.capabilityKind,
+		evidence.capabilityId,
+		evidence.runtimeName,
+		evidence.references.map((reference) => [reference.path, reference.symbol ?? null]),
+		serializeDiagnosticDetails(evidence.details)
+	]);
+};
+/**
+* Deduplicates and sorts normalized evidence from every completed adapter.
+* @param candidates The normalized evidence items to combine.
+* @returns A frozen deterministic evidence collection.
+*/
+var normalizeRuntimeAdapterEvidence = (candidates) => {
+	const evidence = /* @__PURE__ */ new Map();
+	for (const item of candidates) evidence.set(serializeEvidence(item), item);
+	return freezeRecursively([...evidence.values()].sort(compareEvidence));
+};
+/**
+* Validates and normalizes one untrusted runtime adapter result.
+* @param candidate The result returned by the adapter implementation.
+* @param context The invoking adapter scope, project, reader, limits, and signal.
+* @returns A promise resolving to frozen deterministic evidence and diagnostics.
+* @throws
+* - INVALID_REPOSITORY_PATH: An adapter repository reference path is invalid.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during validation.
+* - INVALID_SOURCE_DATA: The repository reader returned invalid contract data.
+* - RESOURCE_LIMIT_EXCEEDED: A Core or repository resource limit was exceeded.
+* - ABORTED: Adapter validation or a repository operation was aborted.
+* - ADAPTER_EXECUTION_FAILED: The adapter result violates its public contract.
+*/
+var validateRuntimeAdapterResult = async (candidate, context, outputCounts) => {
+	let diagnostics;
+	let evidence;
+	let validationState;
+	try {
+		if (!isRecord$1(candidate) || !hasOnlyKeys(candidate, ADAPTER_RESULT_KEYS)) return invalidAdapterResult(context.adapterId);
+		const evidenceValue = candidate["evidence"];
+		const diagnosticsValue = candidate["diagnostics"];
+		if (!Array.isArray(evidenceValue) || !Array.isArray(diagnosticsValue)) return invalidAdapterResult(context.adapterId);
+		const evidenceCandidates = evidenceValue;
+		const diagnosticCandidates = diagnosticsValue;
+		registerRawOutput(outputCounts, "evidence", evidenceCandidates.length, context);
+		registerRawOutput(outputCounts, "diagnostics", diagnosticCandidates.length, context);
+		validationState = {
+			...context,
+			agentsById: new Map(context.agents.map((agent) => [agent.id, agent])),
+			decisionIds: new Set(context.project.decisions.map(({ decision }) => decision.id))
+		};
+		diagnostics = diagnosticCandidates.map((diagnostic) => normalizeDiagnostic(diagnostic, validationState));
+		evidence = normalizeRuntimeAdapterEvidence(evidenceCandidates.map((evidenceCandidate) => normalizeEvidence(evidenceCandidate, validationState)));
+	} catch (error) {
+		if (error instanceof CoreOperationException && error.code === "RESOURCE_LIMIT_EXCEEDED") throw error;
+		return invalidAdapterResult(context.adapterId);
+	}
+	try {
+		await validateEvidenceReferences(evidence, validationState);
+		return freezeRecursively({
+			diagnostics: normalizeDiagnostics(diagnostics),
+			evidence
+		});
+	} catch (error) {
+		if (error instanceof RepositoryPathException || error instanceof RepositorySourceException || error instanceof CoreOperationException) throw error;
+		return invalidAdapterResult(context.adapterId);
+	}
+};
+//#endregion
+//#region src/adapter-execution/index.ts
+var isInspectionBoundaryFailure = (error) => {
+	return error instanceof RepositoryPathException || error instanceof RepositorySourceException || error instanceof CoreOperationException && error.operation === "inspect-project" && (error.code === "ABORTED" || error.code === "RESOURCE_LIMIT_EXCEEDED");
+};
+var invokeAdapter = async (adapter, project, session, options, outputCounts, signal) => {
+	const agents = freezeRecursively(project.agents.filter(({ declaration }) => declaration.runtime.id === adapter.id));
+	if (agents.length === 0) return freezeRecursively({
+		diagnostics: [],
+		evidence: []
+	});
+	const context = Object.freeze({
+		agents,
+		project,
+		repository: session.reader,
+		...signal === void 0 ? {} : { signal }
+	});
+	let candidate;
+	try {
+		session.throwIfAborted();
+		candidate = await adapter.inspect(context);
+		session.throwIfAborted();
+	} catch (error) {
+		session.throwIfAborted();
+		if (isInspectionBoundaryFailure(error)) throw error;
+		throw new CoreOperationException({
+			adapterId: adapter.id,
+			cause: error,
+			code: "ADAPTER_EXECUTION_FAILED",
+			operation: "inspect-project"
+		});
+	}
+	return validateRuntimeAdapterResult(candidate, {
+		adapterId: adapter.id,
+		agents,
+		limits: options.limits,
+		project,
+		repository: session.reader,
+		...signal === void 0 ? {} : { signal }
+	}, outputCounts);
+};
+/**
+* Invokes every applicable configured adapter in canonical ID order.
+* @param project The complete frozen universal project index.
+* @param session The shared inspection reader, cache, and resource budget.
+* @param options The immutable Core adapter registry and resource limits.
+* @param signal Optional cancellation shared by the complete inspection.
+* @returns A promise resolving to normalized evidence and adapter diagnostics.
+* @throws
+* - INVALID_REPOSITORY_PATH: An adapter repository path is invalid.
+* - ENTRY_NOT_FOUND: A requested repository entry is absent.
+* - ENTRY_NOT_FILE: A requested repository entry is not a regular file.
+* - ENTRY_NOT_DIRECTORY: A 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 adapter inspection.
+* - INVALID_SOURCE_DATA: The repository reader returned invalid contract data.
+* - RESOURCE_LIMIT_EXCEEDED: A Core or repository resource limit was exceeded.
+* - ABORTED: Adapter inspection or a repository operation was aborted.
+* - ADAPTER_EXECUTION_FAILED: An adapter failed or returned an invalid result.
+*/
+var inspectRuntimeAdapters = async (project, session, options, signal) => {
+	const evidence = [];
+	const diagnostics = [];
+	const outputCounts = {
+		diagnostics: 0,
+		evidence: 0
+	};
+	for (const adapter of options.adapters) {
+		const result = await invokeAdapter(adapter, project, session, options, outputCounts, signal);
+		evidence.push(...result.evidence);
+		diagnostics.push(...result.diagnostics);
+	}
+	return freezeRecursively({
+		diagnostics: normalizeDiagnostics(diagnostics),
+		evidence: normalizeRuntimeAdapterEvidence(evidence)
+	});
+};
+//#endregion
+//#region src/repository-inspection-session/index.ts
+var MANIFEST_PATH$3 = parseRepositoryPath("/moldea/moldea.yaml");
+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"];
+	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);
+	return {
+		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) => {
+	throw new CoreOperationException({
+		code: "RESOURCE_LIMIT_EXCEEDED",
+		limit,
+		operation: "inspect-project"
+	});
+};
+var createSourceOptions = (sessionSignal, operationSignal) => {
+	const signal = 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 frozen session whose reader owns inspection-local budgets and byte caching.
+* @throws
+* - ABORTED: Repository inspection was aborted before the session was created.
+*/
+var createRepositoryInspectionSession = (repository, limits, signal) => {
+	const readCache = /* @__PURE__ */ new Map();
+	const seenPaths = /* @__PURE__ */ new Set();
+	let totalBytesRead = 0;
+	const createAbortedException = (abortedSignal) => {
+		return new CoreOperationException({
+			cause: abortedSignal.reason,
+			code: "ABORTED",
+			operation: "inspect-project"
+		});
+	};
+	const registerPath = (path) => {
+		if (path === REPOSITORY_ROOT || seenPaths.has(path)) return;
+		if (seenPaths.size >= limits.maxEntries) return throwResourceLimitExceeded("maxEntries");
+		seenPaths.add(path);
+	};
+	const throwIfSignalAborted = (operationSignal) => {
+		const abortedSignal = signal?.aborted ? signal : operationSignal?.aborted ? operationSignal : null;
+		if (abortedSignal === null) return;
+		throw createAbortedException(abortedSignal);
+	};
+	throwIfSignalAborted();
+	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 listEntries = (options) => {
+		const prefix = options?.prefix === void 0 ? REPOSITORY_ROOT : parseRepositoryPath(options.prefix);
+		return { async *[Symbol.asyncIterator]() {
+			throwIfSignalAborted(options?.signal);
+			registerPath(prefix);
+			const yieldedPaths = /* @__PURE__ */ new Set();
+			const sourceOptions = createSourceOptions(signal, options?.signal);
+			const sourceListOptions = sourceOptions === void 0 ? { prefix } : {
+				prefix,
+				...sourceOptions
+			};
+			for await (const candidate of repository.listEntries(sourceListOptions)) {
+				throwIfSignalAborted(options?.signal);
+				const entry = copyReaderEntry$1(candidate, "list-entries", prefix);
+				if (!isStrictDescendant(entry.path, prefix) || yieldedPaths.has(entry.path)) return invalidSourceData$3("list-entries", entry.path);
+				yieldedPaths.add(entry.path);
+				registerPath(entry.path);
+				yield entry;
+			}
+			throwIfSignalAborted(options?.signal);
+		} };
+	};
+	const loadFile = async (path) => {
+		const content = await repository.readFile(path, createSourceOptions(signal, void 0));
+		throwIfSignalAborted();
+		if (!(content instanceof Uint8Array)) return invalidSourceData$3("read-file", path);
+		const fileLimit = path === MANIFEST_PATH$3 ? "maxManifestBytes" : "maxFileBytes";
+		if (content.byteLength > limits[fileLimit]) return throwResourceLimitExceeded(fileLimit);
+		if (totalBytesRead + content.byteLength > limits.maxTotalBytesRead) return throwResourceLimitExceeded("maxTotalBytesRead");
+		totalBytesRead += content.byteLength;
+		return new Uint8Array(content);
+	};
+	const removeFailedRead = async (path, readPromise) => {
+		try {
+			return await readPromise;
+		} catch (error) {
+			readCache.delete(path);
+			throw error;
+		}
+	};
+	const waitForRead = (readPromise, operationSignal) => {
+		throwIfSignalAborted(operationSignal);
+		if (operationSignal === void 0 || operationSignal === signal) return readPromise;
+		let handleAbort;
+		const cancellationPromise = new Promise((resolve, reject) => {
+			handleAbort = () => {
+				const abortedSignal = signal?.aborted ? signal : operationSignal;
+				reject(createAbortedException(abortedSignal));
+			};
+			operationSignal.addEventListener("abort", handleAbort, { once: true });
+			if (operationSignal.aborted) handleAbort();
+		});
+		return Promise.race([readPromise, cancellationPromise]).finally(() => {
+			operationSignal.removeEventListener("abort", handleAbort);
+		});
+	};
+	const readFile = async (path, options) => {
+		const parsedPath = parseRepositoryPath(path);
+		throwIfSignalAborted(options?.signal);
+		registerPath(parsedPath);
+		let readPromise = readCache.get(parsedPath);
+		if (readPromise === void 0) {
+			readPromise = removeFailedRead(parsedPath, loadFile(parsedPath));
+			readCache.set(parsedPath, readPromise);
+		}
+		const content = await waitForRead(readPromise, options?.signal);
+		throwIfSignalAborted(options?.signal);
+		return new Uint8Array(content);
+	};
+	const reader = Object.freeze({
+		getEntry,
+		listEntries,
+		readFile
+	});
+	return Object.freeze({
+		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, "inspect-project");
+	const value = trimRepositoryFormatWhitespace(asset.content);
+	const scalarLength = countUnicodeScalars$1(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, "inspect-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",
+		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.readFile(path, signal === void 0 ? void 0 : { signal });
+	if (!(content instanceof Uint8Array)) return invalidSourceData$2(path);
+	const normalized = normalizeTextDocument({
+		content,
+		path
+	}, limits, "inspect-project");
+	if (!normalized.valid || normalized.text === null) return freezeRecursively({
+		asset: null,
+		diagnostics: normalized.diagnostics,
+		valid: false
+	});
+	return freezeRecursively({
+		asset: {
+			content: normalized.text.value,
+			digest: await calculateNormalizedTextDigest(normalized.text),
+			path,
+			scalarLength: normalized.text.scalarLength,
+			utf8ByteLength: normalized.text.utf8ByteLength
+		},
+		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, "inspect-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, "inspect-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"];
+	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);
+	return {
+		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", 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);
+	};
+	return freezeRecursively({
+		agents: [...working.agents.values()].sort((left, right) => compareExactStrings(left.id, right.id)).map((agent) => freezeRecursively({ ...agent })),
+		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", 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, "inspect-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.listEntries(listOptions)) {
+		const entry = copyReaderEntry(candidate, "list-entries");
+		if (!entry.path.startsWith("/moldea/")) return invalidSourceData$1("list-entries", entry.path);
+		if (seenPaths.has(entry.path)) return invalidSourceData$1("list-entries", 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", MANIFEST_PATH$1);
+	if (projectEntry !== null !== listedProject) return invalidSourceData$1("list-entries", 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, "inspect-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",
+		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 limits and adapter snapshots.
+* @param signal Optional cancellation forwarded to every repository read.
+* @returns A deeply immutable internal decision set and its deterministic diagnostics.
+* @throws
+* - ENTRY_NOT_FOUND: A discovered decision disappeared from the reader snapshot.
+* - ENTRY_NOT_FILE: A discovered decision 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 decision reads.
+* - INVALID_SOURCE_DATA: The repository reader returned invalid contract data.
+* - RESOURCE_LIMIT_EXCEEDED: A Core or repository resource limit was exceeded.
+* - ABORTED: Decision inspection or a repository operation was aborted.
+*/
+var readDecisionGraph = async (repository, paths, options, signal) => {
+	options = createCoreOperationOptionsSnapshot(options);
+	const diagnostics = createCoreDiagnosticCollector(options.limits, "inspect-project");
+	const candidates = [];
+	const decisions = [];
+	const readOptions = signal === void 0 ? void 0 : { signal };
+	for (const path of [...paths].sort(compareExactStrings)) {
+		const content = await repository.readFile(path, readOptions);
+		if (!(content instanceof Uint8Array)) return invalidSourceData(path);
+		const parsed = await parseDecisionDocument({
+			content: content.slice(),
+			path
+		}, options, "inspect-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, "inspect-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/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 {
+		canonicalDigest: canonicalInstruction.digest,
+		digest: mirrorResult.asset.digest,
+		path: mirrorPath
+	};
+};
+/**
+* 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, "inspect-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, "inspect-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, "inspect-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/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) => {
+	for (const [index, reference] of [...references ?? []].sort(compareReferences).entries()) candidates.push({
+		entity,
+		kind: "reference",
+		path: reference.path,
+		pointer: childPointer(pointer, String(index))
+	});
+};
+/** 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);
+	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`,
+		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)
+	});
+	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)
+		});
+	}
+	for (const variableId of Object.keys(bindings?.variableProviders ?? {}).sort(compareExactStrings)) {
+		const reference = bindings?.variableProviders?.[variableId];
+		if (reference !== void 0) candidates.push({
+			entity: {
+				agentId,
+				variableId
+			},
+			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 ? null : { 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.
+* @returns Deeply immutable deterministic repository-reference diagnostics.
+* @throws
+* - INVALID_REPOSITORY_PATH: A repository path is invalid.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during validation.
+* - 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 a repository lookup was aborted.
+*/
+var validateRepositoryReferences = async (repository, manifestPath, manifest, discovery, limits, signal) => {
+	const collector = createCoreDiagnosticCollector(limits, "inspect-project");
+	const blockedPaths = new Set(discovery.diagnostics.flatMap((diagnostic) => diagnostic.path === null ? [] : [diagnostic.path]));
+	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);
+		}
+		validateCandidate(candidate, await entryPromise, manifestPath, collector);
+	}
+	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, "inspect-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 before runtime adapter validation.
+* @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: A repository path is invalid.
+* - ENTRY_NOT_FOUND: A discovered file disappeared from the reader snapshot.
+* - ENTRY_NOT_FILE: A discovered file changed type during inspection.
+* - ENTRY_NOT_DIRECTORY: A discovered directory 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 inspection.
+* - 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 a repository operation was aborted.
+*/
+var inspectUniversalProject = async (context, options) => {
+	options = createCoreOperationOptionsSnapshot(options);
+	const { session, signal } = context;
+	const collector = createCoreDiagnosticCollector(options.limits, "inspect-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;
+	let runtimeLocations = [];
+	if (moldeaRoot?.type === "directory") {
+		manifestEntry = await session.reader.getEntry(MANIFEST_PATH, operationOptions);
+		if (manifestEntry?.type === "file") {
+			const parsedManifest = await inspectManifestDocument({
+				content: await session.reader.readFile(MANIFEST_PATH, operationOptions),
+				path: MANIFEST_PATH
+			}, options, "inspect-project");
+			formatVersion = parsedManifest.formatVersion;
+			runtimeLocations = parsedManifest.runtimeLocations;
+			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));
+		const mirrorInspection = await inspectMirrors(session.reader, manifestPath, agents, options, signal);
+		agentMirrors = mirrorInspection.agentMirrors;
+		addDiagnostics(collector, mirrorInspection.diagnostics);
+	}
+	session.throwIfAborted();
+	const diagnostics = collector.finalize();
+	const project = diagnostics.length === 0 && 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,
+		formatVersion,
+		project,
+		runtimeLocations
+	});
+};
+//#endregion
+//#region src/project-inspection/index.ts
+var isRecord = (candidate) => {
+	return typeof candidate === "object" && candidate !== null && !Array.isArray(candidate);
+};
+var invalidArgument = () => {
+	throw new CoreOperationException({
+		code: "INVALID_ARGUMENT",
+		operation: "inspect-project"
+	});
+};
+var isRepositoryReader = (candidate) => {
+	return isRecord(candidate) && typeof candidate["getEntry"] === "function" && typeof candidate["listEntries"] === "function" && typeof candidate["readFile"] === "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();
+		const repository = candidate["repository"];
+		const signal = candidate["signal"];
+		if (!isRepositoryReader(repository) || signal !== void 0 && !isAbortSignal(signal)) return invalidArgument();
+		return {
+			repository,
+			...signal === void 0 ? {} : { signal }
+		};
+	} catch (error) {
+		if (error instanceof CoreOperationException) throw error;
+		return invalidArgument();
+	}
+};
+/**
+* Inspects one coherent repository snapshot through universal and adapter 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: A repository path is invalid.
+* - ENTRY_NOT_FOUND: A discovered file disappeared from the reader snapshot.
+* - ENTRY_NOT_FILE: A discovered file changed type during inspection.
+* - ENTRY_NOT_DIRECTORY: A discovered directory 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 inspection.
+* - 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 a repository operation was aborted.
+* - ADAPTER_EXECUTION_FAILED: A runtime adapter failed or returned an invalid result.
+*/
+var inspectProject = 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);
+	if (universal.project === null) return freezeRecursively({
+		diagnostics: universal.diagnostics,
+		evidence: [],
+		formatVersion: universal.formatVersion,
+		project: null,
+		valid: false
+	});
+	const availabilityDiagnostics = validateRuntimeAdapterAvailability(universal.runtimeLocations, universal.project.formatVersion, operationOptions);
+	if (availabilityDiagnostics.length > 0) return freezeRecursively({
+		diagnostics: availabilityDiagnostics,
+		evidence: [],
+		formatVersion: universal.formatVersion,
+		project: null,
+		valid: false
+	});
+	const adapterInspection = await inspectRuntimeAdapters(universal.project, session, operationOptions, validatedInput.signal);
+	const valid = adapterInspection.diagnostics.length === 0;
+	return freezeRecursively({
+		diagnostics: adapterInspection.diagnostics,
+		evidence: adapterInspection.evidence,
+		formatVersion: universal.formatVersion,
+		project: valid ? universal.project : null,
+		valid
+	});
+};
+//#endregion
+//#region src/core/index.ts
+/**
+* Creates one immutable Core instance from detached configuration snapshots.
+* @param options Optional runtime adapters and resource-limit overrides.
+* @returns A frozen Core instance safe for concurrent independent operations.
+* @throws
+* - DUPLICATE_ADAPTER_ID: A runtime adapter ID is registered more than once.
+* - RESERVED_ADAPTER_ID: A reserved runtime adapter ID was supplied.
+* - INVALID_ADAPTER_DEFINITION: A runtime adapter definition is invalid.
+* - INVALID_RESOURCE_LIMIT: A Core resource limit is invalid.
+*/
+var createCore = (options) => {
+	const snapshot = normalizeCoreOptions(options);
+	return freezeRecursively({
+		calculateContentDigest: (input) => {
+			return calculateContentDigest(input, createCoreOperationOptionsSnapshot(snapshot).limits);
+		},
+		inspectProject: (input) => inspectProject(input, createCoreOperationOptionsSnapshot(snapshot)),
+		normalizeText: (input) => {
+			return normalizeTextDocument(input, createCoreOperationOptionsSnapshot(snapshot).limits, "normalize-text");
+		},
+		parseDecision: (input) => parseDecisionDocument(input, createCoreOperationOptionsSnapshot(snapshot)),
+		parseManifest: (input) => parseManifestDocument(input, createCoreOperationOptionsSnapshot(snapshot))
+	});
+};
+//#endregion
+export { CoreConfigurationException, CoreOperationException, DEFAULT_CORE_RESOURCE_LIMITS, SUPPORTED_REPOSITORY_FORMAT_VERSIONS, createCore };
+
+//# sourceMappingURL=index.js.map