@moldea.ai/core 9.1.0 → 9.2.0

package/README.md

@@ -88,12 +88,18 @@ Core checks each declared binding's file and, when a symbol is named, its syntax
 
 Every diagnostic has `severity`, `group`, and stable `source: 'core'`. The groups are `discovery`, `manifest`, `references`, `agents`, `mirrors`, and `integration`. The result reports complete `errorCount`, unaccepted `warningCount`, `acceptedWarningCount`, and `diagnosticCount`; warnings do not invalidate a project. Manifest `acceptedWarnings` match a warning's code, subject, and qualifier and require a non-empty reason. Accepted findings remain visible. Unmatched impact patterns are best-effort warnings; a skipped check never makes an acceptance obsolete. Validation and inspection also check the root `/AGENTS.md` managed block against its referenced skill installation, reporting missing blocks, missing installation files, drift, or a link that doesn't lead to a file in the repository, with its reason as qualifier, as acceptable integration warnings. They also check whether `/CLAUDE.md`, `/.claude/CLAUDE.md`, or, without shared files, `/CLAUDE.local.md` loads AGENTS.md through an import line or a link, reporting `MOLDEA_INTEGRATION_CLAUDE_IMPORT_MISSING` when it does not. An optional `instructions` reader supplies the four instruction files; links are followed inside the repository with Repository's `resolveRepositoryLink`, and link targets, the skill installation, and every other check read `repository`. `parseIntegrationBlock(text)` extracts the safe relative installation path or a reason it could not be found. Manifest-only operations and `scope` do not read the integration.
 
+Managed-block comparison tolerates LF/CRLF differences, an optional final line break, empty lines immediately inside the markers, and spaces or tabs after marker comments. It preserves exact instruction text and internal whitespace; duplicate, reversed, missing, or otherwise malformed markers still produce diagnostics.
+
+Core 9.2 supplies normalized scalar-based source ranges for pointer-addressed manifest and decision YAML diagnostics, including cross-file findings and unmatched acceptances. Missing members point to their nearest existing ancestor; existing explicit ranges stay unchanged. See [diagnostic locations](docs/diagnostics.md) for member spans and unavailable-source behavior.
+
 ## Resource and trust boundaries
 
 Core uses independent limits for distinct entries, total bytes read, per-file bytes, manifest bytes, logical retained bytes, diagnostics, and coverage records. The default logical retained-memory ceiling is 512 MiB. Before reading a supported source for export analysis, Core checks `maxFileBytes`, confirms read-buffer headroom, and reserves `65536 + sourceBytes * (8 + 512)` bytes for text and syntax nodes. An oversized source or reservation miss records `resource-limit` without a source read; a subsequent failed read, cancellation, or operation budget failure rejects the whole operation. Each distinct source is parsed at most once per operation. Source buffers and syntax reservations are released after analysis; only export names remain in the inventory cache. Core executes no repository code, follows instruction links only inside the snapshot, receives no host path or source credential, and returns logical paths only.
 
 Logical `RESOURCE_LIMIT_EXCEEDED` exceptions identify the exceeded limit, its configured maximum, the observed or projected usage, and `reduce-input-or-increase-limit`. Verified isolated-worker heap exhaustion uses `review-inspection-capacity` with unknown observed usage. Fixed transport limits have no next action. Core refuses an operation before allocating retained state beyond the applicable ceiling.
 
+Private manifest and decision YAML trees and their pointer-lookup storage also reserve logical retained memory until final locations are resolved. These reservations are released on success or failure; they do not remain in prepared inspection handles.
+
 ## Development
 
 From the monorepo root:

package/dist/analysis-worker.js

@@ -1,4 +1,4 @@
-import { n as normalizeCoreOptions } from "./chunks/options-C5360E_N.js";
+import { n as normalizeCoreOptions } from "./chunks/options-BXKLnSDR.js";
 import { n as CoreOperationException } from "./chunks/exceptions-AT654xUL.js";
 import { a as encodeInspectionMessage, d as NODE_INSPECTION_TRANSPORT_BYTES, i as decodeInspectionMessage, n as serializeInspectionFailure, o as NODE_INSPECTION_FILE_PAGE_BYTES, r as createInspectionProcessFailure, t as deserializeInspectionFailure } from "./chunks/errors-Uvb-9X1u.js";
 import { a as parseRpcLinkText, i as parseRpcFilePage, n as parseRpcEntry, r as parseRpcEntryPage } from "./chunks/repository-rpc-B9YaeLba.js";
