@moldea.ai/adapter-eve 1.0.0

package/dist/index.js

@@ -0,0 +1,1831 @@
+import ts from "typescript";
+import { posix } from "node:path";
+import { parseRepositoryPath } from "@moldea.ai/repository";
+import { intersects, subset, validRange } from "semver";
+//#region src/constants/index.ts
+var EVE_SUPPORTED_PACKAGE_RANGE = ">=0.39.1 <0.40.0";
+var EVE_TARGET_ID = "typescript-filesystem-agent-0-39";
+var EVE_SUPPORTED_REPOSITORY_FORMAT_VERSIONS = Object.freeze([1]);
+var EVE_AUTHORED_MODULE_EXTENSIONS = Object.freeze([
+	".cts",
+	".mts",
+	".cjs",
+	".mjs",
+	".ts",
+	".js"
+]);
+var EVE_TOOL_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/u;
+var EVE_RESERVED_TOOL_NAME = "Workflow";
+var EVE_FRAMEWORK_TOOL_NAMES = Object.freeze([
+	"ask_question",
+	"bash",
+	"glob",
+	"grep",
+	"read_file",
+	"write_file",
+	"todo",
+	"web_fetch",
+	"web_search",
+	"agent",
+	"connection_search",
+	"load_skill"
+]);
+//#endregion
+//#region src/repository-discovery/agent-roots.ts
+var isSafeRuntimeName = (runtimeName) => runtimeName.length > 0 && !runtimeName.includes("\0") && !runtimeName.includes("\n") && !runtimeName.includes("\r") && runtimeName === runtimeName.trim();
+var getPackageRuntimeName = (packageName) => {
+	if (packageName === null || packageName.length === 0) return null;
+	const runtimeName = packageName.slice(packageName.lastIndexOf("/") + 1);
+	return isSafeRuntimeName(runtimeName) ? runtimeName : null;
+};
+var getLocalRoot = (path, baseRoot, layout) => {
+	const prefix = `${baseRoot === "/" ? "" : baseRoot}/subagents/`;
+	if (!path.startsWith(prefix) || !path.endsWith("/agent.ts")) return null;
+	const segments = path.slice(prefix.length, -9).split("/");
+	if (segments.length === 0 || segments.some((segment) => segment.length === 0)) return null;
+	if (segments.length % 2 === 0) return null;
+	for (let index = 1; index < segments.length; index += 2) if (segments[index] !== "subagents") return null;
+	const agentRoot = posix.dirname(path);
+	const parentRoot = posix.dirname(posix.dirname(agentRoot));
+	const runtimeName = segments.at(-1) ?? "";
+	return Object.freeze({
+		agentKind: "local-subagent",
+		agentRoot,
+		layout,
+		parentRoot,
+		runtimeName: isSafeRuntimeName(runtimeName) ? runtimeName : null
+	});
+};
+/** Resolves one bound `agent.ts` into an exact Eve root or local-subagent layout. */
+var resolveEveAgentRoot = (path, packageObservation) => {
+	if (posix.basename(path) !== "agent.ts") return null;
+	const packageRoot = parseRepositoryPath(posix.dirname(packageObservation.path));
+	const flatPath = parseRepositoryPath(posix.join(packageRoot, "agent.ts"));
+	const nestedRoot = parseRepositoryPath(posix.join(packageRoot, "agent"));
+	const nestedPath = parseRepositoryPath(posix.join(nestedRoot, "agent.ts"));
+	if (path === flatPath) return Object.freeze({
+		agentKind: "root",
+		agentRoot: packageRoot,
+		layout: "flat",
+		parentRoot: null,
+		runtimeName: getPackageRuntimeName(packageObservation.manifestPackageName)
+	});
+	if (path === nestedPath) return Object.freeze({
+		agentKind: "root",
+		agentRoot: nestedRoot,
+		layout: "nested",
+		parentRoot: null,
+		runtimeName: getPackageRuntimeName(packageObservation.manifestPackageName)
+	});
+	return getLocalRoot(path, packageRoot, "flat") ?? getLocalRoot(path, nestedRoot, "nested");
+};
+//#endregion
+//#region src/repository-discovery/candidate-index.ts
+var compareStrings = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+var getAuthoredExtension = (path) => EVE_AUTHORED_MODULE_EXTENSIONS.find((extension) => path.endsWith(extension)) ?? null;
+var removeExtension = (path, extension) => path.slice(0, -extension.length);
+var getDirectRelativePath = (root, path) => {
+	const prefix = root === "/" ? "/" : `${root}/`;
+	return path.startsWith(prefix) ? path.slice(prefix.length) : null;
+};
+var indexExtensionNamespaces = (root, entries) => {
+	const namespaces = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		if (entry.type !== "file") continue;
+		const relative = getDirectRelativePath(root, entry.path);
+		if (relative === null || !relative.startsWith("extensions/")) continue;
+		const extensionRelative = relative.slice(11);
+		const segments = extensionRelative.split("/");
+		const extension = getAuthoredExtension(extensionRelative);
+		const firstSegment = segments[0];
+		const secondSegment = segments[1];
+		let namespace = null;
+		if (extension !== null && segments.length === 1 && firstSegment !== void 0) namespace = removeExtension(firstSegment, extension);
+		else if (extension !== null && segments.length === 2 && firstSegment !== void 0 && secondSegment !== void 0 && removeExtension(secondSegment, extension) === "extension") namespace = firstSegment;
+		if (namespace !== null && EVE_TOOL_NAME_PATTERN.test(namespace)) namespaces.add(namespace);
+	}
+	return namespaces;
+};
+var isExtensionReserved = (name, namespaces) => [...namespaces].some((namespace) => name.startsWith(`${namespace}__`));
+var indexTools = (root, entries, namespaces) => {
+	const raw = entries.flatMap((entry) => {
+		if (entry.type !== "file") return [];
+		const relative = getDirectRelativePath(root, entry.path);
+		if (relative === null || !relative.startsWith("tools/")) return [];
+		const toolRelative = relative.slice(6);
+		const extension = getAuthoredExtension(toolRelative);
+		if (extension === null) return [];
+		const withoutExtension = removeExtension(toolRelative, extension);
+		return [{
+			entry,
+			extension,
+			relativePath: withoutExtension,
+			segments: withoutExtension.split("/")
+		}];
+	});
+	const slots = /* @__PURE__ */ new Map();
+	for (const candidate of raw) slots.set(candidate.relativePath, (slots.get(candidate.relativePath) ?? 0) + 1);
+	return Object.freeze(raw.map(({ entry, extension, relativePath, segments }) => {
+		const runtimeName = segments.join("-");
+		return Object.freeze({
+			isCollidedSlot: (slots.get(relativePath) ?? 0) > 1,
+			isExtensionReserved: isExtensionReserved(segments[0] ?? "", namespaces),
+			isSupportedSource: extension === ".ts",
+			path: entry.path,
+			relativePath,
+			runtimeName,
+			segments: Object.freeze(segments)
+		});
+	}));
+};
+var indexSkills = (root, entries) => {
+	const raw = [];
+	for (const entry of entries) {
+		if (entry.type !== "file") continue;
+		const relative = getDirectRelativePath(root, entry.path);
+		if (relative === null || !relative.startsWith("skills/")) continue;
+		const segments = relative.slice(7).split("/");
+		const firstSegment = segments[0];
+		const secondSegment = segments[1];
+		if (segments.length === 2 && firstSegment !== void 0 && secondSegment === "SKILL.md") {
+			raw.push({
+				identity: firstSegment,
+				kind: "packaged",
+				path: entry.path
+			});
+			continue;
+		}
+		if (segments.length !== 1) continue;
+		if (firstSegment === void 0) continue;
+		if (/\.md$/iu.test(firstSegment)) {
+			raw.push({
+				identity: firstSegment.slice(0, -3),
+				kind: "markdown",
+				path: entry.path
+			});
+			continue;
+		}
+		const extension = getAuthoredExtension(firstSegment);
+		if (extension !== null) raw.push({
+			identity: removeExtension(firstSegment, extension),
+			kind: extension === ".ts" ? "typescript" : "markdown",
+			path: entry.path
+		});
+	}
+	const identities = /* @__PURE__ */ new Map();
+	for (const candidate of raw) identities.set(candidate.identity, (identities.get(candidate.identity) ?? 0) + 1);
+	return Object.freeze(raw.map((candidate) => Object.freeze({
+		...candidate,
+		isCollidedSlot: (identities.get(candidate.identity) ?? 0) > 1
+	})));
+};
+var indexSubagents = (root, entries, namespaces) => {
+	const raw = [];
+	for (const entry of entries) {
+		if (entry.type !== "file") continue;
+		const relative = getDirectRelativePath(root, entry.path);
+		if (relative === null || !relative.startsWith("subagents/")) continue;
+		const segments = relative.slice(10).split("/");
+		const firstSegment = segments[0];
+		const secondSegment = segments[1];
+		if (segments.length === 2 && firstSegment !== void 0 && secondSegment !== void 0) {
+			const extension = getAuthoredExtension(secondSegment);
+			if (extension !== null && removeExtension(secondSegment, extension) === "agent") raw.push({
+				agentPath: entry.path,
+				kind: "directory",
+				runtimeName: firstSegment
+			});
+			continue;
+		}
+		if (segments.length === 1 && firstSegment !== void 0) {
+			const extension = getAuthoredExtension(firstSegment);
+			if (extension !== null) raw.push({
+				agentPath: entry.path,
+				kind: "file",
+				runtimeName: removeExtension(firstSegment, extension)
+			});
+		}
+	}
+	const identities = /* @__PURE__ */ new Map();
+	for (const candidate of raw) identities.set(candidate.runtimeName, (identities.get(candidate.runtimeName) ?? 0) + 1);
+	return Object.freeze(raw.map((candidate) => Object.freeze({
+		agentPath: candidate.agentPath,
+		isDirectoryBacked: candidate.kind === "directory" && candidate.agentPath.endsWith("/agent.ts") && (identities.get(candidate.runtimeName) ?? 0) === 1,
+		isExtensionReserved: isExtensionReserved(candidate.runtimeName, namespaces),
+		runtimeName: candidate.runtimeName
+	})));
+};
+/** Creates the deterministic candidate index for one selected Eve agent root. */
+var createEveAgentRootIndex = (root, sourceEntries) => {
+	const entries = [...sourceEntries].sort((left, right) => compareStrings(left.path, right.path));
+	const namespaces = indexExtensionNamespaces(root, entries);
+	const agentCandidates = entries.filter((entry) => {
+		const relative = getDirectRelativePath(root, entry.path);
+		return relative !== null && !relative.includes("/");
+	}).filter((entry) => {
+		const extension = getAuthoredExtension(entry.path);
+		return entry.type === "file" && extension !== null && posix.basename(entry.path, extension) === "agent";
+	});
+	const instructionEntries = entries.filter((entry) => {
+		const relative = getDirectRelativePath(root, entry.path);
+		return relative !== null && (relative === "instructions" || !relative.includes("/") && (/^instructions\.md$/iu.test(relative) || /^system\.md$/iu.test(relative) || getAuthoredExtension(relative) !== null && ["instructions", "system"].includes(removeExtension(relative, getAuthoredExtension(relative) ?? ""))));
+	});
+	return Object.freeze({
+		extensionNamespaces: namespaces,
+		instructionEntries: Object.freeze(instructionEntries),
+		isAgentSlotCollided: agentCandidates.length > 1,
+		skillCandidates: indexSkills(root, entries),
+		subagentCandidates: indexSubagents(root, entries, namespaces),
+		toolCandidates: indexTools(root, entries, namespaces)
+	});
+};
+//#endregion
+//#region ../../packages/adapter-static-analysis/dist/index.js
+/**
+* Creates an operation-local inspection session with deterministic promise caches.
+* @param options Provider callbacks and the optional operation signal.
+* @returns Cached source, package, and entry inspection functions.
+* @throws If the inspection is aborted.
+*/
+var createInspectionSession = (options) => {
+	const sourceCache = /* @__PURE__ */ new Map();
+	const packageCache = /* @__PURE__ */ new Map();
+	const entryCache = /* @__PURE__ */ new Map();
+	const analyzeSource = (path) => {
+		options.signal?.throwIfAborted();
+		const existing = sourceCache.get(path);
+		if (existing !== void 0) return existing;
+		const analysis = (async () => {
+			options.signal?.throwIfAborted();
+			const bytes = await options.readFile(path, options.signal);
+			options.signal?.throwIfAborted();
+			const result = await options.analyzeSource(path, bytes, options.signal);
+			options.signal?.throwIfAborted();
+			return result;
+		})();
+		sourceCache.set(path, analysis);
+		return analysis;
+	};
+	const discoverPackage = (path) => {
+		options.signal?.throwIfAborted();
+		const existing = packageCache.get(path);
+		if (existing !== void 0) return existing;
+		const discovery = options.discoverPackage(path, options.signal);
+		packageCache.set(path, discovery);
+		return discovery;
+	};
+	const getEntry = (path) => {
+		options.signal?.throwIfAborted();
+		const existing = entryCache.get(path);
+		if (existing !== void 0) return existing;
+		const entry = options.getEntry(path, options.signal);
+		entryCache.set(path, entry);
+		return entry;
+	};
+	return Object.freeze({
+		analyzeSource,
+		discoverPackage,
+		getEntry,
+		...options.signal === void 0 ? {} : { signal: options.signal }
+	});
+};
+var decoder = new TextDecoder("utf-8", {
+	fatal: true,
+	ignoreBOM: true
+});
+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 a TypeScript UTF-16-offset to Unicode-scalar source locator.
+* @param value The normalized valid Unicode-scalar text.
+* @returns The scalar-aware source locator.
+*/
+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)
+	}) });
+};
+/**
+* Decodes and normalizes source bytes through the runtime-adapter text contract.
+* @param bytes The exact reader-owned source bytes.
+* @returns The normalized text and locator or an invalid-text result.
+*/
+var normalizeText = (bytes) => {
+	let decoded;
+	try {
+		decoded = decoder.decode(bytes);
+	} catch {
+		return Object.freeze({ valid: false });
+	}
+	const value = (decoded.startsWith("") ? decoded.slice(1) : decoded).replace(/\r\n?/gu, "\n");
+	if (value.includes("\0")) return Object.freeze({ valid: false });
+	return Object.freeze({
+		locator: createSourceLocator(value),
+		valid: true,
+		value
+	});
+};
+var PACKAGE_DEPENDENCY_FIELDS = Object.freeze([
+	"dependencies",
+	"optionalDependencies",
+	"peerDependencies",
+	"devDependencies"
+]);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/**
+* Creates nearest-to-root package-manifest candidates for one source path.
+* @param sourcePath The normalized source path.
+* @returns Deterministically ordered manifest paths.
+*/
+var createPackageManifestCandidatePaths = (sourcePath) => {
+	const candidates = [];
+	let directory = posix.dirname(sourcePath);
+	while (true) {
+		candidates.push(posix.join(directory, "package.json"));
+		if (directory === "/") break;
+		directory = posix.dirname(directory);
+	}
+	return Object.freeze(candidates);
+};
+var extractPackageDeclarations = (manifest, packageName) => {
+	const declarations = [];
+	for (const field of PACKAGE_DEPENDENCY_FIELDS) {
+		const dependencies = manifest[field];
+		if (dependencies === void 0) continue;
+		if (!isRecord(dependencies)) return null;
+		const declaration = dependencies[packageName];
+		if (declaration === void 0) continue;
+		if (typeof declaration !== "string" || declaration.trim().length === 0) return null;
+		declarations.push(Object.freeze({
+			declaredRange: declaration,
+			dependencyKind: field
+		}));
+	}
+	return declarations;
+};
+var classifyPackageDeclarations = (declarations, supportedRange) => {
+	const classifications = declarations.map(({ declaredRange }) => {
+		const normalizedRange = validRange(declaredRange, {
+			loose: false,
+			includePrerelease: false
+		});
+		if (normalizedRange === null) return "ambiguous";
+		if (subset(normalizedRange, supportedRange, {
+			loose: false,
+			includePrerelease: false
+		})) return "supported";
+		if (!intersects(normalizedRange, supportedRange, {
+			loose: false,
+			includePrerelease: false
+		})) return "unsupported";
+		return "ambiguous";
+	});
+	if (classifications.every((classification) => classification === "supported")) return "supported";
+	if (classifications.every((classification) => classification === "unsupported")) return "unsupported";
+	return "ambiguous";
+};
+/**
+* Discovers the nearest package declaration without repository enumeration.
+* @param options The package target, repository callbacks, path, range, and signal.
+* @returns The first observed declaration, invalid manifest, or absence result.
+* @throws If repository reading or the active inspection is aborted.
+*/
+var discoverPackage = async (options) => {
+	const { includeManifestPackageName, packageName, reader, signal, sourcePath, supportedRange } = options;
+	for (const manifestPath of createPackageManifestCandidatePaths(sourcePath)) {
+		signal?.throwIfAborted();
+		const entry = await reader.getEntry(manifestPath);
+		signal?.throwIfAborted();
+		if (entry === null) continue;
+		if (entry.type !== "file") return Object.freeze({
+			kind: "invalid",
+			path: manifestPath
+		});
+		const bytes = await reader.readFile(manifestPath);
+		signal?.throwIfAborted();
+		const text = normalizeText(bytes);
+		signal?.throwIfAborted();
+		if (!text.valid) return Object.freeze({
+			kind: "invalid",
+			path: manifestPath
+		});
+		let parsed;
+		try {
+			parsed = JSON.parse(text.value);
+		} catch {
+			return Object.freeze({
+				kind: "invalid",
+				path: manifestPath
+			});
+		}
+		signal?.throwIfAborted();
+		if (!isRecord(parsed)) return Object.freeze({
+			kind: "invalid",
+			path: manifestPath
+		});
+		const declarations = extractPackageDeclarations(parsed, packageName);
+		if (declarations === null) return Object.freeze({
+			kind: "invalid",
+			path: manifestPath
+		});
+		if (declarations.length === 0) return Object.freeze({ kind: "absent" });
+		return Object.freeze({
+			kind: "observed",
+			observation: Object.freeze({
+				compatibility: classifyPackageDeclarations(declarations, supportedRange),
+				declarations: Object.freeze(declarations),
+				...includeManifestPackageName === true ? { manifestPackageName: typeof parsed["name"] === "string" ? parsed["name"] : null } : {},
+				path: manifestPath
+			})
+		});
+	}
+	return Object.freeze({ kind: "absent" });
+};
+/**
+* Removes the transparent expression wrappers supported by runtime adapters.
+* @param expression The expression to normalize.
+* @returns The underlying expression used by static matching.
+*/
+var unwrapExpression = (expression) => {
+	let current = expression;
+	while (ts.isAsExpression(current) || ts.isParenthesizedExpression(current) || ts.isSatisfiesExpression(current)) current = current.expression;
+	return current;
+};
+/**
+* Reads an exact static string literal from one expression.
+* @param expression The candidate string expression.
+* @returns Its exact value or `null` when dynamic.
+*/
+var getStaticString = (expression) => {
+	if (expression === null || expression === void 0) return null;
+	const candidate = unwrapExpression(expression);
+	return ts.isStringLiteral(candidate) || ts.isNoSubstitutionTemplateLiteral(candidate) ? candidate.text : null;
+};
+var hasModifier = (node, kind) => ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false);
+var isConstDeclarationList = (declarationList) => (declarationList.flags & ts.NodeFlags.Const) !== 0;
+/**
+* Indexes static value imports and supported SDK constructor imports.
+* @param sourceFile The parsed TypeScript source.
+* @param config The provider package and constructor import forms.
+* @returns Module-owned import bindings needed by static checks.
+*/
+var indexImports = (sourceFile, config) => {
+	const constructorNames = /* @__PURE__ */ new Set();
+	const namedImports = /* @__PURE__ */ new Map();
+	const supportedNamedImports = new Set(config.namedConstructorImports);
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+		const importClause = statement.importClause;
+		if (importClause?.isTypeOnly === true) continue;
+		const moduleSpecifier = statement.moduleSpecifier.text;
+		if (moduleSpecifier === config.packageName && config.supportsDefaultConstructorImport && importClause?.name !== void 0) constructorNames.add(importClause.name.text);
+		if (moduleSpecifier === config.packageName && importClause?.namedBindings !== void 0 && ts.isNamedImports(importClause.namedBindings)) for (const element of importClause.namedBindings.elements) {
+			const importedName = element.propertyName?.text ?? element.name.text;
+			if (!element.isTypeOnly && supportedNamedImports.has(importedName)) constructorNames.add(element.name.text);
+		}
+		if (!moduleSpecifier.startsWith(".") || importClause?.namedBindings === void 0 || !ts.isNamedImports(importClause.namedBindings)) continue;
+		for (const element of importClause.namedBindings.elements) {
+			if (element.isTypeOnly) continue;
+			namedImports.set(element.name.text, Object.freeze({
+				importedName: element.propertyName?.text ?? element.name.text,
+				moduleSpecifier
+			}));
+		}
+	}
+	return {
+		constructorNames,
+		namedImports
+	};
+};
+/**
+* Indexes direct exports, module-level SDK clients, and constant arrays.
+* @param sourceFile The parsed TypeScript source.
+* @param constructorNames The supported constructor bindings.
+* @returns Static module declarations used by adapter inspection.
+*/
+var indexModuleDeclarations = (sourceFile, constructorNames) => {
+	const clientNames = /* @__PURE__ */ new Set();
+	const exports = /* @__PURE__ */ new Map();
+	const moduleArrays = /* @__PURE__ */ new Map();
+	const moduleConstDeclarations = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if (ts.isFunctionDeclaration(statement) && statement.name !== void 0) {
+			if (hasModifier(statement, ts.SyntaxKind.ExportKeyword)) exports.set(statement.name.text, Object.freeze({
+				declaration: statement,
+				kind: statement.body === void 0 || hasModifier(statement, ts.SyntaxKind.DefaultKeyword) ? "present-unsupported" : "present-supported"
+			}));
+			continue;
+		}
+		if (ts.isExportDeclaration(statement) && statement.exportClause !== void 0) {
+			if (!ts.isNamedExports(statement.exportClause) || statement.isTypeOnly) continue;
+			for (const element of statement.exportClause.elements) if (!element.isTypeOnly) exports.set(element.name.text, Object.freeze({
+				declaration: element,
+				kind: "present-unsupported"
+			}));
+			continue;
+		}
+		if (!ts.isVariableStatement(statement)) {
+			if (hasModifier(statement, ts.SyntaxKind.ExportKeyword) && (ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement) || ts.isModuleDeclaration(statement)) && statement.name !== void 0 && ts.isIdentifier(statement.name)) exports.set(statement.name.text, Object.freeze({
+				declaration: statement,
+				kind: "present-unsupported"
+			}));
+			continue;
+		}
+		const isConst = isConstDeclarationList(statement.declarationList);
+		const isExported = hasModifier(statement, ts.SyntaxKind.ExportKeyword);
+		for (const declaration of statement.declarationList.declarations) {
+			if (!ts.isIdentifier(declaration.name)) continue;
+			if (isExported) exports.set(declaration.name.text, Object.freeze({
+				declaration,
+				kind: isConst && declaration.initializer !== void 0 ? "present-supported" : "present-unsupported"
+			}));
+			if (!isConst || declaration.initializer === void 0) continue;
+			moduleConstDeclarations.set(declaration.name.text, declaration);
+			const initializer = unwrapExpression(declaration.initializer);
+			if (ts.isNewExpression(initializer)) {
+				const constructor = unwrapExpression(initializer.expression);
+				if (ts.isIdentifier(constructor) && constructorNames.has(constructor.text)) clientNames.add(declaration.name.text);
+			}
+			if (ts.isArrayLiteralExpression(initializer)) moduleArrays.set(declaration.name.text, Object.freeze({
+				declaration,
+				expression: initializer
+			}));
+		}
+	}
+	return {
+		clientNames,
+		exports,
+		moduleArrays,
+		moduleConstDeclarations
+	};
+};
+var addBindingNames = (names, bindingName) => {
+	if (ts.isIdentifier(bindingName)) {
+		names.add(bindingName.text);
+		return;
+	}
+	for (const element of bindingName.elements) if (!ts.isOmittedExpression(element)) addBindingNames(names, element.name);
+};
+var addVariableDeclarationListBindings = (names, declarationList) => {
+	for (const declaration of declarationList.declarations) addBindingNames(names, declaration.name);
+};
+var addStatementBindings = (names, statement) => {
+	if (ts.isVariableStatement(statement)) {
+		addVariableDeclarationListBindings(names, statement.declarationList);
+		return;
+	}
+	if (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement) || ts.isModuleDeclaration(statement)) {
+		if (statement.name !== void 0 && ts.isIdentifier(statement.name)) names.add(statement.name.text);
+	}
+};
+var isFunctionScope = (node) => ts.isArrowFunction(node) || ts.isConstructorDeclaration(node) || ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isGetAccessorDeclaration(node) || ts.isMethodDeclaration(node) || ts.isSetAccessorDeclaration(node);
+var getLocalBindingNames = (bindings, scope) => {
+	const existingNames = bindings.get(scope);
+	if (existingNames !== void 0) return existingNames;
+	const names = /* @__PURE__ */ new Set();
+	bindings.set(scope, names);
+	return names;
+};
+/**
+* Indexes local runtime bindings that can shadow module-owned identifiers.
+* @param sourceFile The parsed TypeScript source.
+* @returns Local binding names keyed by lexical or function scope.
+*/
+var indexLocalBindingNames = (sourceFile) => {
+	const bindings = /* @__PURE__ */ new Map();
+	const visit = (node, functionScope) => {
+		let childFunctionScope = functionScope;
+		if (isFunctionScope(node)) {
+			const names = getLocalBindingNames(bindings, node);
+			for (const parameter of node.parameters) addBindingNames(names, parameter.name);
+			if (node.name !== void 0 && ts.isIdentifier(node.name)) names.add(node.name.text);
+			childFunctionScope = node;
+		}
+		if (ts.isBlock(node) || ts.isModuleBlock(node)) {
+			const names = getLocalBindingNames(bindings, node);
+			for (const statement of node.statements) addStatementBindings(names, statement);
+		} else if (ts.isCaseBlock(node)) {
+			const names = getLocalBindingNames(bindings, node);
+			for (const clause of node.clauses) for (const statement of clause.statements) addStatementBindings(names, statement);
+		} else if (ts.isCatchClause(node) && node.variableDeclaration !== void 0) addBindingNames(getLocalBindingNames(bindings, node), node.variableDeclaration.name);
+		else if ((ts.isForStatement(node) || ts.isForInStatement(node) || ts.isForOfStatement(node)) && node.initializer !== void 0 && ts.isVariableDeclarationList(node.initializer)) addVariableDeclarationListBindings(getLocalBindingNames(bindings, node), node.initializer);
+		else if (ts.isClassExpression(node) && node.name !== void 0) getLocalBindingNames(bindings, node).add(node.name.text);
+		if (childFunctionScope !== null && ts.isVariableDeclarationList(node) && (node.flags & ts.NodeFlags.BlockScoped) === 0) addVariableDeclarationListBindings(getLocalBindingNames(bindings, childFunctionScope), node);
+		ts.forEachChild(node, (child) => visit(child, childFunctionScope));
+	};
+	visit(sourceFile, null);
+	return bindings;
+};
+/**
+* Indexes identifier occurrences once for binding-specific safety analysis.
+* @param sourceFile The parsed TypeScript source.
+* @returns Identifier occurrences grouped by exact source spelling.
+*/
+var indexIdentifierUses = (sourceFile) => {
+	const identifierUses = /* @__PURE__ */ new Map();
+	const visit = (node) => {
+		if (ts.isIdentifier(node)) {
+			const uses = identifierUses.get(node.text) ?? [];
+			uses.push(node);
+			identifierUses.set(node.text, uses);
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(sourceFile);
+	return new Map([...identifierUses].map(([name, uses]) => [name, Object.freeze(uses)]));
+};
+/**
+* Determines whether a module-bound name is visible at one identifier use.
+* @param identifier The identifier whose lexical environment is inspected.
+* @param analysis The indexed source containing the identifier.
+* @returns Whether no parameter or local declaration shadows the module binding.
+*/
+var isModuleBindingVisible = (identifier, analysis) => {
+	let current = identifier.parent;
+	while (current !== void 0 && !ts.isSourceFile(current)) {
+		if (analysis.localBindingNames.get(current)?.has(identifier.text) === true) return false;
+		current = current.parent;
+	}
+	return true;
+};
+/**
+* Resolves TypeScript source candidates for a supported relative ESM specifier.
+* @param containingPath The importing source path.
+* @param moduleSpecifier The exact relative ESM specifier.
+* @returns Supported logical source candidates in deterministic order.
+*/
+var resolveImportCandidatePaths = (containingPath, moduleSpecifier) => {
+	const resolved = posix.resolve(posix.dirname(containingPath), moduleSpecifier);
+	if (resolved.endsWith(".js")) return [`${resolved.slice(0, -3)}.ts`, `${resolved.slice(0, -3)}.tsx`];
+	if (resolved.endsWith(".mjs")) return [`${resolved.slice(0, -4)}.mts`];
+	return [
+		".ts",
+		".tsx",
+		".mts"
+	].some((extension) => resolved.endsWith(extension)) ? [resolved] : [];
+};
+var getScriptKind = (path) => path.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+var createSyntaxProgram = (sourceFile, text) => {
+	return ts.createProgram({
+		host: {
+			fileExists: (fileName) => fileName === sourceFile.fileName,
+			getCanonicalFileName: (fileName) => fileName,
+			getCurrentDirectory: () => "/",
+			getDefaultLibFileName: () => "/lib.d.ts",
+			getDirectories: () => [],
+			getNewLine: () => "\n",
+			getSourceFile: (fileName) => fileName === sourceFile.fileName ? sourceFile : void 0,
+			readFile: (fileName) => fileName === sourceFile.fileName ? text : void 0,
+			useCaseSensitiveFileNames: () => true,
+			writeFile: () => void 0
+		},
+		options: {
+			jsx: ts.JsxEmit.Preserve,
+			module: ts.ModuleKind.ESNext,
+			noLib: true,
+			noResolve: true,
+			target: ts.ScriptTarget.ES2023
+		},
+		rootNames: [sourceFile.fileName]
+	});
+};
+/**
+* Parses and indexes one TypeScript module without provider request assumptions.
+* @param path The normalized logical source path.
+* @param bytes The exact source bytes returned by the adapter reader.
+* @param importConfig The provider constructor-import contract.
+* @param signal The active inspection signal.
+* @returns A source analysis or stable invalid-text or invalid-syntax result.
+* @throws If source analysis is aborted.
+*/
+var analyzeTypeScriptModule = (path, bytes, importConfig, signal) => {
+	signal?.throwIfAborted();
+	const text = normalizeText(bytes);
+	if (!text.valid) return Object.freeze({ kind: "invalid-text" });
+	signal?.throwIfAborted();
+	const sourceFile = ts.createSourceFile(path, text.value, ts.ScriptTarget.ES2023, true, getScriptKind(path));
+	const syntaxDiagnostic = createSyntaxProgram(sourceFile, text.value).getSyntacticDiagnostics(sourceFile).filter(({ category }) => category === ts.DiagnosticCategory.Error).sort((left, right) => (left.start ?? 0) - (right.start ?? 0))[0];
+	signal?.throwIfAborted();
+	if (syntaxDiagnostic !== void 0) {
+		const start = syntaxDiagnostic.start;
+		return Object.freeze({
+			kind: "invalid-syntax",
+			range: start === void 0 ? null : text.locator.locateRange(start, start + (syntaxDiagnostic.length ?? 0))
+		});
+	}
+	const { constructorNames, namedImports } = indexImports(sourceFile, importConfig);
+	signal?.throwIfAborted();
+	const { clientNames, exports, moduleArrays, moduleConstDeclarations } = indexModuleDeclarations(sourceFile, constructorNames);
+	signal?.throwIfAborted();
+	const identifierUses = indexIdentifierUses(sourceFile);
+	signal?.throwIfAborted();
+	const localBindingNames = indexLocalBindingNames(sourceFile);
+	signal?.throwIfAborted();
+	const analysis = Object.freeze({
+		clientNames,
+		constructorNames,
+		exports,
+		identifierUses,
+		localBindingNames,
+		moduleArrays,
+		moduleConstDeclarations,
+		namedImports,
+		path,
+		safeModuleArrayNames: /* @__PURE__ */ new Set(),
+		sourceFile,
+		text
+	});
+	signal?.throwIfAborted();
+	return Object.freeze({
+		analysis,
+		kind: "valid"
+	});
+};
+/**
+* Classifies a directly exported constant and returns its static initializer.
+* @param analysis The indexed source.
+* @param symbol The exact bound symbol.
+* @returns The symbol state and initializer when supported.
+*/
+var getConstExport = (analysis, symbol) => {
+	const exported = analysis.exports.get(symbol);
+	if (exported === void 0) return Object.freeze({ kind: "absent" });
+	if (exported.kind === "present-supported" && ts.isVariableDeclaration(exported.declaration) && exported.declaration.initializer !== void 0) return Object.freeze({
+		declaration: exported.declaration,
+		expression: unwrapExpression(exported.declaration.initializer),
+		kind: "present-supported"
+	});
+	return Object.freeze({
+		declaration: exported.declaration,
+		kind: "present-unsupported"
+	});
+};
+var resolveCandidatePath = async (options, containingPath, moduleSpecifier) => {
+	const matchingPaths = [];
+	for (const candidate of resolveImportCandidatePaths(containingPath, moduleSpecifier)) {
+		const path = options.parsePath(candidate);
+		if ((await options.getEntry(path))?.type === "file") matchingPaths.push(path);
+	}
+	return matchingPaths.length === 1 ? matchingPaths[0] : null;
+};
+var resolveStaticStringExpression = async (options, analysis, expression, visited) => {
+	options.signal?.throwIfAborted();
+	const candidate = unwrapExpression(expression);
+	const literal = getStaticString(candidate);
+	if (literal !== null) return Object.freeze({
+		expression: candidate,
+		kind: "supported",
+		value: literal
+	});
+	if (!ts.isIdentifier(candidate) || !isModuleBindingVisible(candidate, analysis)) return Object.freeze({ kind: "unsupported" });
+	const localDeclaration = analysis.moduleConstDeclarations.get(candidate.text);
+	if (localDeclaration?.initializer !== void 0) {
+		const key = `${analysis.path}\0local\0${candidate.text}`;
+		if (visited.has(key)) return Object.freeze({ kind: "unsupported" });
+		visited.add(key);
+		const result = await resolveStaticStringExpression(options, analysis, localDeclaration.initializer, visited);
+		visited.delete(key);
+		return result;
+	}
+	const namedImport = analysis.namedImports.get(candidate.text);
+	if (namedImport === void 0) return Object.freeze({ kind: "unsupported" });
+	const importedPath = await resolveCandidatePath(options, analysis.path, namedImport.moduleSpecifier);
+	if (importedPath === null) return Object.freeze({ kind: "unsupported" });
+	const key = `${importedPath}\0export\0${namedImport.importedName}`;
+	if (visited.has(key)) return Object.freeze({ kind: "unsupported" });
+	visited.add(key);
+	const importedResult = await options.analyzeSource(importedPath);
+	if (importedResult.kind !== "valid") {
+		visited.delete(key);
+		return Object.freeze({ kind: "unsupported" });
+	}
+	const exported = getConstExport(importedResult.analysis, namedImport.importedName);
+	if (exported.kind !== "present-supported" || exported.expression === void 0) {
+		visited.delete(key);
+		return Object.freeze({ kind: "unsupported" });
+	}
+	const result = await resolveStaticStringExpression(options, importedResult.analysis, exported.expression, visited);
+	visited.delete(key);
+	return result;
+};
+/**
+* Resolves one exact supported static string without normalization or execution.
+* @param options The source, expression, repository callbacks, and parser for the relationship.
+* @returns The exact compiler-parsed string or an unsupported state.
+*/
+var resolveStaticString = (options) => resolveStaticStringExpression(options, options.analysis, options.expression, /* @__PURE__ */ new Set());
+//#endregion
+//#region src/source-analysis/helper-imports.ts
+var HELPER_IMPORTS = Object.freeze({
+	eve: Object.freeze({ defineAgent: "defineAgent" }),
+	"eve/instructions": Object.freeze({ defineInstructions: "defineInstructions" }),
+	"eve/skills": Object.freeze({ defineSkill: "defineSkill" }),
+	"eve/tools": Object.freeze({ defineTool: "defineTool" })
+});
+/** Indexes exact Eve helper runtime imports by lexical local binding. */
+var indexEveHelperImports = (sourceFile) => {
+	const defineAgent = /* @__PURE__ */ new Set();
+	const defineInstructions = /* @__PURE__ */ new Set();
+	const defineSkill = /* @__PURE__ */ new Set();
+	const defineTool = /* @__PURE__ */ new Set();
+	const sets = {
+		defineAgent,
+		defineInstructions,
+		defineSkill,
+		defineTool
+	};
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+		const importClause = statement.importClause;
+		const expected = HELPER_IMPORTS[statement.moduleSpecifier.text];
+		if (expected === void 0 || importClause?.isTypeOnly === true || importClause?.namedBindings === void 0 || !ts.isNamedImports(importClause.namedBindings)) continue;
+		for (const element of importClause.namedBindings.elements) {
+			const importedName = element.propertyName?.text ?? element.name.text;
+			if (!element.isTypeOnly && importedName in expected) sets[importedName].add(element.name.text);
+		}
+	}
+	return Object.freeze({
+		defineAgent,
+		defineInstructions,
+		defineSkill,
+		defineTool
+	});
+};
+//#endregion
+//#region src/source-analysis/source-analysis.ts
+var indexRuntimeSymbols = (sourceFile) => {
+	const symbols = /* @__PURE__ */ new Map();
+	for (const statement of sourceFile.statements) {
+		if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement)) && statement.name !== void 0) {
+			symbols.set(statement.name.text, statement);
+			continue;
+		}
+		if (!ts.isVariableStatement(statement)) continue;
+		for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name)) symbols.set(declaration.name.text, declaration);
+	}
+	return symbols;
+};
+/** Parses one supported Eve TypeScript module without executing or resolving it. */
+var analyzeEveSource = (path, bytes, signal) => {
+	const result = analyzeTypeScriptModule(path, bytes, {
+		namedConstructorImports: [],
+		packageName: "eve",
+		supportsDefaultConstructorImport: false
+	}, signal);
+	if (result.kind !== "valid") return result;
+	const analysis = Object.freeze({
+		...result.analysis,
+		defaultExports: Object.freeze(result.analysis.sourceFile.statements.filter((statement) => ts.isExportAssignment(statement) && !statement.isExportEquals)),
+		helperImports: indexEveHelperImports(result.analysis.sourceFile),
+		path,
+		runtimeSymbols: indexRuntimeSymbols(result.analysis.sourceFile)
+	});
+	return Object.freeze({
+		analysis,
+		kind: "valid"
+	});
+};
+//#endregion
+//#region src/source-analysis/object-definitions.ts
+var DEFINITION_HELPER_KEYS = Object.freeze({
+	agent: "defineAgent",
+	instructions: "defineInstructions",
+	skill: "defineSkill",
+	tool: "defineTool"
+});
+/** Returns the exact static name of an ordinary Eve object member. */
+var getEveObjectMemberName = (member) => {
+	if (!ts.isPropertyAssignment(member) && !ts.isMethodDeclaration(member) && !ts.isGetAccessorDeclaration(member) && !ts.isSetAccessorDeclaration(member) && !ts.isShorthandPropertyAssignment(member)) return null;
+	return ts.isIdentifier(member.name) || ts.isStringLiteral(member.name) ? member.name.text : null;
+};
+/** Indexes unique ordinary members without accepting spreads or prototype setters. */
+var getEveObjectMembers = (object) => {
+	const members = /* @__PURE__ */ new Map();
+	for (const member of object.properties) {
+		const name = getEveObjectMemberName(member);
+		if (name === null || name === "__proto__" || members.has(name) || ts.isShorthandPropertyAssignment(member) || ts.isGetAccessorDeclaration(member) || ts.isSetAccessorDeclaration(member)) return null;
+		members.set(name, member);
+	}
+	return members;
+};
+/** Returns an ordinary property-assignment expression from a closed definition. */
+var getEvePropertyExpression = (properties, name) => {
+	const property = properties.get(name);
+	return property !== void 0 && ts.isPropertyAssignment(property) ? unwrapExpression(property.initializer) : null;
+};
+/** Classifies one exact direct default-exported Eve helper definition. */
+var getEveDefinition = (analysis, kind) => {
+	if (analysis.defaultExports.length === 0) return Object.freeze({
+		hasDefaultExport: false,
+		kind: "absent"
+	});
+	if (analysis.defaultExports.length !== 1) return Object.freeze({
+		hasDefaultExport: true,
+		kind: "present-unsupported"
+	});
+	const declaration = analysis.defaultExports[0];
+	if (declaration === void 0) return Object.freeze({
+		hasDefaultExport: false,
+		kind: "absent"
+	});
+	const expression = unwrapExpression(declaration.expression);
+	if (!ts.isCallExpression(expression) || expression.arguments.length !== 1) return Object.freeze({
+		hasDefaultExport: true,
+		kind: "present-unsupported"
+	});
+	const callee = unwrapExpression(expression.expression);
+	const helperKey = DEFINITION_HELPER_KEYS[kind];
+	if (!ts.isIdentifier(callee) || !analysis.helperImports[helperKey].has(callee.text)) return Object.freeze({
+		hasDefaultExport: true,
+		kind: "present-unsupported"
+	});
+	const argument = expression.arguments[0];
+	if (argument === void 0) return Object.freeze({
+		hasDefaultExport: true,
+		kind: "present-unsupported"
+	});
+	const object = unwrapExpression(argument);
+	if (!ts.isObjectLiteralExpression(object)) return Object.freeze({
+		hasDefaultExport: true,
+		kind: "present-unsupported"
+	});
+	const properties = getEveObjectMembers(object);
+	return properties === null ? Object.freeze({
+		hasDefaultExport: true,
+		kind: "present-unsupported"
+	}) : Object.freeze({
+		call: expression,
+		declaration,
+		kind: "present-supported",
+		object,
+		properties
+	});
+};
+//#endregion
+//#region src/source-analysis/functions.ts
+/** Determines whether a declaration is one supported runtime function value. */
+var isEveFunctionDeclaration = (declaration) => {
+	if (declaration === void 0) return false;
+	if (ts.isFunctionDeclaration(declaration)) return declaration.body !== void 0;
+	if (!ts.isVariableDeclaration(declaration) || declaration.initializer === void 0) return false;
+	const initializer = unwrapExpression(declaration.initializer);
+	return ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer);
+};
+/** Classifies an inline or module-local direct runtime function expression. */
+var isEveFunctionValue = (analysis, expression) => {
+	const candidate = unwrapExpression(expression);
+	return ts.isArrowFunction(candidate) || ts.isFunctionExpression(candidate) || ts.isIdentifier(candidate) && isEveFunctionDeclaration(analysis.runtimeSymbols.get(candidate.text));
+};
+/** Resolves an inline, module-local, or exact relative-imported runtime function. */
+var isEveResolvedFunctionValue = async (session, analysis, expression) => {
+	if (isEveFunctionValue(analysis, expression)) return true;
+	const candidate = unwrapExpression(expression);
+	if (!ts.isIdentifier(candidate)) return false;
+	const imported = analysis.namedImports.get(candidate.text);
+	if (imported === void 0 || !imported.moduleSpecifier.startsWith(".")) return false;
+	const resolved = posix.resolve(posix.dirname(analysis.path), imported.moduleSpecifier);
+	const path = parseRepositoryPath(resolved.endsWith(".js") ? `${resolved.slice(0, -3)}.ts` : resolved);
+	if ((await session.getEntry(path))?.type !== "file" || !path.endsWith(".ts")) return false;
+	const result = await session.analyzeSource(path);
+	const exported = result.kind === "valid" ? result.analysis.exports.get(imported.importedName) : void 0;
+	return result.kind === "valid" && exported?.kind === "present-supported" && isEveFunctionDeclaration(result.analysis.runtimeSymbols.get(imported.importedName));
+};
+//#endregion
+//#region src/source-analysis/static-values.ts
+/** Resolves one exact Eve static string through supported local and relative bindings. */
+var resolveEveStaticString = (session, analysis, expression) => resolveStaticString({
+	analysis,
+	analyzeSource: (path) => session.analyzeSource(parseRepositoryPath(path)),
+	expression: unwrapExpression(expression),
+	getEntry: (path) => session.getEntry(parseRepositoryPath(path)),
+	parsePath: (path) => parseRepositoryPath(path),
+	...session.signal === void 0 ? {} : { signal: session.signal }
+});
+/** Resolves a closed object whose keys and values are exact static strings. */
+var isEveStaticStringRecord = async (session, analysis, expression) => {
+	const candidate = unwrapExpression(expression);
+	if (!ts.isObjectLiteralExpression(candidate)) return false;
+	const names = /* @__PURE__ */ new Set();
+	for (const property of candidate.properties) {
+		if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name) && !ts.isStringLiteral(property.name) || property.name.text === "__proto__" || names.has(property.name.text)) return false;
+		names.add(property.name.text);
+		if ((await resolveEveStaticString(session, analysis, property.initializer)).kind !== "supported") return false;
+	}
+	return true;
+};
+//#endregion
+//#region src/diagnostics/index.ts
+var EVE_ADAPTER_DIAGNOSTICS = Object.freeze({
+	EVE_PACKAGE_MANIFEST_INVALID: "The owning package manifest is invalid for Eve dependency detection.",
+	EVE_SDK_VERSION_UNSUPPORTED: "The observed Eve dependency range is disjoint from the supported range.",
+	EVE_SOURCE_TEXT_INVALID: "The referenced Eve source file is not valid normalized text.",
+	EVE_SOURCE_SYNTAX_INVALID: "The referenced Eve source file contains invalid TypeScript syntax.",
+	EVE_RUNTIME_AGENT_SYMBOL_NOT_FOUND: "The declared Eve runtime-agent symbol was not found.",
+	EVE_INSTRUCTION_LOADER_SYMBOL_NOT_FOUND: "The declared Eve instruction-loader symbol was not found.",
+	EVE_AGENT_OUTPUT_SCHEMA_SYMBOL_NOT_FOUND: "The declared Eve agent output-schema symbol was not found.",
+	EVE_TOOL_IMPLEMENTATION_SYMBOL_NOT_FOUND: "The declared Eve tool implementation symbol was not found.",
+	EVE_TOOL_REGISTRATION_SYMBOL_NOT_FOUND: "The declared Eve tool registration symbol was not found.",
+	EVE_TOOL_INPUT_SCHEMA_SYMBOL_NOT_FOUND: "The declared Eve tool input-schema symbol was not found.",
+	EVE_TOOL_OUTPUT_SCHEMA_SYMBOL_NOT_FOUND: "The declared Eve tool output-schema symbol was not found.",
+	EVE_SKILL_IMPLEMENTATION_SYMBOL_NOT_FOUND: "The declared Eve skill implementation symbol was not found.",
+	EVE_SKILL_REGISTRATION_SYMBOL_NOT_FOUND: "The declared Eve skill registration symbol was not found.",
+	EVE_INSTRUCTION_ROOT_CONFLICT: "The Eve instruction slot contains conflicting authored sources.",
+	EVE_INSTRUCTION_LOADER_NOT_WIRED: "The declared instruction loader is not wired to the supported Eve instruction surface.",
+	EVE_AGENT_OUTPUT_SCHEMA_NOT_WIRED: "The declared agent output schema is not wired to the Eve agent definition.",
+	EVE_TOOL_IMPLEMENTATION_NOT_WIRED: "The declared tool implementation is not wired to the Eve tool definition.",
+	EVE_TOOL_REGISTRATION_NOT_WIRED: "The declared tool registration is not wired to the owning Eve agent.",
+	EVE_TOOL_NAME_INVALID: "The Eve filesystem tool name is invalid.",
+	EVE_TOOL_NAME_RESERVED: "The Eve filesystem tool name is reserved by the runtime.",
+	EVE_TOOL_RUNTIME_NAME_COLLISION: "Multiple Eve tool sources resolve to the same runtime tool name.",
+	EVE_TOOL_NAME_MISMATCH: "The declared tool name does not match the Eve path-derived runtime name.",
+	EVE_TOOL_INPUT_SCHEMA_NOT_WIRED: "The declared tool input schema is not wired to the Eve tool definition.",
+	EVE_TOOL_OUTPUT_SCHEMA_NOT_WIRED: "The declared tool output schema is not wired to the Eve tool definition.",
+	EVE_SKILL_IMPLEMENTATION_NOT_WIRED: "The declared skill implementation is not the discovered Eve skill artifact.",
+	EVE_SKILL_REGISTRATION_NOT_WIRED: "The declared skill registration is not wired to the owning Eve agent.",
+	EVE_SKILL_NAME_MISMATCH: "The declared skill name does not match the Eve path-derived runtime name.",
+	EVE_TOOL_SUBAGENT_NAME_COLLISION: "The Eve tool and local subagent use the same runtime tool name.",
+	EVE_SUBAGENT_PARENT_AMBIGUOUS: "Multiple registered Eve agents map to the local subagent's immediate parent root.",
+	EVE_ROUTING_DESCRIPTION_MISSING: "The supported Eve local subagent definition is missing its routing description.",
+	EVE_ROUTING_DESCRIPTION_NOT_WIRED: "The Eve local subagent description does not use the target effective routing description."
+});
+/** Creates one frozen, safely namespaced Eve adapter diagnostic. */
+var createEveDiagnostic = (input) => Object.freeze({
+	...input,
+	details: Object.freeze({ ...input.details }),
+	entity: input.entity === null ? null : Object.freeze({ ...input.entity }),
+	message: EVE_ADAPTER_DIAGNOSTICS[input.code],
+	source: "eve"
+});
+//#endregion
+//#region src/inspection/common.ts
+/** Compares exact strings without locale-sensitive behavior. */
+var compareEveStrings = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+var freezeReference = (reference) => Object.freeze({
+	path: reference.path,
+	...reference.symbol === void 0 ? {} : { symbol: reference.symbol }
+});
+/** Creates one deeply immutable Eve evidence record. */
+var createEveEvidence = (evidence) => Object.freeze({
+	...evidence,
+	details: Object.freeze({ ...evidence.details }),
+	references: Object.freeze(evidence.references.map(freezeReference))
+});
+var createEntity = (agentId, capabilityKind, capabilityId) => Object.freeze({
+	adapterId: "eve",
+	agentId,
+	...capabilityKind === void 0 || capabilityId === void 0 ? {} : {
+		capabilityId,
+		capabilityKind
+	}
+});
+/** Appends one stable package-owned Eve diagnostic. */
+var addEveDiagnostic = (diagnostics, code, path, agentId, range = null, capabilityKind, capabilityId, details = {}) => {
+	diagnostics.push(createEveDiagnostic({
+		code,
+		details,
+		entity: createEntity(agentId, capabilityKind, capabilityId),
+		path,
+		pointer: null,
+		range
+	}));
+};
+/** Adds the sole permitted diagnostic for invalid referenced TypeScript source. */
+var addEveSourceFailureDiagnostic = (diagnostics, result, path, agentId, capabilityKind, capabilityId) => {
+	const hasMatchingDiagnostic = (code) => diagnostics.some((diagnostic) => diagnostic.code === code && diagnostic.path === path && diagnostic.entity?.agentId === agentId && diagnostic.entity.capabilityKind === capabilityKind && diagnostic.entity.capabilityId === capabilityId);
+	if (result.kind === "invalid-text") {
+		if (!hasMatchingDiagnostic("EVE_SOURCE_TEXT_INVALID")) addEveDiagnostic(diagnostics, "EVE_SOURCE_TEXT_INVALID", path, agentId, null, capabilityKind, capabilityId);
+		return true;
+	}
+	if (result.kind === "invalid-syntax") {
+		if (!hasMatchingDiagnostic("EVE_SOURCE_SYNTAX_INVALID")) addEveDiagnostic(diagnostics, "EVE_SOURCE_SYNTAX_INVALID", path, agentId, result.range, capabilityKind, capabilityId);
+		return true;
+	}
+	return false;
+};
+/** Returns the Core scalar range for one Eve source node. */
+var locateEveNode = (analysis, node) => analysis.text.locator.locateRange(node.getStart(analysis.sourceFile), node.getEnd());
+//#endregion
+//#region src/inspection/package-inspection.ts
+/** Inspects one scoped agent's nearest Eve package declaration. */
+var inspectEvePackage = async (session, agent, sourcePath, evidence, diagnostics) => {
+	const result = await session.discoverPackage(sourcePath);
+	if (result.kind === "absent") return null;
+	if (result.kind === "invalid") {
+		addEveDiagnostic(diagnostics, "EVE_PACKAGE_MANIFEST_INVALID", result.path, agent.id);
+		return null;
+	}
+	const { observation } = result;
+	if (observation.compatibility === "unsupported") {
+		addEveDiagnostic(diagnostics, "EVE_SDK_VERSION_UNSUPPORTED", observation.path, agent.id);
+		return null;
+	}
+	for (const declaration of observation.declarations) {
+		const isSemver = validRange(declaration.declaredRange, {
+			includePrerelease: false,
+			loose: false
+		}) !== null;
+		evidence.push(createEveEvidence({
+			agentId: agent.id,
+			capabilityId: null,
+			capabilityKind: null,
+			details: {
+				dependencyKind: declaration.dependencyKind,
+				...isSemver ? { declaredRange: declaration.declaredRange } : {},
+				packageClassification: observation.compatibility,
+				targetId: EVE_TARGET_ID
+			},
+			kind: "runtime-package",
+			references: [{ path: observation.path }],
+			runtimeName: null,
+			source: "eve"
+		}));
+	}
+	return observation;
+};
+//#endregion
+//#region src/inspection/relationships.ts
+var resolveRelativeImportPath = (containingPath, moduleSpecifier) => {
+	if (!moduleSpecifier.startsWith(".")) return null;
+	const resolved = posix.resolve(posix.dirname(containingPath), moduleSpecifier);
+	if (resolved.endsWith(".js")) return parseRepositoryPath(`${resolved.slice(0, -3)}.ts`);
+	return resolved.endsWith(".ts") ? parseRepositoryPath(resolved) : null;
+};
+var isSupportedRuntimeSymbol = (analysis, symbol, requiresFunction) => {
+	const declaration = analysis.runtimeSymbols.get(symbol);
+	if (declaration === void 0) return false;
+	return !requiresFunction || isEveFunctionDeclaration(declaration);
+};
+/** Classifies whether one direct expression uses the exact manifest-bound runtime value. */
+var classifyEveBoundExpression = async (session, analysis, expression, reference, requiresFunction = false) => {
+	if (reference.symbol === void 0 || reference.symbol === "default") return "unresolved";
+	const boundResult = await session.analyzeSource(reference.path);
+	if (boundResult.kind !== "valid") return "unresolved";
+	if (analysis.path === reference.path) {
+		if (!boundResult.analysis.runtimeSymbols.has(reference.symbol)) return boundResult.analysis.exports.has(reference.symbol) ? "unresolved" : "missing";
+		if (!isSupportedRuntimeSymbol(boundResult.analysis, reference.symbol, requiresFunction)) return "unresolved";
+	} else {
+		const exported = boundResult.analysis.exports.get(reference.symbol);
+		if (exported === void 0) return "missing";
+		if (exported.kind !== "present-supported" || !isSupportedRuntimeSymbol(boundResult.analysis, reference.symbol, requiresFunction)) return "unresolved";
+	}
+	if (expression === null) return "different";
+	const candidate = unwrapExpression(expression);
+	if (!ts.isIdentifier(candidate)) return "unresolved";
+	if (analysis.path === reference.path && candidate.text === reference.symbol && isSupportedRuntimeSymbol(analysis, candidate.text, requiresFunction)) return "wired";
+	const imported = analysis.namedImports.get(candidate.text);
+	if (imported === void 0) return analysis.runtimeSymbols.has(candidate.text) ? "different" : "unresolved";
+	return resolveRelativeImportPath(analysis.path, imported.moduleSpecifier) === reference.path && imported.importedName === reference.symbol ? "wired" : "different";
+};
+/** Classifies one direct call to an exact manifest-bound function. */
+var classifyEveBoundCall = async (session, analysis, expression, reference) => {
+	if (expression === null) return classifyEveBoundExpression(session, analysis, null, reference, true);
+	const candidate = unwrapExpression(expression);
+	return ts.isCallExpression(candidate) ? classifyEveBoundExpression(session, analysis, candidate.expression, reference, true) : "unresolved";
+};
+//#endregion
+//#region src/inspection/agent-inspection.ts
+var POSITIVE_AGENT_KEYS = /* @__PURE__ */ new Set([
+	"description",
+	"model",
+	"outputSchema"
+]);
+/** Inspects one exact manifest-bound Eve agent definition and its output schema. */
+var inspectEveAgent = async (session, agent, evidence, diagnostics) => {
+	const runtimeAgent = agent.declaration.bindings?.runtimeAgent;
+	if (runtimeAgent === void 0 || !runtimeAgent.path.endsWith("/agent.ts")) return null;
+	const packageObservation = await inspectEvePackage(session, agent, runtimeAgent.path, evidence, diagnostics);
+	if (packageObservation === null) return null;
+	const root = resolveEveAgentRoot(runtimeAgent.path, packageObservation);
+	if (root === null) return null;
+	const rootIndex = await session.indexAgentRoot(root.agentRoot);
+	if (rootIndex.isAgentSlotCollided) return null;
+	const result = await session.analyzeSource(runtimeAgent.path);
+	if (addEveSourceFailureDiagnostic(diagnostics, result, runtimeAgent.path, agent.id)) return null;
+	if (result.kind !== "valid") return null;
+	evidence.push(createEveEvidence({
+		agentId: agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: { language: "typescript" },
+		kind: "language",
+		references: [runtimeAgent],
+		runtimeName: null,
+		source: "eve"
+	}));
+	if (runtimeAgent.symbol !== void 0 && runtimeAgent.symbol !== "default") return null;
+	const definition = getEveDefinition(result.analysis, "agent");
+	if (definition.kind === "absent") {
+		if (runtimeAgent.symbol === "default") addEveDiagnostic(diagnostics, "EVE_RUNTIME_AGENT_SYMBOL_NOT_FOUND", runtimeAgent.path, agent.id);
+		return null;
+	}
+	if (definition.kind !== "present-supported" || [...definition.properties].some(([key, property]) => !POSITIVE_AGENT_KEYS.has(key) || !ts.isPropertyAssignment(property))) return null;
+	const model = getEvePropertyExpression(definition.properties, "model");
+	if (model === null || (await resolveEveStaticString(session, result.analysis, model)).kind !== "supported") return null;
+	evidence.push(createEveEvidence({
+		agentId: agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: {
+			agentKind: root.agentKind,
+			agentRoot: root.agentRoot,
+			layout: root.layout,
+			targetId: EVE_TARGET_ID
+		},
+		kind: "agent-definition",
+		references: [runtimeAgent],
+		runtimeName: root.runtimeName,
+		source: "eve"
+	}));
+	const outputSchema = agent.declaration.bindings?.outputSchema;
+	if (outputSchema !== void 0 && outputSchema.symbol !== void 0) {
+		if (!addEveSourceFailureDiagnostic(diagnostics, await session.analyzeSource(outputSchema.path), outputSchema.path, agent.id)) {
+			const state = await classifyEveBoundExpression(session, result.analysis, getEvePropertyExpression(definition.properties, "outputSchema"), outputSchema);
+			if (state === "missing") addEveDiagnostic(diagnostics, "EVE_AGENT_OUTPUT_SCHEMA_SYMBOL_NOT_FOUND", outputSchema.path, agent.id);
+			else if (state === "wired") evidence.push(createEveEvidence({
+				agentId: agent.id,
+				capabilityId: null,
+				capabilityKind: null,
+				details: { schemaRole: "agent-output" },
+				kind: "schema",
+				references: [outputSchema],
+				runtimeName: outputSchema.symbol,
+				source: "eve"
+			}));
+			else if (state === "different") addEveDiagnostic(diagnostics, "EVE_AGENT_OUTPUT_SCHEMA_NOT_WIRED", runtimeAgent.path, agent.id);
+		}
+	}
+	const descriptionProperty = definition.properties.get("description");
+	const descriptionExpression = getEvePropertyExpression(definition.properties, "description");
+	let routingDescription;
+	if (descriptionProperty === void 0) routingDescription = Object.freeze({
+		kind: "absent",
+		range: null
+	});
+	else if (descriptionExpression === null) routingDescription = Object.freeze({
+		kind: "unsupported",
+		range: locateEveNode(result.analysis, descriptionProperty)
+	});
+	else {
+		const staticDescription = await resolveEveStaticString(session, result.analysis, descriptionExpression);
+		const range = locateEveNode(result.analysis, descriptionProperty);
+		routingDescription = staticDescription.kind === "supported" ? Object.freeze({
+			kind: "supported",
+			range,
+			value: staticDescription.value
+		}) : Object.freeze({
+			kind: "unsupported",
+			range
+		});
+	}
+	return Object.freeze({
+		agent,
+		analysis: result.analysis,
+		definition,
+		packageObservation,
+		root,
+		rootIndex,
+		routingDescription
+	});
+};
+//#endregion
+//#region src/inspection/instruction-inspection.ts
+var getDirectName = (root, entry) => {
+	const prefix = root === "/" ? "/" : `${root}/`;
+	return entry.path.slice(prefix.length);
+};
+var isModernMarkdown = (name) => /^instructions\.md$/iu.test(name);
+var isLegacyMarkdown = (name) => /^system\.md$/iu.test(name);
+var isModernModule = (name) => /^instructions\.(?:cts|mts|cjs|mjs|ts|js)$/u.test(name);
+var isLegacyModule = (name) => /^system\.(?:cts|mts|cjs|mjs|ts|js)$/u.test(name);
+var addInstructionConflicts = (diagnostics, agentId, candidates) => {
+	const sorted = [...candidates].sort((left, right) => compareEveStrings(left.path, right.path));
+	const primary = sorted[0];
+	if (primary === void 0) return;
+	for (const conflicting of sorted.slice(1)) addEveDiagnostic(diagnostics, "EVE_INSTRUCTION_ROOT_CONFLICT", primary.path, agentId, null, void 0, void 0, { conflictingPath: conflicting.path });
+};
+var inspectMarkdown = async (session, definition, path, evidence, diagnostics) => {
+	const binding = definition.agent.declaration.bindings?.instructionLoader;
+	if (binding === void 0) return;
+	if (!normalizeText(await session.reader.readFile(path, session.signal === void 0 ? void 0 : { signal: session.signal })).valid) {
+		addEveDiagnostic(diagnostics, "EVE_SOURCE_TEXT_INVALID", path, definition.agent.id);
+		return;
+	}
+	if (binding.path === path && binding.symbol === void 0) {
+		evidence.push(createEveEvidence({
+			agentId: definition.agent.id,
+			capabilityId: null,
+			capabilityKind: null,
+			details: {},
+			kind: "instruction-loader",
+			references: [binding],
+			runtimeName: null,
+			source: "eve"
+		}));
+		return;
+	}
+	if (binding.symbol === void 0) addEveDiagnostic(diagnostics, "EVE_INSTRUCTION_LOADER_NOT_WIRED", path, definition.agent.id);
+};
+var inspectTypeScriptInstructions = async (session, definition, path, evidence, diagnostics) => {
+	const binding = definition.agent.declaration.bindings?.instructionLoader;
+	if (binding === void 0) return;
+	const result = await session.analyzeSource(path);
+	if (addEveSourceFailureDiagnostic(diagnostics, result, path, definition.agent.id)) return;
+	if (result.kind !== "valid") return;
+	const instructions = getEveDefinition(result.analysis, "instructions");
+	if (instructions.kind !== "present-supported" || instructions.properties.size < 1 || instructions.properties.size > 2 || !instructions.properties.has("content") || [...instructions.properties].some(([key, property]) => !["content", "role"].includes(key) || !ts.isPropertyAssignment(property))) return;
+	const role = getEvePropertyExpression(instructions.properties, "role");
+	if (role !== null && getStaticString(role) !== "system") {
+		if (getStaticString(role) === "user") addEveDiagnostic(diagnostics, "EVE_INSTRUCTION_LOADER_NOT_WIRED", path, definition.agent.id);
+		return;
+	}
+	if (addEveSourceFailureDiagnostic(diagnostics, await session.analyzeSource(binding.path), binding.path, definition.agent.id)) return;
+	const state = await classifyEveBoundCall(session, result.analysis, getEvePropertyExpression(instructions.properties, "content"), binding);
+	if (state === "missing") addEveDiagnostic(diagnostics, "EVE_INSTRUCTION_LOADER_SYMBOL_NOT_FOUND", binding.path, definition.agent.id);
+	else if (state === "wired") evidence.push(createEveEvidence({
+		agentId: definition.agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: {},
+		kind: "instruction-loader",
+		references: [binding],
+		runtimeName: binding.symbol ?? null,
+		source: "eve"
+	}));
+	else if (state === "different") addEveDiagnostic(diagnostics, "EVE_INSTRUCTION_LOADER_NOT_WIRED", path, definition.agent.id);
+};
+/** Inspects the exclusive modern instruction surface for one supported Eve agent. */
+var inspectEveInstructions = async (session, definition, evidence, diagnostics) => {
+	const named = definition.rootIndex.instructionEntries.map((entry) => ({
+		entry,
+		name: getDirectName(definition.root.agentRoot, entry)
+	}));
+	if (named.find(({ entry, name }) => entry.type === "directory" && name === "instructions") !== void 0) return;
+	const modern = named.filter(({ entry, name }) => entry.type === "file" && (isModernMarkdown(name) || isModernModule(name)));
+	if (modern.length > 1) {
+		if (!modern.every(({ name }) => isModernMarkdown(name))) addInstructionConflicts(diagnostics, definition.agent.id, modern.map(({ entry }) => entry));
+		return;
+	}
+	if (modern.length === 1) {
+		const modernSource = modern[0];
+		if (modernSource === void 0) return;
+		const { entry, name } = modernSource;
+		if (name === "instructions.md") await inspectMarkdown(session, definition, entry.path, evidence, diagnostics);
+		else if (name === "instructions.ts") await inspectTypeScriptInstructions(session, definition, entry.path, evidence, diagnostics);
+		return;
+	}
+	const legacy = named.filter(({ entry, name }) => entry.type === "file" && (isLegacyMarkdown(name) || isLegacyModule(name)));
+	if (legacy.length > 1 && !legacy.every(({ name }) => isLegacyMarkdown(name))) {
+		addInstructionConflicts(diagnostics, definition.agent.id, legacy.map(({ entry }) => entry));
+		return;
+	}
+	if (legacy.length === 0 && definition.agent.declaration.bindings?.instructionLoader !== void 0) addEveDiagnostic(diagnostics, "EVE_INSTRUCTION_LOADER_NOT_WIRED", definition.analysis.path, definition.agent.id);
+};
+//#endregion
+//#region src/package-discovery/index.ts
+/** Discovers the nearest owning Eve package and its safe root identity. */
+var discoverEvePackage = async (reader, sourcePath, signal) => {
+	const result = await discoverPackage({
+		includeManifestPackageName: true,
+		packageName: "eve",
+		reader: {
+			getEntry: (path) => reader.getEntry(path, signal === void 0 ? void 0 : { signal }),
+			readFile: (path) => reader.readFile(path, signal === void 0 ? void 0 : { signal })
+		},
+		...signal === void 0 ? {} : { signal },
+		sourcePath,
+		supportedRange: EVE_SUPPORTED_PACKAGE_RANGE
+	});
+	if (result.kind !== "observed") return result;
+	return Object.freeze({
+		kind: "observed",
+		observation: Object.freeze({
+			...result.observation,
+			manifestPackageName: result.observation.manifestPackageName ?? null,
+			path: result.observation.path
+		})
+	});
+};
+//#endregion
+//#region src/inspection/session.ts
+/** Creates one operation-local Eve inspection session with source and listing caches. */
+var createEveInspectionSession = (context) => {
+	const base = createInspectionSession({
+		analyzeSource: analyzeEveSource,
+		discoverPackage: (path, signal) => discoverEvePackage(context.repository, path, signal),
+		getEntry: (path, signal) => context.repository.getEntry(path, signal === void 0 ? void 0 : { signal }),
+		readFile: (path, signal) => context.repository.readFile(path, signal === void 0 ? void 0 : { signal }),
+		...context.signal === void 0 ? {} : { signal: context.signal }
+	});
+	const rootCache = /* @__PURE__ */ new Map();
+	const indexAgentRoot = (path) => {
+		context.signal?.throwIfAborted();
+		const existing = rootCache.get(path);
+		if (existing !== void 0) return existing;
+		const indexed = (async () => {
+			const entries = [];
+			for await (const entry of context.repository.listEntries({
+				prefix: path,
+				...context.signal === void 0 ? {} : { signal: context.signal }
+			})) {
+				context.signal?.throwIfAborted();
+				entries.push(entry);
+			}
+			return createEveAgentRootIndex(path, entries);
+		})();
+		rootCache.set(path, indexed);
+		return indexed;
+	};
+	return Object.freeze({
+		...base,
+		indexAgentRoot,
+		reader: context.repository
+	});
+};
+//#endregion
+//#region src/inspection/skill-inspection.ts
+var ALLOWED_SKILL_KEYS = /* @__PURE__ */ new Set([
+	"description",
+	"files",
+	"license",
+	"markdown",
+	"metadata"
+]);
+var prepareSkill = async (session, candidate) => {
+	if (candidate.kind !== "typescript" || candidate.isCollidedSlot) return null;
+	const result = await session.analyzeSource(candidate.path);
+	if (result.kind !== "valid") return null;
+	const definition = getEveDefinition(result.analysis, "skill");
+	if (definition.kind !== "present-supported" || [...definition.properties].some(([key, property]) => !ALLOWED_SKILL_KEYS.has(key) || !ts.isPropertyAssignment(property))) return null;
+	const description = getEvePropertyExpression(definition.properties, "description");
+	const markdown = getEvePropertyExpression(definition.properties, "markdown");
+	const license = getEvePropertyExpression(definition.properties, "license");
+	const metadata = getEvePropertyExpression(definition.properties, "metadata");
+	const files = getEvePropertyExpression(definition.properties, "files");
+	const isRegistrationEligible = description !== null && markdown !== null && (await resolveEveStaticString(session, result.analysis, description)).kind === "supported" && (await resolveEveStaticString(session, result.analysis, markdown)).kind === "supported" && (license === null || (await resolveEveStaticString(session, result.analysis, license)).kind === "supported") && (metadata === null || await isEveStaticStringRecord(session, result.analysis, metadata)) && (files === null || await isEveStaticStringRecord(session, result.analysis, files));
+	return Object.freeze({
+		analysis: result.analysis,
+		candidate,
+		definition,
+		isRegistrationEligible
+	});
+};
+var selectSkill = (candidates, skill) => {
+	const implementationMatches = candidates.filter(({ path }) => path === skill.implementation.path);
+	if (implementationMatches.length === 1) return implementationMatches[0] ?? null;
+	const nameMatches = candidates.filter(({ identity }) => identity === skill.name);
+	return nameMatches.length === 1 ? nameMatches[0] ?? null : null;
+};
+/** Inspects flat, packaged, and TypeScript Eve skills for one scoped agent. */
+var inspectEveSkills = async (session, definition, evidence, diagnostics) => {
+	for (const [capabilityId, skill] of Object.entries(definition.agent.declaration.skills ?? {})) {
+		const candidate = selectSkill(definition.rootIndex.skillCandidates, skill);
+		if (candidate === null || candidate.isCollidedSlot) continue;
+		const supportsImplementationSymbol = candidate.kind === "typescript" ? skill.implementation.symbol === void 0 || skill.implementation.symbol === "default" : skill.implementation.symbol === void 0;
+		if (skill.implementation.path !== candidate.path || !supportsImplementationSymbol) {
+			if (supportsImplementationSymbol) addEveDiagnostic(diagnostics, "EVE_SKILL_IMPLEMENTATION_NOT_WIRED", candidate.path, definition.agent.id, null, "skill", capabilityId);
+			continue;
+		}
+		if (candidate.kind !== "typescript") continue;
+		const prepared = await prepareSkill(session, candidate);
+		if (prepared === null) {
+			const result = await session.analyzeSource(candidate.path);
+			if (addEveSourceFailureDiagnostic(diagnostics, result, candidate.path, definition.agent.id, "skill", capabilityId)) continue;
+			if (skill.implementation.symbol === "default") {
+				if (result.kind === "valid" && getEveDefinition(result.analysis, "skill").kind === "absent") addEveDiagnostic(diagnostics, "EVE_SKILL_IMPLEMENTATION_SYMBOL_NOT_FOUND", candidate.path, definition.agent.id, null, "skill", capabilityId);
+			}
+			continue;
+		}
+		const registration = skill.registration;
+		let isRegistrationWired = registration === void 0;
+		if (registration !== void 0) {
+			if (registration.path === candidate.path && (registration.symbol === void 0 || registration.symbol === "default")) isRegistrationWired = true;
+			else if (registration.symbol === "default") {
+				const result = await session.analyzeSource(registration.path);
+				if (addEveSourceFailureDiagnostic(diagnostics, result, registration.path, definition.agent.id, "skill", capabilityId)) continue;
+				const registrationDefinition = result.kind === "valid" ? getEveDefinition(result.analysis, "skill") : null;
+				if (registrationDefinition?.kind === "absent") addEveDiagnostic(diagnostics, "EVE_SKILL_REGISTRATION_SYMBOL_NOT_FOUND", registration.path, definition.agent.id, null, "skill", capabilityId);
+				else if (registrationDefinition?.kind === "present-supported") addEveDiagnostic(diagnostics, "EVE_SKILL_REGISTRATION_NOT_WIRED", candidate.path, definition.agent.id, null, "skill", capabilityId);
+			} else if (registration.symbol === void 0) addEveDiagnostic(diagnostics, "EVE_SKILL_REGISTRATION_NOT_WIRED", candidate.path, definition.agent.id, null, "skill", capabilityId);
+		}
+		if (!prepared.isRegistrationEligible || !isRegistrationWired) continue;
+		if (skill.name !== candidate.identity) {
+			addEveDiagnostic(diagnostics, "EVE_SKILL_NAME_MISMATCH", candidate.path, definition.agent.id, null, "skill", capabilityId);
+			continue;
+		}
+		evidence.push(createEveEvidence({
+			agentId: definition.agent.id,
+			capabilityId,
+			capabilityKind: "skill",
+			details: { registrationKind: "typescript" },
+			kind: "skill-registration",
+			references: [{ path: candidate.path }],
+			runtimeName: candidate.identity,
+			source: "eve"
+		}));
+	}
+};
+//#endregion
+//#region src/inspection/subagent-inspection.ts
+/** Inspects exact immediate directory-backed local-subagent registrations. */
+var inspectEveSubagents = (definitions, preparedToolNames, evidence, diagnostics) => {
+	for (const target of definitions) {
+		if (target.root.agentKind !== "local-subagent" || target.root.parentRoot === null || target.root.runtimeName === null) continue;
+		const parents = definitions.filter(({ root }) => root.agentRoot === target.root.parentRoot).sort((left, right) => compareEveStrings(left.agent.id, right.agent.id));
+		if (parents.length > 1) {
+			addEveDiagnostic(diagnostics, "EVE_SUBAGENT_PARENT_AMBIGUOUS", target.agent.declaration.bindings?.runtimeAgent?.path ?? null, target.agent.id, null, void 0, void 0, { candidateAgentIds: parents.map(({ agent }) => agent.id).join(",") });
+			continue;
+		}
+		const parent = parents[0];
+		if (parent === void 0) continue;
+		const candidates = parent.rootIndex.subagentCandidates.filter(({ runtimeName }) => runtimeName === target.root.runtimeName);
+		const candidate = candidates.find(({ agentPath, isDirectoryBacked }) => isDirectoryBacked && agentPath === target.agent.declaration.bindings?.runtimeAgent?.path);
+		if (candidates.length !== 1 || candidate === void 0 || candidate.isExtensionReserved) continue;
+		if ((preparedToolNames.get(parent.agent.id) ?? /* @__PURE__ */ new Set()).has(target.root.runtimeName) || EVE_FRAMEWORK_TOOL_NAMES.includes(target.root.runtimeName) || target.root.runtimeName === "load_skill") {
+			addEveDiagnostic(diagnostics, "EVE_TOOL_SUBAGENT_NAME_COLLISION", target.agent.declaration.bindings?.runtimeAgent?.path ?? null, target.agent.id, null, void 0, void 0, { collisionKind: "runtime-tool" });
+			continue;
+		}
+		if (target.routingDescription.kind === "absent" || target.routingDescription.kind === "supported" && target.routingDescription.value === "") {
+			addEveDiagnostic(diagnostics, "EVE_ROUTING_DESCRIPTION_MISSING", target.agent.declaration.bindings?.runtimeAgent?.path ?? null, target.agent.id, target.routingDescription.range);
+			continue;
+		}
+		if (target.routingDescription.kind !== "supported") continue;
+		const routingDescriptionSource = target.agent.handoffDescription === null ? "agent-description" : "handoff-description";
+		const effectiveDescription = target.agent.handoffDescription?.value ?? target.agent.description.value;
+		const isWired = target.routingDescription.value === effectiveDescription;
+		if (!isWired) addEveDiagnostic(diagnostics, "EVE_ROUTING_DESCRIPTION_NOT_WIRED", target.agent.declaration.bindings?.runtimeAgent?.path ?? null, target.agent.id, target.routingDescription.range);
+		const parentReference = parent.agent.declaration.bindings?.runtimeAgent;
+		const targetReference = target.agent.declaration.bindings?.runtimeAgent;
+		if (parentReference === void 0 || targetReference === void 0) continue;
+		evidence.push(createEveEvidence({
+			agentId: parent.agent.id,
+			capabilityId: null,
+			capabilityKind: null,
+			details: {
+				registrationKind: "local-subagent-package",
+				routingDescriptionSource,
+				routingDescriptionWired: isWired,
+				targetAgentId: target.agent.id,
+				targetRuntimeName: target.root.runtimeName
+			},
+			kind: "handoff-registration",
+			references: [parentReference, targetReference],
+			runtimeName: target.root.runtimeName,
+			source: "eve"
+		}));
+	}
+};
+//#endregion
+//#region src/inspection/tool-inspection.ts
+var ALLOWED_TOOL_KEYS = /* @__PURE__ */ new Set([
+	"approval",
+	"description",
+	"execute",
+	"inputSchema",
+	"outputSchema",
+	"toModelOutput"
+]);
+var isApprovalSupported = async (session, analysis, property) => {
+	if (property === void 0) return true;
+	if (!ts.isPropertyAssignment(property)) return false;
+	if (await isEveResolvedFunctionValue(session, analysis, property.initializer)) return true;
+	const expression = property.initializer;
+	if (!ts.isObjectLiteralExpression(expression)) return false;
+	const members = getEveObjectMembers(expression);
+	if (members === null || !members.has("request") || [...members.keys()].some((key) => !["request", "response"].includes(key))) return false;
+	for (const [name, member] of members) {
+		if (!ts.isMethodDeclaration(member) && (!ts.isPropertyAssignment(member) || !await isEveResolvedFunctionValue(session, analysis, member.initializer))) return false;
+		if (!["request", "response"].includes(name)) return false;
+	}
+	return true;
+};
+var prepareTool = async (session, candidate) => {
+	if (!candidate.isSupportedSource || candidate.isCollidedSlot || candidate.isExtensionReserved) return null;
+	const result = await session.analyzeSource(candidate.path);
+	if (result.kind !== "valid") return null;
+	const definition = getEveDefinition(result.analysis, "tool");
+	if (definition.kind !== "present-supported") return null;
+	const description = getEvePropertyExpression(definition.properties, "description");
+	const inputSchema = getEvePropertyExpression(definition.properties, "inputSchema");
+	const executeMember = definition.properties.get("execute");
+	const toModelOutput = definition.properties.get("toModelOutput");
+	const hasSupportedMembers = [...definition.properties].every(([key, member]) => {
+		if (!ALLOWED_TOOL_KEYS.has(key)) return false;
+		return ts.isPropertyAssignment(member) || (key === "execute" || key === "toModelOutput") && ts.isMethodDeclaration(member);
+	});
+	const executeSupported = executeMember !== void 0 && (ts.isMethodDeclaration(executeMember) || ts.isPropertyAssignment(executeMember) && await isEveResolvedFunctionValue(session, result.analysis, executeMember.initializer));
+	const toModelOutputSupported = toModelOutput === void 0 || ts.isMethodDeclaration(toModelOutput) || ts.isPropertyAssignment(toModelOutput) && await isEveResolvedFunctionValue(session, result.analysis, toModelOutput.initializer);
+	const isRegistrationEligible = hasSupportedMembers && description !== null && inputSchema !== null && executeSupported && toModelOutputSupported && await isApprovalSupported(session, result.analysis, definition.properties.get("approval")) && (await resolveEveStaticString(session, result.analysis, description)).kind === "supported";
+	return Object.freeze({
+		analysis: result.analysis,
+		candidate,
+		definition,
+		isRegistrationEligible
+	});
+};
+var selectTool = (prepared, tool) => {
+	const nameMatches = prepared.filter(({ candidate }) => candidate.runtimeName === tool.name);
+	if (nameMatches.length === 1) return nameMatches[0] ?? null;
+	const implementationMatches = prepared.filter(({ candidate }) => candidate.path === tool.implementation.path);
+	if (implementationMatches.length === 1) return implementationMatches[0] ?? null;
+	const registrationMatches = prepared.filter(({ candidate }) => candidate.path === tool.registration?.path);
+	return registrationMatches.length === 1 ? registrationMatches[0] ?? null : null;
+};
+var selectToolCandidate = (candidates, tool) => {
+	const nameMatches = candidates.filter(({ runtimeName }) => runtimeName === tool.name);
+	if (nameMatches.length === 1) return nameMatches[0] ?? null;
+	const implementationMatches = candidates.filter(({ path }) => path === tool.implementation.path);
+	if (implementationMatches.length === 1) return implementationMatches[0] ?? null;
+	const registrationMatches = candidates.filter(({ path }) => path === tool.registration?.path);
+	return registrationMatches.length === 1 ? registrationMatches[0] ?? null : null;
+};
+var inspectToolSchema = async (session, definition, prepared, capabilityId, role, tool, evidence, diagnostics) => {
+	const reference = role === "input" ? tool.inputSchema : tool.outputSchema;
+	if (reference?.symbol === void 0) return;
+	if (addEveSourceFailureDiagnostic(diagnostics, await session.analyzeSource(reference.path), reference.path, definition.agent.id, "tool", capabilityId)) return;
+	const propertyName = role === "input" ? "inputSchema" : "outputSchema";
+	const state = await classifyEveBoundExpression(session, prepared.analysis, getEvePropertyExpression(prepared.definition.properties, propertyName), reference);
+	const prefix = role === "input" ? "INPUT" : "OUTPUT";
+	if (state === "missing") addEveDiagnostic(diagnostics, `EVE_TOOL_${prefix}_SCHEMA_SYMBOL_NOT_FOUND`, reference.path, definition.agent.id, null, "tool", capabilityId);
+	else if (state === "wired") evidence.push(createEveEvidence({
+		agentId: definition.agent.id,
+		capabilityId,
+		capabilityKind: "tool",
+		details: { schemaRole: `tool-${role}` },
+		kind: "schema",
+		references: [reference],
+		runtimeName: reference.symbol,
+		source: "eve"
+	}));
+	else if (state === "different") addEveDiagnostic(diagnostics, `EVE_TOOL_${prefix}_SCHEMA_NOT_WIRED`, prepared.candidate.path, definition.agent.id, null, "tool", capabilityId);
+};
+/** Inspects recursive static Eve tools declared by one scoped agent. */
+var inspectEveTools = async (session, definition, evidence, diagnostics) => {
+	const prepared = (await Promise.all(definition.rootIndex.toolCandidates.map((candidate) => prepareTool(session, candidate)))).filter((candidate) => candidate !== null);
+	const runtimeGroups = /* @__PURE__ */ new Map();
+	for (const candidate of definition.rootIndex.toolCandidates) {
+		if (!candidate.isSupportedSource || candidate.isCollidedSlot || candidate.isExtensionReserved || candidate.runtimeName === "Workflow" || candidate.segments.some((segment) => !EVE_TOOL_NAME_PATTERN.test(segment))) continue;
+		const group = runtimeGroups.get(candidate.runtimeName) ?? [];
+		group.push(candidate);
+		runtimeGroups.set(candidate.runtimeName, group);
+	}
+	const collidedNames = /* @__PURE__ */ new Set();
+	for (const [runtimeName, candidates] of runtimeGroups) {
+		if (candidates.length < 2) continue;
+		collidedNames.add(runtimeName);
+		const sorted = candidates.map(({ path }) => path).sort(compareEveStrings);
+		addEveDiagnostic(diagnostics, "EVE_TOOL_RUNTIME_NAME_COLLISION", sorted[0] ?? null, definition.agent.id, null, void 0, void 0, { conflictingPaths: sorted.join(",") });
+	}
+	for (const [capabilityId, tool] of Object.entries(definition.agent.declaration.tools ?? {})) {
+		const selected = selectTool(prepared, tool);
+		if (selected === null) {
+			const candidate = selectToolCandidate(definition.rootIndex.toolCandidates, tool);
+			if (candidate !== null && candidate.isSupportedSource && !candidate.isCollidedSlot && !candidate.isExtensionReserved) addEveSourceFailureDiagnostic(diagnostics, await session.analyzeSource(candidate.path), candidate.path, definition.agent.id, "tool", capabilityId);
+			continue;
+		}
+		const { candidate } = selected;
+		const invalidSegmentIndex = candidate.segments.findIndex((segment) => !EVE_TOOL_NAME_PATTERN.test(segment));
+		const isReserved = candidate.runtimeName === EVE_RESERVED_TOOL_NAME;
+		const canDiagnoseRegistration = invalidSegmentIndex < 0 && !isReserved && !collidedNames.has(candidate.runtimeName);
+		if (invalidSegmentIndex >= 0) addEveDiagnostic(diagnostics, "EVE_TOOL_NAME_INVALID", candidate.path, definition.agent.id, null, "tool", capabilityId, { segmentIndex: invalidSegmentIndex });
+		else if (isReserved) addEveDiagnostic(diagnostics, "EVE_TOOL_NAME_RESERVED", candidate.path, definition.agent.id, null, "tool", capabilityId);
+		let implementationKind = null;
+		if (tool.implementation.path === candidate.path && (tool.implementation.symbol === void 0 || tool.implementation.symbol === "default")) implementationKind = "inline";
+		else if (tool.implementation.symbol !== void 0) {
+			if (!addEveSourceFailureDiagnostic(diagnostics, await session.analyzeSource(tool.implementation.path), tool.implementation.path, definition.agent.id, "tool", capabilityId)) {
+				const execute = selected.definition.properties.get("execute");
+				const state = await classifyEveBoundExpression(session, selected.analysis, execute !== void 0 && ts.isPropertyAssignment(execute) ? execute.initializer : null, tool.implementation, true);
+				if (state === "missing") addEveDiagnostic(diagnostics, "EVE_TOOL_IMPLEMENTATION_SYMBOL_NOT_FOUND", tool.implementation.path, definition.agent.id, null, "tool", capabilityId);
+				else if (state === "wired") implementationKind = "bound-function";
+				else if (state === "different") addEveDiagnostic(diagnostics, "EVE_TOOL_IMPLEMENTATION_NOT_WIRED", candidate.path, definition.agent.id, null, "tool", capabilityId);
+			}
+		}
+		await inspectToolSchema(session, definition, selected, capabilityId, "input", tool, evidence, diagnostics);
+		await inspectToolSchema(session, definition, selected, capabilityId, "output", tool, evidence, diagnostics);
+		const registration = tool.registration;
+		let isRegistrationWired = registration === void 0;
+		let isRegistrationResolved = true;
+		if (registration !== void 0) {
+			if (registration.path === candidate.path && (registration.symbol === void 0 || registration.symbol === "default")) isRegistrationWired = true;
+			else if (registration.symbol === "default") {
+				const registrationResult = await session.analyzeSource(registration.path);
+				if (addEveSourceFailureDiagnostic(diagnostics, registrationResult, registration.path, definition.agent.id, "tool", capabilityId)) isRegistrationResolved = false;
+				const registrationDefinition = registrationResult.kind === "valid" ? getEveDefinition(registrationResult.analysis, "tool") : null;
+				if (registrationDefinition?.kind === "absent") {
+					if (canDiagnoseRegistration) addEveDiagnostic(diagnostics, "EVE_TOOL_REGISTRATION_SYMBOL_NOT_FOUND", registration.path, definition.agent.id, null, "tool", capabilityId);
+					isRegistrationResolved = false;
+				} else if (registrationDefinition?.kind === "present-supported") {
+					if (canDiagnoseRegistration) addEveDiagnostic(diagnostics, "EVE_TOOL_REGISTRATION_NOT_WIRED", selected.candidate.path, definition.agent.id, null, "tool", capabilityId);
+				} else isRegistrationResolved = false;
+			} else if (registration.symbol === void 0) {
+				if (canDiagnoseRegistration) addEveDiagnostic(diagnostics, "EVE_TOOL_REGISTRATION_NOT_WIRED", candidate.path, definition.agent.id, null, "tool", capabilityId);
+			}
+		}
+		if (!(selected.isRegistrationEligible && implementationKind !== null && isRegistrationWired && isRegistrationResolved && invalidSegmentIndex < 0 && !isReserved && !collidedNames.has(candidate.runtimeName))) continue;
+		if (tool.name !== candidate.runtimeName) {
+			addEveDiagnostic(diagnostics, "EVE_TOOL_NAME_MISMATCH", candidate.path, definition.agent.id, null, "tool", capabilityId);
+			continue;
+		}
+		const references = [{ path: candidate.path }, ...tool.implementation.path === candidate.path ? [] : [tool.implementation]];
+		evidence.push(createEveEvidence({
+			agentId: definition.agent.id,
+			capabilityId,
+			capabilityKind: "tool",
+			details: {
+				implementationKind,
+				pathDepth: candidate.segments.length,
+				registrationKind: "filesystem-tool"
+			},
+			kind: "tool-registration",
+			references,
+			runtimeName: candidate.runtimeName,
+			source: "eve"
+		}));
+	}
+	return new Set(prepared.filter(({ candidate, isRegistrationEligible }) => isRegistrationEligible && !collidedNames.has(candidate.runtimeName) && candidate.runtimeName !== "Workflow" && candidate.segments.every((segment) => EVE_TOOL_NAME_PATTERN.test(segment))).map(({ candidate }) => candidate.runtimeName));
+};
+//#endregion
+//#region src/inspection/inspection.ts
+/**
+* Inspects all scoped Eve agents through one deterministic read-only session.
+* @param context The Core-provided immutable adapter context.
+* @returns A promise resolving to source-grounded evidence and diagnostics.
+* @throws
+* - INVALID_REPOSITORY_PATH: The repository path is invalid.
+* - ENTRY_NOT_FOUND: The requested repository entry was not found.
+* - ENTRY_NOT_FILE: The requested repository entry is not a file.
+* - ENTRY_NOT_DIRECTORY: The requested repository entry is not a directory.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during the operation.
+* - INVALID_SOURCE_DATA: The repository source returned invalid data.
+* - RESOURCE_LIMIT_EXCEEDED: A repository reading resource limit was exceeded.
+* - ABORTED: The repository operation or inspection signal was aborted.
+*/
+var inspectEve = async (context) => {
+	context.signal?.throwIfAborted();
+	const session = createEveInspectionSession(context);
+	const evidence = [];
+	const diagnostics = [];
+	const definitions = [];
+	const agents = [...context.agents].sort((left, right) => compareEveStrings(left.id, right.id));
+	for (const agent of agents) {
+		context.signal?.throwIfAborted();
+		const definition = await inspectEveAgent(session, agent, evidence, diagnostics);
+		if (definition !== null) definitions.push(definition);
+	}
+	const preparedToolNames = /* @__PURE__ */ new Map();
+	for (const definition of definitions) {
+		context.signal?.throwIfAborted();
+		await inspectEveInstructions(session, definition, evidence, diagnostics);
+		preparedToolNames.set(definition.agent.id, await inspectEveTools(session, definition, evidence, diagnostics));
+		await inspectEveSkills(session, definition, evidence, diagnostics);
+	}
+	context.signal?.throwIfAborted();
+	inspectEveSubagents(definitions, preparedToolNames, evidence, diagnostics);
+	return Object.freeze({
+		diagnostics: Object.freeze(diagnostics),
+		evidence: Object.freeze(evidence)
+	});
+};
+//#endregion
+//#region src/adapter/index.ts
+var eveAdapter = Object.freeze({
+	id: "eve",
+	inspect: inspectEve,
+	supportedRepositoryFormatVersions: EVE_SUPPORTED_REPOSITORY_FORMAT_VERSIONS
+});
+//#endregion
+export { eveAdapter };