@@ -91,7 +91,7 @@ var repository = createProxyReader("repository", start.snapshot);
 var instructions = start.instructions === null ? null : createProxyReader("instructions", start.instructions.snapshot);
 /** Prepares the fixed Core implementation after the parent acknowledges the heap. */
 var prepare = async () => {
-	const { createCore } = await import("./chunks/core-CFmT3SRC.js").then((n) => n.t);
+	const { createCore } = await import("./chunks/core-DOzzzqoB.js").then((n) => n.t);
 	inspection = await createCore(normalizeCoreOptions({ limits: {
 		...start.limits,
 		maxRetainedBytes: start.limits.maxRetainedBytes - NODE_INSPECTION_TRANSPORT_BYTES

package/dist/chunks/{core-CFmT3SRC.js → core-DOzzzqoB.js}

@@ -1,6 +1,6 @@
-import { a as escapeJsonPointerSegment, i as createCoreDiagnosticCollector, n as normalizeCoreOptions, o as normalizeDiagnostics, r as countDiagnosticsBySeverity, s as createNullPrototypeRecord, t as createCoreOperationOptionsSnapshot } from "./options-C5360E_N.js";
+import { a as escapeJsonPointerSegment, c as measureYamlRetainedBytes, i as createCoreDiagnosticCollector, l as parseStrictYaml, n as normalizeCoreOptions, o as locateDiagnosticRanges, r as countDiagnosticsBySeverity, s as normalizeDiagnostics, t as createCoreOperationOptionsSnapshot, u as createNullPrototypeRecord } from "./options-BXKLnSDR.js";
 import { n as CoreOperationException } from "./exceptions-AT654xUL.js";
-import { _ as trimRepositoryFormatWhitespace, a as createSourceLocator, c as calculateContentDigest, d as countUnicodeScalars, f as hasNonWhitespace, g as parseDecisionIdFromPath, h as isVariableId, i as parseStrictYaml, l as calculateNormalizedTextDigest, m as isRuntimeGuidancePath, n as inspectManifestDocument, o as collectManifestScopeDeclarations, p as isContextPath, r as parseManifestDocument, s as matchesRepositoryGlob, t as matchManifestScope, u as normalizeTextDocument } from "./scope-CNg6Gnpi.js";
+import { a as collectManifestScopeDeclarations, c as calculateNormalizedTextDigest, d as hasNonWhitespace, f as isContextPath, g as trimRepositoryFormatWhitespace, h as parseDecisionIdFromPath, i as createSourceLocator, l as normalizeTextDocument, m as isVariableId, n as inspectManifestDocument, o as matchesRepositoryGlob, p as isRuntimeGuidancePath, r as parseManifestDocument, s as calculateContentDigest, t as matchManifestScope, u as countUnicodeScalars } from "./scope-COlv6gct.js";
 import { ERRORS, compareCodePoints, deepFreeze, findMarkedRegion, isObjectValid } from "jg-utilities";
 import { hasErrorCode } from "jg-exception";
 import { REPOSITORY_LINK_TEXT_MAX_BYTES, REPOSITORY_ROOT, RepositorySourceException, compareRepositoryPaths, createRepositoryIdentity, isRepositoryPath, parseRepositoryPath, resolveRepositoryLink } from "@moldea.ai/repository";
@@ -352,7 +352,7 @@ var validateDecisionBody = (body, range, context) => {
 * - 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") => {
+var inspectDecisionDocument = async (input, options, operation = "parse-decision") => {
 	options = createCoreOperationOptionsSnapshot(options);
 	const normalized = normalizeTextDocument(input, options.limits, operation);
 	const path = parseRepositoryPath(input.path);
@@ -366,7 +366,8 @@ var parseDecisionDocument = async (input, options, operation = "parse-decision")
 	if (!normalized.valid || normalized.text === null) return deepFreeze({
 		decision: null,
 		diagnostics: diagnostics.finalize(),
-		valid: false
+		valid: false,
+		yamlRoot: null
 	});
 	const context = {
 		decisionId,
@@ -376,15 +377,19 @@ var parseDecisionDocument = async (input, options, operation = "parse-decision")
 	const locator = createSourceLocator(normalized.text.value);
 	const sections = extractDecisionSections(normalized.text.value, locator, context);
 	let metadata = null;
+	let yamlRoot = null;
 	if (sections !== null) {
 		validateDecisionBody(sections.body, sections.bodyRange, context);
 		const parsed = parseStrictYaml(sections.yaml, path, locator, diagnostics);
+		yamlRoot = parsed.value;
 		if (parsed.valid && parsed.value !== null) metadata = validateDecisionFrontmatter(parsed.value, context);
 	}
+	const locatedDiagnostics = locateDiagnosticRanges(diagnostics.finalize(), new Map(yamlRoot === null ? [] : [[path, yamlRoot]]));
 	if (decisionId === null || sections === null || metadata === null || diagnostics.size > 0) return deepFreeze({
 		decision: null,
-		diagnostics: diagnostics.finalize(),
-		valid: false
+		diagnostics: locatedDiagnostics,
+		valid: false,
+		yamlRoot
 	});
 	const digest = await calculateNormalizedTextDigest(normalized.text);
 	const asset = {
@@ -404,8 +409,25 @@ var parseDecisionDocument = async (input, options, operation = "parse-decision")
 			status: metadata.status,
 			supersedes: metadata.supersedes
 		},
-		diagnostics: diagnostics.finalize(),
-		valid: true
+		diagnostics: locatedDiagnostics,
+		valid: true,
+		yamlRoot
+	});
+};
+/**
+* Parses a decision without exposing private YAML nodes to public callers.
+* @returns The immutable 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") => {
+	const inspection = await inspectDecisionDocument(input, options, operation);
+	return deepFreeze({
+		decision: inspection.decision,
+		diagnostics: inspection.diagnostics,
+		valid: inspection.valid
 	});
 };
 //#endregion
@@ -1751,6 +1773,7 @@ var sortDecisions = (decisions) => {
 * @param paths The decision candidates retained by canonical discovery.
 * @param options The immutable Core limit snapshot.
 * @param signal Optional cancellation forwarded to every repository read.
+* @param retainYamlRoot Optional inspection owner that admits private roots to its memory ledger.
 * @returns A deeply immutable internal decision set and its deterministic diagnostics.
 * @throws
 * - ENTRY_NOT_FOUND: The requested repository entry was not found.
@@ -1764,7 +1787,7 @@ var sortDecisions = (decisions) => {
 * - ABORTED: The Core operation was aborted.
 * - ABORTED: The repository operation was aborted.
 */
-var readDecisionGraph = async (repository, paths, options, signal) => {
+var readDecisionGraph = async (repository, paths, options, signal, retainYamlRoot) => {
 	options = createCoreOperationOptionsSnapshot(options);
 	const diagnostics = createCoreDiagnosticCollector(options.limits, "validate-project");
 	const candidates = [];
@@ -1773,10 +1796,11 @@ var readDecisionGraph = async (repository, paths, options, signal) => {
 	for (const path of [...paths].sort(compareCodePoints)) {
 		const content = await repository.readCompleteFile(path, readOptions);
 		if (!(content instanceof Uint8Array)) return invalidSourceData(path);
-		const parsed = await parseDecisionDocument({
+		const parsed = await inspectDecisionDocument({
 			content: content.slice(),
 			path
 		}, options, "validate-project");
+		if (parsed.yamlRoot !== null) retainYamlRoot?.(path, parsed.yamlRoot);
 		for (const diagnostic of parsed.diagnostics) diagnostics.merge(diagnostic);
 		candidates.push({
 			decision: parsed.decision,
@@ -1884,18 +1908,36 @@ var MARKERS = {
 };
 /**
 * Finds the managed block's region with the skill writer's region semantics: one start and one end
-* marker, each on its own line, the start first.
+* marker, each on its own line with optional trailing spaces or tabs, the start first.
 * @param text The instruction document.
 * @returns The region, or why the document has none.
 */
 var parseManagedIntegrationRegion = (text) => {
 	try {
-		return findMarkedRegion(text, MARKERS) ?? "block-missing";
+		const region = findMarkedRegion(text.replace(/(<!-- moldea:(?:start|end) -->)[ \t]+(?=\r?$)/gmu, "$1"), MARKERS);
+		if (region === null) return "block-missing";
+		const start = text.indexOf(MARKERS.start);
+		const closingLineBreak = text.indexOf("\n", text.indexOf(MARKERS.end));
+		return {
+			start,
+			end: closingLineBreak === -1 ? text.length : closingLineBreak + 1,
+			lineEnding: region.lineEnding
+		};
 	} catch (error) {
 		if (hasErrorCode(error, ERRORS.INVALID_MARKED_REGION)) return "block-invalid";
 		throw error;
 	}
 };
+/** Removes only managed-envelope formatting differences, preserving all instruction content. */
+var normalizeManagedIntegrationBlock = (text) => {
+	const normalized = text.replaceAll("\r\n", "\n").replace(/(<!-- moldea:(?:start|end) -->)[ \t]+(?=\n|$)/gu, "$1");
+	if (!normalized.startsWith(`${MARKERS.start}\n`) || !(normalized.endsWith(MARKERS.end) || normalized.endsWith(`${MARKERS.end}\n`))) return normalized;
+	let start = MARKERS.start.length;
+	let end = normalized.lastIndexOf(MARKERS.end);
+	while (start < end && normalized[start] === "\n") start++;
+	while (end > start && normalized[end - 1] === "\n") end--;
+	return `${MARKERS.start}\n${normalized.slice(start, end)}\n${MARKERS.end}`;
+};
 /**
 * Extracts the relative installation path from the fixed relevance-gate command without executing it.
 * @returns The safe installation path or the reason it could not be obtained.
@@ -2068,8 +2110,8 @@ var checkAgentsDocument = async (context, report, load, entryDetails) => {
 			const renderedReservation = (asset.text.length + occurrences * skillPath.length) * 8;
 			ledger.reserve(renderedReservation);
 			try {
-				const expected = asset.text.replaceAll("{{skill-path}}", skillPath).replace(/\r\n?/g, "\n").replaceAll("\n", region.lineEnding);
-				if (document.text.slice(region.start, region.end) !== expected) return report("MOLDEA_INTEGRATION_BLOCK_STALE", { referencedPath: `/${skillPath}` });
+				const expected = normalizeManagedIntegrationBlock(asset.text.replaceAll("{{skill-path}}", skillPath).replace(/\r\n?/gu, "\n"));
+				if (normalizeManagedIntegrationBlock(document.text.slice(region.start, region.end)) !== expected) return report("MOLDEA_INTEGRATION_BLOCK_STALE", { referencedPath: `/${skillPath}` });
 			} finally {
 				ledger.release(renderedReservation);
 			}
@@ -3117,86 +3159,102 @@ var inspectUniversalProject = async (context, options) => {
 	const coverage = [];
 	const collector = createCoreDiagnosticCollector(options.limits, "validate-project");
 	const operationOptions = signal === void 0 ? void 0 : { signal };
-	const moldeaRoot = await session.reader.getEntry(MOLDEA_ROOT, operationOptions);
-	let manifestEntry = null;
-	let projectEntry = null;
-	let indexedManifest = null;
-	let formatVersion = null;
-	if (moldeaRoot?.type === "directory") {
-		manifestEntry = await session.reader.getEntry(MANIFEST_PATH, operationOptions);
-		if (manifestEntry?.type === "file") {
-			const content = await session.reader.readCompleteFile(MANIFEST_PATH, operationOptions);
-			const parsedManifest = await inspectManifestDocument({
-				content,
-				path: MANIFEST_PATH
-			}, options, "validate-project");
-			formatVersion = parsedManifest.formatVersion;
-			addDiagnostics(collector, parsedManifest.diagnostics);
-			if (parsedManifest.asset !== null && parsedManifest.manifest !== null) indexedManifest = {
-				asset: parsedManifest.asset,
-				value: parsedManifest.manifest
-			};
+	const yamlRoots = /* @__PURE__ */ new Map();
+	const memory = getRetainedMemory(session.reader);
+	let retainedYamlBytes = 0;
+	/** Reserves each parsed tree until final cross-file and acceptance locations are resolved. */
+	const retainYamlRoot = (path, root) => {
+		const bytes = measureYamlRetainedBytes(root);
+		memory.reserve(bytes);
+		retainedYamlBytes += bytes;
+		yamlRoots.set(path, root);
+	};
+	try {
+		const moldeaRoot = await session.reader.getEntry(MOLDEA_ROOT, operationOptions);
+		let manifestEntry = null;
+		let projectEntry = null;
+		let indexedManifest = null;
+		let formatVersion = null;
+		if (moldeaRoot?.type === "directory") {
+			manifestEntry = await session.reader.getEntry(MANIFEST_PATH, operationOptions);
+			if (manifestEntry?.type === "file") {
+				const content = await session.reader.readCompleteFile(MANIFEST_PATH, operationOptions);
+				const parsedManifest = await inspectManifestDocument({
+					content,
+					path: MANIFEST_PATH
+				}, options, "validate-project");
+				if (parsedManifest.yamlRoot !== null) retainYamlRoot(MANIFEST_PATH, parsedManifest.yamlRoot);
+				formatVersion = parsedManifest.formatVersion;
+				addDiagnostics(collector, parsedManifest.diagnostics);
+				if (parsedManifest.asset !== null && parsedManifest.manifest !== null) indexedManifest = {
+					asset: parsedManifest.asset,
+					value: parsedManifest.manifest
+				};
+			}
+			projectEntry = await session.reader.getEntry(PROJECT_PATH, operationOptions);
 		}
-		projectEntry = await session.reader.getEntry(PROJECT_PATH, operationOptions);
-	}
-	const projectFile = await readProjectFile(session.reader, projectEntry?.type === "file" ? PROJECT_PATH : null, options, signal);
-	addDiagnostics(collector, projectFile.diagnostics);
-	const discovery = await discoverCanonicalAssets(session.reader, options.limits, signal, {
-		manifest: manifestEntry,
-		moldeaRoot,
-		project: projectEntry
-	});
-	addDiagnostics(collector, discovery.diagnostics);
-	session.throwIfAborted();
-	const projectAssets = await readProjectAssets(session.reader, indexedManifest?.value ?? null, discovery, options, signal, projectFile);
-	addDiagnostics(collector, projectAssets.diagnostics);
-	const runtimeGuidance = await readRuntimeGuidance(session.reader, discovery.inventory.manifest ?? MANIFEST_PATH, indexedManifest?.value ?? null, discovery, options, signal);
-	addDiagnostics(collector, runtimeGuidance.diagnostics);
-	const decisionGraph = await readDecisionGraph(session.reader, discovery.inventory.decisions, options, signal);
-	addDiagnostics(collector, decisionGraph.diagnostics);
-	let agents = [];
-	let agentMirrors = [];
-	if (indexedManifest !== null) {
-		const manifestPath = indexedManifest.asset.path;
-		const agentAssets = await inspectAgentAssets(session.reader, indexedManifest.value, discovery, options, signal);
-		agents = agentAssets.agents;
-		addDiagnostics(collector, agentAssets.diagnostics);
-		addDiagnostics(collector, validateManifestRelationships(manifestPath, indexedManifest.value, discovery, decisionGraph.decisions, options.limits));
-		addDiagnostics(collector, await validateRepositoryReferences(session.reader, manifestPath, indexedManifest.value, discovery, options.limits, signal, coverage));
-		const mirrorInspection = await inspectMirrors(session.reader, manifestPath, agents, options, signal);
-		agentMirrors = mirrorInspection.agentMirrors;
-		addDiagnostics(collector, mirrorInspection.diagnostics);
+		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, retainYamlRoot);
+		addDiagnostics(collector, decisionGraph.diagnostics);
+		let agents = [];
+		let agentMirrors = [];
+		if (indexedManifest !== null) {
+			const manifestPath = indexedManifest.asset.path;
+			const agentAssets = await inspectAgentAssets(session.reader, indexedManifest.value, discovery, options, signal);
+			agents = agentAssets.agents;
+			addDiagnostics(collector, agentAssets.diagnostics);
+			addDiagnostics(collector, validateManifestRelationships(manifestPath, indexedManifest.value, discovery, decisionGraph.decisions, options.limits));
+			addDiagnostics(collector, await validateRepositoryReferences(session.reader, manifestPath, indexedManifest.value, discovery, options.limits, signal, coverage));
+			const mirrorInspection = await inspectMirrors(session.reader, manifestPath, agents, options, signal);
+			agentMirrors = mirrorInspection.agentMirrors;
+			addDiagnostics(collector, mirrorInspection.diagnostics);
+		}
+		session.throwIfAborted();
+		addDiagnostics(collector, await inspectCodingAgentIntegration(session.reader, session.instructions, options.limits, signal));
+		const patterns = indexedManifest === null ? {
+			completed: false,
+			diagnostics: []
+		} : await inspectImpactPatterns(session.reader, indexedManifest.value, options.limits, signal);
+		session.throwIfAborted();
+		addDiagnostics(collector, patterns.diagnostics);
+		const diagnostics = locateDiagnosticRanges(applyWarningAcceptances(collector.finalize(), indexedManifest?.value.acceptedWarnings ?? [], /* @__PURE__ */ new Set([...[
+			"MOLDEA_INTEGRATION_BLOCK_MISSING",
+			"MOLDEA_INTEGRATION_SKILL_MISSING",
+			"MOLDEA_INTEGRATION_BLOCK_STALE",
+			"MOLDEA_INTEGRATION_LINK_UNRESOLVED",
+			"MOLDEA_INTEGRATION_CLAUDE_IMPORT_MISSING"
+		], ...patterns.completed ? ["MOLDEA_IMPACT_PATTERN_UNMATCHED"] : []]), options.limits), yamlRoots);
+		const project = !diagnostics.some((diagnostic) => diagnostic.severity === "error") && indexedManifest !== null && projectAssets.project !== null ? createProjectIndex({
+			agentMirrors,
+			agents,
+			context: projectAssets.context,
+			decisions: decisionGraph.decisions,
+			manifest: indexedManifest,
+			project: projectAssets.project,
+			runtimes: runtimeGuidance.runtimes
+		}) : null;
+		return deepFreeze({
+			diagnostics,
+			coverage,
+			formatVersion,
+			project
+		});
+	} finally {
+		yamlRoots.clear();
+		memory.release(retainedYamlBytes);
 	}
-	session.throwIfAborted();
-	addDiagnostics(collector, await inspectCodingAgentIntegration(session.reader, session.instructions, options.limits, signal));
-	const patterns = indexedManifest === null ? {
-		completed: false,
-		diagnostics: []
-	} : await inspectImpactPatterns(session.reader, indexedManifest.value, options.limits, signal);
-	session.throwIfAborted();
-	addDiagnostics(collector, patterns.diagnostics);
-	const diagnostics = applyWarningAcceptances(collector.finalize(), indexedManifest?.value.acceptedWarnings ?? [], /* @__PURE__ */ new Set([...[
-		"MOLDEA_INTEGRATION_BLOCK_MISSING",
-		"MOLDEA_INTEGRATION_SKILL_MISSING",
-		"MOLDEA_INTEGRATION_BLOCK_STALE",
-		"MOLDEA_INTEGRATION_LINK_UNRESOLVED",
-		"MOLDEA_INTEGRATION_CLAUDE_IMPORT_MISSING"
-	], ...patterns.completed ? ["MOLDEA_IMPACT_PATTERN_UNMATCHED"] : []]), options.limits);
-	const project = !diagnostics.some((diagnostic) => diagnostic.severity === "error") && indexedManifest !== null && projectAssets.project !== null ? createProjectIndex({
-		agentMirrors,
-		agents,
-		context: projectAssets.context,
-		decisions: decisionGraph.decisions,
-		manifest: indexedManifest,
-		project: projectAssets.project,
-		runtimes: runtimeGuidance.runtimes
-	}) : null;
-	return deepFreeze({
-		diagnostics,
-		coverage,
-		formatVersion,
-		project
-	});
 };
 //#endregion
 //#region src/project-validation/index.ts
@@ -3633,4 +3691,4 @@ var createCore = (options) => {
 //#endregion
 export { createCore as n, parseIntegrationBlock as r, core_exports as t };
 
-//# sourceMappingURL=core-CFmT3SRC.js.map
+//# sourceMappingURL=core-DOzzzqoB.js.map