@moldea.ai/adapter-claude-agent-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,2435 @@
+import { posix } from "node:path";
+import { intersects, subset, validRange } from "semver";
+import ts from "typescript";
+import { parseRepositoryPath } from "@moldea.ai/repository";
+//#region src/constants/index.ts
+var CLAUDE_AGENT_SDK_ADAPTER_ID = "claude-agent-sdk";
+var CLAUDE_AGENT_SDK_PACKAGE_NAME = "@anthropic-ai/claude-agent-sdk";
+var CLAUDE_AGENT_SDK_SUPPORTED_RANGE = ">=0.3.234 <0.4.0";
+var CLAUDE_AGENT_SDK_SUPPORTED_REPOSITORY_FORMAT_VERSIONS = Object.freeze([1]);
+var CLAUDE_AGENT_SDK_MCP_SERVER_KEY_PATTERN = /^[A-Za-z0-9_-]+$/;
+//#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 { 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),
+				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;
+};
+/**
+* Resolves one direct call with an optional outer `await` wrapper.
+* @param expression The candidate call expression.
+* @returns The direct call or `null` when the form is unsupported.
+*/
+var getDirectCall = (expression) => {
+	const unwrapped = unwrapExpression(expression);
+	const candidate = ts.isAwaitExpression(unwrapped) ? unwrapExpression(unwrapped.expression) : unwrapped;
+	return ts.isCallExpression(candidate) ? candidate : null;
+};
+var getStaticPropertyName = (name) => {
+	if (ts.isIdentifier(name) || ts.isStringLiteral(name)) return name.text;
+	return null;
+};
+/**
+* Indexes a closed object literal with exact identifier or string-literal keys.
+* @param objectLiteral The candidate closed object.
+* @returns Exact property expressions or `null` for dynamic or duplicate members.
+*/
+var getClosedObjectProperties = (objectLiteral) => {
+	const properties = /* @__PURE__ */ new Map();
+	for (const property of objectLiteral.properties) {
+		if (!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property)) return null;
+		const propertyName = getStaticPropertyName(property.name);
+		if (propertyName === null || properties.has(propertyName)) return null;
+		properties.set(propertyName, unwrapExpression(ts.isPropertyAssignment(property) ? property.initializer : property.name));
+	}
+	return properties;
+};
+/**
+* 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] : [];
+};
+/**
+* Resolves the explicit module references an identifier can denote.
+* @param identifier The local source identifier.
+* @param analysis The source containing that identifier.
+* @returns Same-file or relative-import candidates in deterministic order.
+*/
+var resolveBindingReferences = (identifier, analysis) => {
+	if (!isModuleBindingVisible(identifier, analysis)) return [];
+	const references = [];
+	if (analysis.exports.has(identifier.text)) references.push(Object.freeze({
+		path: analysis.path,
+		symbol: identifier.text
+	}));
+	const namedImport = analysis.namedImports.get(identifier.text);
+	if (namedImport !== void 0) references.push(...resolveImportCandidatePaths(analysis.path, namedImport.moduleSpecifier).map((path) => Object.freeze({
+		path,
+		symbol: namedImport.importedName
+	})));
+	return references;
+};
+/**
+* Checks whether an identifier resolves directly to an explicit bound reference.
+* @param identifier The local source identifier.
+* @param analysis The source containing that identifier.
+* @param reference The explicit source binding to match.
+* @returns Whether local or named-import identity proves the relationship.
+*/
+var isBoundIdentifier = (identifier, analysis, reference) => {
+	if (reference.symbol === void 0) return false;
+	return resolveBindingReferences(identifier, analysis).some((candidate) => candidate.path === reference.path && candidate.symbol === reference.symbol);
+};
+var getDirectPropertyName$1 = (name) => {
+	if (ts.isIdentifier(name) || ts.isStringLiteral(name)) return name.text;
+	return null;
+};
+var getPotentialRelationshipNames = (name, relationshipNames) => {
+	const directName = getDirectPropertyName$1(name);
+	if (directName !== null) return relationshipNames.includes(directName) ? [directName] : [];
+	if (!ts.isComputedPropertyName(name)) return [];
+	const expression = unwrapExpression(name.expression);
+	if (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)) return relationshipNames.includes(expression.text) ? [expression.text] : [];
+	if (ts.isNumericLiteral(expression) || expression.kind === ts.SyntaxKind.TrueKeyword || expression.kind === ts.SyntaxKind.FalseKeyword || expression.kind === ts.SyntaxKind.NullKeyword) return [];
+	return relationshipNames;
+};
+/**
+* Classifies selected properties on one object literal without interpreting unrelated values.
+* @param object The object literal whose direct properties are inspected.
+* @param relationshipNames The exact properties owned by the caller.
+* @returns Independent closed, absent, or unresolved relationship observations.
+*/
+var analyzeObjectRelationships = (object, relationshipNames) => {
+	const states = new Map(relationshipNames.map((name) => [name, {
+		directPropertyCount: 0,
+		relationship: { kind: "absent" }
+	}]));
+	const markUnresolved = (names) => {
+		for (const name of names) {
+			const state = states.get(name);
+			if (state !== void 0) state.relationship = { kind: "unresolved" };
+		}
+	};
+	for (const property of object.properties) {
+		if (ts.isSpreadAssignment(property)) {
+			markUnresolved(relationshipNames);
+			continue;
+		}
+		const potentialNames = getPotentialRelationshipNames(property.name, relationshipNames);
+		const relationshipExpression = ts.isPropertyAssignment(property) ? property.initializer : ts.isShorthandPropertyAssignment(property) ? property.name : null;
+		if (relationshipExpression === null) {
+			markUnresolved(potentialNames);
+			continue;
+		}
+		const directName = getDirectPropertyName$1(property.name);
+		if (directName === null || !relationshipNames.includes(directName)) {
+			markUnresolved(potentialNames);
+			continue;
+		}
+		const state = states.get(directName);
+		if (state === void 0) continue;
+		state.directPropertyCount += 1;
+		state.relationship = state.directPropertyCount === 1 ? {
+			expression: unwrapExpression(relationshipExpression),
+			kind: "present"
+		} : { kind: "unresolved" };
+	}
+	return Object.freeze({
+		object,
+		relationships: new Map([...states].map(([name, state]) => [name, Object.freeze(state.relationship)]))
+	});
+};
+var READONLY_ARRAY_METHODS = /* @__PURE__ */ new Set([
+	"at",
+	"concat",
+	"entries",
+	"flat",
+	"includes",
+	"indexOf",
+	"join",
+	"keys",
+	"lastIndexOf",
+	"slice",
+	"toLocaleString",
+	"toReversed",
+	"toSpliced",
+	"toString",
+	"values",
+	"with"
+]);
+var skipTransparentParents$1 = (node) => {
+	let current = node;
+	while (ts.isAsExpression(current.parent) || ts.isParenthesizedExpression(current.parent) || ts.isSatisfiesExpression(current.parent)) current = current.parent;
+	return current;
+};
+var isAssignmentOperator$1 = (kind) => kind >= ts.SyntaxKind.FirstAssignment && kind <= ts.SyntaxKind.LastAssignment;
+var isAssignmentTarget = (expression) => {
+	let current = skipTransparentParents$1(expression);
+	while (true) {
+		const parent = current.parent;
+		if (ts.isBinaryExpression(parent) && isAssignmentOperator$1(parent.operatorToken.kind)) return parent.left === current;
+		if ((ts.isPrefixUnaryExpression(parent) || ts.isPostfixUnaryExpression(parent)) && parent.operand === current && (parent.operator === ts.SyntaxKind.PlusPlusToken || parent.operator === ts.SyntaxKind.MinusMinusToken)) return true;
+		if (ts.isDeleteExpression(parent) && parent.expression === current) return true;
+		if ((ts.isForInStatement(parent) || ts.isForOfStatement(parent)) && parent.initializer === current) return true;
+		if (ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent) || ts.isPropertyAssignment(parent) || ts.isSpreadAssignment(parent) || ts.isSpreadElement(parent) || ts.isArrayLiteralExpression(parent) || ts.isObjectLiteralExpression(parent)) {
+			current = skipTransparentParents$1(parent);
+			continue;
+		}
+		return false;
+	}
+};
+var getStaticMemberName$1 = (member) => {
+	if (ts.isPropertyAccessExpression(member)) return member.name.text;
+	const argument = member.argumentExpression;
+	return argument !== void 0 && (ts.isStringLiteral(argument) || ts.isNoSubstitutionTemplateLiteral(argument)) ? argument.text : null;
+};
+var isSafeArrayMemberUse = (member) => {
+	if (isAssignmentTarget(member)) return false;
+	const candidate = skipTransparentParents$1(member);
+	const parent = candidate.parent;
+	if (!ts.isCallExpression(parent) || parent.expression !== candidate) return ts.isPropertyAccessExpression(member) && member.name.text === "length";
+	const memberName = getStaticMemberName$1(member);
+	const call = skipTransparentParents$1(parent);
+	return memberName !== null && READONLY_ARRAY_METHODS.has(memberName) && ts.isExpressionStatement(call.parent);
+};
+var isIgnoredIdentifierPosition = (identifier, declarationName) => identifier === declarationName || ts.isImportSpecifier(identifier.parent) || ts.isPropertyAssignment(identifier.parent) && identifier.parent.name === identifier || ts.isPropertyAccessExpression(identifier.parent) && identifier.parent.name === identifier;
+/**
+* Determines whether a module value binding has only explicitly allowed value uses.
+* @param analysis The indexed source containing the binding references.
+* @param bindingName The exact lexically visible module binding name.
+* @param declarationName The optional local declaration identifier to exclude.
+* @param allowedReferences Exact bare identifier occurrences owned by supported relationships.
+* @param kind Whether array read-only member access is permitted for the value.
+* @returns Whether the binding cannot be aliased, escaped, reassigned, or mutated.
+*/
+var isModuleValueBindingSafe = (analysis, bindingName, declarationName, allowedReferences, kind) => {
+	const identifierUses = analysis.identifierUses.get(bindingName) ?? [];
+	for (const identifier of identifierUses) {
+		if (isIgnoredIdentifierPosition(identifier, declarationName) || !isModuleBindingVisible(identifier, analysis)) continue;
+		if (allowedReferences.has(identifier)) continue;
+		const expression = skipTransparentParents$1(identifier);
+		const parent = expression.parent;
+		const member = (ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent)) && parent.expression === expression ? parent : null;
+		if (kind !== "array" || member === null || !isSafeArrayMemberUse(member)) return false;
+	}
+	return true;
+};
+/**
+* Determines whether a module-local constant literal has only explicitly allowed value uses.
+* @param analysis The indexed source containing the declaration and its references.
+* @param declaration The module-local constant declaration to inspect.
+* @param allowedReferences Exact bare identifier occurrences owned by supported relationships.
+* @param kind Whether array read-only member access is permitted for the value.
+* @returns Whether the binding cannot be aliased, escaped, reassigned, or mutated.
+*/
+var isModuleConstValueSafe = (analysis, declaration, allowedReferences, kind) => {
+	if (!ts.isIdentifier(declaration.name)) return false;
+	return isModuleValueBindingSafe(analysis, declaration.name.text, declaration.name, allowedReferences, kind);
+};
+function getSafeModuleConstLiteral(expression, analysis, allowedReferences, kind) {
+	const candidate = unwrapExpression(expression);
+	if (!ts.isIdentifier(candidate) || !isModuleBindingVisible(candidate, analysis)) return null;
+	const declaration = analysis.moduleConstDeclarations.get(candidate.text);
+	const initializer = declaration?.initializer === void 0 ? null : unwrapExpression(declaration.initializer);
+	const isExpectedLiteral = initializer !== null && (kind === "array" ? ts.isArrayLiteralExpression(initializer) : ts.isObjectLiteralExpression(initializer));
+	if (declaration === void 0 || !isExpectedLiteral || !isModuleConstValueSafe(analysis, declaration, allowedReferences, kind)) return null;
+	return Object.freeze({
+		declaration,
+		expression: initializer
+	});
+}
+var skipTransparentParents = (node) => {
+	let current = node;
+	while (ts.isAsExpression(current.parent) || ts.isParenthesizedExpression(current.parent) || ts.isSatisfiesExpression(current.parent)) current = current.parent;
+	return current;
+};
+var isAssignmentOperator = (kind) => kind >= ts.SyntaxKind.FirstAssignment && kind <= ts.SyntaxKind.LastAssignment;
+var isMutatingTarget = (expression) => {
+	const candidate = skipTransparentParents(expression);
+	const parent = candidate.parent;
+	return ts.isBinaryExpression(parent) && parent.left === candidate && isAssignmentOperator(parent.operatorToken.kind) || (ts.isPrefixUnaryExpression(parent) || ts.isPostfixUnaryExpression(parent)) && parent.operand === candidate && (parent.operator === ts.SyntaxKind.PlusPlusToken || parent.operator === ts.SyntaxKind.MinusMinusToken) || ts.isDeleteExpression(parent) && parent.expression === candidate || (ts.isForInStatement(parent) || ts.isForOfStatement(parent)) && parent.initializer === candidate;
+};
+var getStaticMemberName = (member) => {
+	if (ts.isPropertyAccessExpression(member)) return member.name.text;
+	const argument = member.argumentExpression;
+	return argument !== void 0 && (ts.isStringLiteral(argument) || ts.isNoSubstitutionTemplateLiteral(argument)) ? argument.text : null;
+};
+var isIgnoredIdentifier = (identifier, declarationName) => identifier === declarationName || ts.isImportSpecifier(identifier.parent) || ts.isPropertyAccessExpression(identifier.parent) && identifier.parent.name === identifier || ts.isPropertyAssignment(identifier.parent) && identifier.parent.name === identifier;
+var addObjectAssignmentMembers = (object, mutatedMembers) => {
+	let hasUnknownMutation = false;
+	for (const property of object.properties) {
+		if (!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property) || ts.isComputedPropertyName(property.name)) {
+			hasUnknownMutation = true;
+			continue;
+		}
+		const propertyName = ts.isIdentifier(property.name) || ts.isStringLiteral(property.name) ? property.name.text : null;
+		if (propertyName === null) hasUnknownMutation = true;
+		else mutatedMembers.add(propertyName);
+	}
+	return hasUnknownMutation;
+};
+var analyzeMutationCall = (identifier, mutatedMembers) => {
+	const candidate = skipTransparentParents(identifier);
+	const parent = candidate.parent;
+	if (!ts.isCallExpression(parent)) return null;
+	const callee = unwrapExpression(parent.expression);
+	if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression) && callee.expression.text === "Object" && callee.name.text === "assign" && parent.arguments[0] === candidate) {
+		let hasUnknownMutation = parent.arguments.length < 2;
+		for (const source of parent.arguments.slice(1)) {
+			const assignmentSource = unwrapExpression(source);
+			if (!ts.isObjectLiteralExpression(assignmentSource)) hasUnknownMutation = true;
+			else if (addObjectAssignmentMembers(assignmentSource, mutatedMembers)) hasUnknownMutation = true;
+		}
+		return hasUnknownMutation;
+	}
+	if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression) && callee.expression.text === "Reflect" && callee.name.text === "set" && parent.arguments[0] === candidate) {
+		const member = parent.arguments[1];
+		if (member !== void 0 && (ts.isStringLiteral(member) || ts.isNoSubstitutionTemplateLiteral(member))) {
+			mutatedMembers.add(member.text);
+			return false;
+		}
+		return true;
+	}
+	return true;
+};
+/**
+* Classifies module-local mutations and escapes for one returned object value.
+* @param analysis The indexed source containing the binding.
+* @param declaration The module-local constant declaration.
+* @param allowedReferences Bare identifier uses proven to be supported registrations or targets.
+* @returns Member-specific mutations and whether an unknown use can affect every relationship.
+*/
+var analyzeModuleValueMutations = (analysis, declaration, allowedReferences) => {
+	if (!ts.isIdentifier(declaration.name)) return Object.freeze({
+		hasUnknownMutation: true,
+		mutatedMembers: /* @__PURE__ */ new Set()
+	});
+	const mutatedMembers = /* @__PURE__ */ new Set();
+	let hasUnknownMutation = false;
+	for (const identifier of analysis.identifierUses.get(declaration.name.text) ?? []) {
+		if (isIgnoredIdentifier(identifier, declaration.name) || !isModuleBindingVisible(identifier, analysis) || allowedReferences.has(identifier)) continue;
+		const expression = skipTransparentParents(identifier);
+		const parent = expression.parent;
+		const member = (ts.isPropertyAccessExpression(parent) || ts.isElementAccessExpression(parent)) && parent.expression === expression ? parent : null;
+		if (member !== null) {
+			const memberName = getStaticMemberName(member);
+			if (memberName === null) hasUnknownMutation = true;
+			else if (isMutatingTarget(member)) mutatedMembers.add(memberName);
+			else {
+				const memberExpression = skipTransparentParents(member);
+				const memberParent = memberExpression.parent;
+				if ((ts.isPropertyAccessExpression(memberParent) || ts.isElementAccessExpression(memberParent)) && memberParent.expression === memberExpression && ts.isCallExpression(skipTransparentParents(memberParent).parent)) mutatedMembers.add(memberName);
+				else if (ts.isCallExpression(memberParent) && memberParent.expression === memberExpression) mutatedMembers.add(memberName);
+			}
+			continue;
+		}
+		if (isMutatingTarget(identifier)) {
+			hasUnknownMutation = true;
+			continue;
+		}
+		const mutationCall = analyzeMutationCall(identifier, mutatedMembers);
+		hasUnknownMutation ||= mutationCall ?? true;
+	}
+	return Object.freeze({
+		hasUnknownMutation,
+		mutatedMembers: new Set(mutatedMembers)
+	});
+};
+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"
+	});
+};
+/**
+* Determines whether a path uses a supported TypeScript source extension.
+* @param path The bound source path.
+* @returns Whether its extension is supported.
+*/
+var isSupportedTypeScriptSourcePath = (path) => [
+	".ts",
+	".tsx",
+	".mts"
+].some((extension) => path.endsWith(extension));
+/**
+* Classifies a direct exported runtime-agent function and exposes its body.
+* @param analysis The indexed runtime source.
+* @param symbol The bound runtime-agent symbol.
+* @returns The symbol state and supported body when available.
+*/
+var getRuntimeExport = (analysis, symbol) => {
+	const exported = analysis.exports.get(symbol);
+	if (exported === void 0) return Object.freeze({ kind: "absent" });
+	if (exported.kind === "present-unsupported") return exported;
+	const { declaration } = exported;
+	if (ts.isFunctionDeclaration(declaration) && declaration.body !== void 0) return Object.freeze({
+		body: declaration.body,
+		declaration,
+		kind: "present-supported"
+	});
+	if (ts.isVariableDeclaration(declaration) && declaration.initializer !== void 0) {
+		const initializer = unwrapExpression(declaration.initializer);
+		if (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) return Object.freeze({
+			body: initializer.body,
+			declaration,
+			kind: "present-supported"
+		});
+	}
+	return Object.freeze({
+		declaration,
+		kind: "present-unsupported"
+	});
+};
+/**
+* Classifies a directly exported callable value such as an instruction loader.
+* @param analysis The indexed source.
+* @param symbol The exact bound symbol.
+* @returns The symbol state for conservative call matching.
+*/
+var getCallableExportState = (analysis, symbol) => {
+	const runtimeExport = getRuntimeExport(analysis, symbol);
+	return runtimeExport.kind === "present-supported" ? Object.freeze({
+		declaration: runtimeExport.declaration,
+		kind: "present-supported"
+	}) : runtimeExport;
+};
+/**
+* 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/collections.ts
+/**
+* Resolves a closed inline or immutable module-local array relationship.
+* @param relationship The relationship containing the array.
+* @param analysis The source containing the relationship.
+* @param allowedReferences Direct supported uses of the module array.
+* @returns Exact elements, `null` when unresolved, or an empty array when absent.
+*/
+var getClaudeAgentSdkClosedArray = (relationship, analysis, allowedReferences) => {
+	if (relationship.kind === "absent") return [];
+	if (relationship.kind !== "present") return null;
+	const candidate = unwrapExpression(relationship.expression);
+	const moduleArray = ts.isArrayLiteralExpression(candidate) ? null : getSafeModuleConstLiteral(candidate, analysis, allowedReferences, "array");
+	const array = ts.isArrayLiteralExpression(candidate) ? candidate : moduleArray?.expression;
+	if (array === void 0 || array.elements.some((element) => ts.isOmittedExpression(element) || ts.isSpreadElement(element))) return null;
+	return Object.freeze(array.elements.map((element) => unwrapExpression(element)));
+};
+/**
+* Resolves a closed inline or immutable module-local object relationship.
+* @param relationship The relationship containing the map.
+* @param analysis The source containing the relationship.
+* @param allowedReferences Direct supported uses of the module object.
+* @returns Static direct entries, `null` when unresolved, or an empty array when absent.
+*/
+var getClaudeAgentSdkClosedMapEntries = (relationship, analysis, allowedReferences) => {
+	if (relationship.kind === "absent") return [];
+	if (relationship.kind !== "present") return null;
+	const candidate = unwrapExpression(relationship.expression);
+	const moduleObject = ts.isObjectLiteralExpression(candidate) ? null : getSafeModuleConstLiteral(candidate, analysis, allowedReferences, "object");
+	const object = ts.isObjectLiteralExpression(candidate) ? candidate : moduleObject?.expression;
+	if (object === void 0) return null;
+	const entries = [];
+	const names = /* @__PURE__ */ new Set();
+	for (const property of object.properties) {
+		if (!ts.isPropertyAssignment(property)) return null;
+		const name = ts.isIdentifier(property.name) || ts.isStringLiteral(property.name) ? property.name.text : ts.isComputedPropertyName(property.name) ? null : void 0;
+		if (name === void 0 || name !== null && names.has(name)) return null;
+		if (name !== null) names.add(name);
+		entries.push(Object.freeze({
+			keyExpression: ts.isComputedPropertyName(property.name) ? property.name.expression : property.name,
+			name,
+			value: unwrapExpression(property.initializer)
+		}));
+	}
+	return Object.freeze(entries);
+};
+//#endregion
+//#region src/source-analysis/mutations.ts
+/**
+* Classifies module-local mutations and escapes for one returned SDK object.
+* @param analysis The indexed source containing the binding.
+* @param declaration The module-local constant declaration.
+* @param allowedReferences Bare identifier uses proven to be supported registrations or targets.
+* @returns Member-specific mutations and whether an unknown use can affect every relationship.
+*/
+var analyzeClaudeAgentSdkMutations = (analysis, declaration, allowedReferences) => analyzeModuleValueMutations(analysis, declaration, allowedReferences);
+//#endregion
+//#region src/source-analysis/query-wrappers.ts
+var OPTION_RELATIONSHIP_NAMES = [
+	"agent",
+	"agents",
+	"disallowedTools",
+	"mcpServers",
+	"outputFormat",
+	"systemPrompt",
+	"toolAliases",
+	"tools"
+];
+var createRelationships = (relationship) => new Map(OPTION_RELATIONSHIP_NAMES.map((name) => [name, relationship]));
+var getQueryContext = (call) => {
+	if (call.arguments.length !== 1) return null;
+	const input = unwrapExpression(call.arguments[0]);
+	if (!ts.isObjectLiteralExpression(input)) return null;
+	const optionsRelationship = analyzeObjectRelationships(input, ["options"]).relationships.get("options");
+	let relationships;
+	if (optionsRelationship?.kind === "absent") relationships = createRelationships({ kind: "absent" });
+	else if (optionsRelationship?.kind !== "present") relationships = createRelationships({ kind: "unresolved" });
+	else {
+		const options = unwrapExpression(optionsRelationship.expression);
+		relationships = ts.isObjectLiteralExpression(options) ? analyzeObjectRelationships(options, OPTION_RELATIONSHIP_NAMES).relationships : createRelationships({ kind: "unresolved" });
+	}
+	const relationship = (name) => relationships.get(name) ?? { kind: "unresolved" };
+	return Object.freeze({
+		agents: relationship("agents"),
+		agentSelection: relationship("agent"),
+		call,
+		disallowedTools: relationship("disallowedTools"),
+		mcpServers: relationship("mcpServers"),
+		outputFormat: relationship("outputFormat"),
+		systemPrompt: relationship("systemPrompt"),
+		toolAliases: relationship("toolAliases"),
+		tools: relationship("tools")
+	});
+};
+var isNestedBoundary = (node) => ts.isFunctionLike(node) || ts.isClassLike(node) || ts.isClassStaticBlockDeclaration(node);
+/**
+* Classifies one directly exported query wrapper and its complete direct-call set.
+* @param analysis The indexed runtime source.
+* @param symbol The exact bound runtime-agent symbol.
+* @returns The absent, unsupported, or supported query-wrapper state.
+*/
+var getClaudeAgentSdkQueryWrapper = (analysis, symbol) => {
+	const runtimeExport = getRuntimeExport(analysis, symbol);
+	if (runtimeExport.kind === "absent") return Object.freeze({ kind: "absent" });
+	if (runtimeExport.kind !== "present-supported" || runtimeExport.body === void 0) return Object.freeze({
+		declaration: runtimeExport.declaration,
+		kind: "present-unsupported"
+	});
+	const contexts = [];
+	let hasAmbiguousCandidate = false;
+	const visit = (node, isNested) => {
+		if (ts.isCallExpression(node)) {
+			const callee = unwrapExpression(node.expression);
+			if (ts.isIdentifier(callee) && analysis.imports.queryNames.has(callee.text) && isModuleBindingVisible(callee, analysis)) {
+				if (isNested || node.questionDotToken !== void 0) hasAmbiguousCandidate = true;
+				else {
+					const context = getQueryContext(node);
+					if (context === null) hasAmbiguousCandidate = true;
+					else contexts.push(context);
+				}
+			}
+		}
+		const childIsNested = isNested || node !== runtimeExport.body && isNestedBoundary(node);
+		node.forEachChild((child) => visit(child, childIsNested));
+	};
+	visit(runtimeExport.body, false);
+	if (contexts.length === 0) return Object.freeze({
+		declaration: runtimeExport.declaration,
+		kind: "present-unsupported"
+	});
+	return Object.freeze({
+		kind: "present-supported",
+		wrapper: Object.freeze({
+			contexts: Object.freeze(contexts),
+			declaration: runtimeExport.declaration,
+			hasAmbiguousCandidate
+		})
+	});
+};
+//#endregion
+//#region src/source-analysis/tool-availability.ts
+var hasUnsupportedGlobSyntax = (pattern) => /[?[\]{}\\]/u.test(pattern);
+var isScopedPermission = (value) => /^[^()]+\(.*\)$/u.test(value);
+/**
+* Matches a complete runtime tool name against the supported bare `*` glob model.
+* @param pattern The exact compiler-parsed deny pattern.
+* @param runtimeName The complete runtime-visible tool name.
+* @returns Whether the complete name matches.
+*/
+var matchesClaudeAgentSdkBarePattern = (pattern, runtimeName) => {
+	const patternScalars = Array.from(pattern);
+	const nameScalars = Array.from(runtimeName);
+	let patternIndex = 0;
+	let nameIndex = 0;
+	let wildcardIndex = -1;
+	let wildcardNameIndex = -1;
+	while (nameIndex < nameScalars.length) if (patternIndex < patternScalars.length && patternScalars[patternIndex] !== "*" && patternScalars[patternIndex] === nameScalars[nameIndex]) {
+		patternIndex += 1;
+		nameIndex += 1;
+	} else if (patternScalars[patternIndex] === "*") {
+		wildcardIndex = patternIndex;
+		wildcardNameIndex = nameIndex;
+		patternIndex += 1;
+	} else if (wildcardIndex >= 0) {
+		patternIndex = wildcardIndex + 1;
+		wildcardNameIndex += 1;
+		nameIndex = wildcardNameIndex;
+	} else return false;
+	while (patternScalars[patternIndex] === "*") patternIndex += 1;
+	return patternIndex === patternScalars.length;
+};
+var resolveList = async (relationship, analysis, allowedReferences, resolveStaticString) => {
+	const elements = getClaudeAgentSdkClosedArray(relationship, analysis, allowedReferences);
+	if (elements === null) return null;
+	const names = [];
+	for (const element of elements) {
+		const result = await resolveStaticString(analysis, element);
+		if (result.kind !== "supported") return null;
+		names.push(result.value);
+	}
+	return Object.freeze(names);
+};
+var applyDenyList = async (current, relationship, analysis, allowedReferences, runtimeName, resolveStaticString, legacyRuntimeName, serverSelector) => {
+	if (relationship.kind === "absent") return current;
+	const entries = await resolveList(relationship, analysis, allowedReferences, resolveStaticString);
+	if (entries === null) return current === "unavailable" ? current : "unresolved";
+	let hasUnresolvedEntry = false;
+	for (const entry of entries) {
+		if (serverSelector !== void 0 && entry === serverSelector) return "unavailable";
+		if (!hasUnsupportedGlobSyntax(entry) && !isScopedPermission(entry)) {
+			if (matchesClaudeAgentSdkBarePattern(entry, runtimeName)) return "unavailable";
+			if (legacyRuntimeName !== void 0 && matchesClaudeAgentSdkBarePattern(entry, legacyRuntimeName)) hasUnresolvedEntry = true;
+			continue;
+		}
+		if (entry.startsWith(runtimeName) || legacyRuntimeName !== void 0 && entry.startsWith(legacyRuntimeName) || entry.includes("*")) hasUnresolvedEntry = true;
+	}
+	return current === "unavailable" ? current : hasUnresolvedEntry ? "unresolved" : current;
+};
+/**
+* Derives query-configured availability of the built-in Agent delegation tool.
+* @param analysis The query source analysis.
+* @param tools The query-level tools relationship.
+* @param disallowedTools The query-level deny relationship.
+* @param agentSelection The unsupported main-thread selection relationship.
+* @param toolAliases The unsupported tool-alias relationship.
+* @param allowedReferences Supported references to shared list constants.
+* @param resolveStaticString The operation-local exact string resolver.
+* @returns The relationship-local availability state.
+*/
+var classifyClaudeAgentSdkAgentAvailability = async (analysis, tools, disallowedTools, agentSelection, toolAliases, allowedReferences, resolveStaticString) => {
+	let availability;
+	if (tools.kind === "absent") availability = "available";
+	else {
+		const entries = await resolveList(tools, analysis, allowedReferences, resolveStaticString);
+		if (entries === null) availability = "unresolved";
+		else if (entries.includes("Agent")) availability = "available";
+		else if (entries.some((entry) => entry === "Task" || entry.includes("*") || entry.startsWith("Agent(") || entry.startsWith("Task("))) availability = "unresolved";
+		else availability = "unavailable";
+	}
+	availability = await applyDenyList(availability, disallowedTools, analysis, allowedReferences, "Agent", resolveStaticString, "Task");
+	return availability === "available" && (agentSelection.kind !== "absent" || toolAliases.kind !== "absent") ? "unresolved" : availability;
+};
+/**
+* Derives query- or subagent-level availability of one exact SDK MCP tool.
+* @param analysis The source containing the availability relationships.
+* @param current The inherited availability state.
+* @param tools The optional explicit allow-list relationship.
+* @param disallowedTools The deny relationship.
+* @param agentSelection The unsupported main-thread selection relationship when query-level.
+* @param toolAliases The unsupported alias relationship when query-level.
+* @param allowedReferences Supported references to shared list constants.
+* @param runtimeName The exact fully qualified runtime tool name.
+* @param serverKey The canonical query-level server key.
+* @param resolveStaticString The operation-local exact string resolver.
+* @returns The refined availability state.
+*/
+var classifyClaudeAgentSdkMcpToolAvailability = async (analysis, current, tools, disallowedTools, agentSelection, toolAliases, allowedReferences, runtimeName, serverKey, resolveStaticString) => {
+	let availability = current;
+	if (availability !== "unavailable" && tools !== null && tools.kind !== "absent") {
+		const entries = await resolveList(tools, analysis, allowedReferences, resolveStaticString);
+		if (entries === null || entries.some((entry) => entry.includes("*") || isScopedPermission(entry))) availability = "unresolved";
+		else availability = entries.includes(runtimeName) ? availability : "unavailable";
+	}
+	availability = await applyDenyList(availability, disallowedTools, analysis, allowedReferences, runtimeName, resolveStaticString, void 0, `mcp__${serverKey}`);
+	return availability === "available" && (agentSelection !== null && agentSelection.kind !== "absent" || toolAliases !== null && toolAliases.kind !== "absent") ? "unresolved" : availability;
+};
+/** Collects direct identifier relationships allowed to share immutable module collections. */
+var collectClaudeAgentSdkRelationshipIdentifiers = (relationships) => new Set(relationships.flatMap((relationship) => {
+	if (relationship.kind !== "present") return [];
+	const candidate = unwrapExpression(relationship.expression);
+	return ts.isIdentifier(candidate) ? [candidate] : [];
+}));
+//#endregion
+//#region src/source-analysis/agent-definitions.ts
+var RELATIONSHIP_NAMES = [
+	"description",
+	"disallowedTools",
+	"mcpServers",
+	"prompt",
+	"tools"
+];
+var KNOWN_PROPERTIES = /* @__PURE__ */ new Set([
+	...RELATIONSHIP_NAMES,
+	"background",
+	"criticalSystemReminder_EXPERIMENTAL",
+	"effort",
+	"initialPrompt",
+	"maxTurns",
+	"memory",
+	"model",
+	"observer",
+	"observerMessage",
+	"permissionMode",
+	"skills"
+]);
+/**
+* Collects every supported direct agents-map use of definitions in one source module.
+* @param analysis The definition source analysis.
+* @returns Identifier occurrences that are registrations rather than mutable escapes.
+*/
+var collectClaudeAgentSdkAgentDefinitionReferences = (analysis) => {
+	const agentRelationships = [...analysis.exports.keys()].flatMap((symbol) => {
+		const result = getClaudeAgentSdkQueryWrapper(analysis, symbol);
+		return result.kind === "present-supported" ? result.wrapper.contexts.map(({ agents }) => agents) : [];
+	});
+	const collectionReferences = collectClaudeAgentSdkRelationshipIdentifiers(agentRelationships);
+	return new Set(agentRelationships.flatMap((relationship) => (getClaudeAgentSdkClosedMapEntries(relationship, analysis, collectionReferences) ?? []).map(({ value }) => unwrapExpression(value)).filter((value) => ts.isIdentifier(value))));
+};
+var getDirectPropertyName = (property) => "name" in property && property.name !== void 0 && (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) ? property.name.text : null;
+var hasUnknownProperty$1 = (config) => config.properties.some((property) => {
+	if (ts.isSpreadAssignment(property)) return false;
+	const name = getDirectPropertyName(property);
+	return name !== null && !KNOWN_PROPERTIES.has(name);
+});
+/**
+* Classifies one directly exported immutable AgentDefinition object.
+* @param analysis The indexed source module.
+* @param symbol The exact exported definition symbol.
+* @returns The absent, unsupported, or supported definition state.
+*/
+var getClaudeAgentSdkAgentDefinition = (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,
+		kind: "present-unsupported"
+	});
+	const config = unwrapExpression(exported.declaration.initializer);
+	if (!ts.isObjectLiteralExpression(config) || hasUnknownProperty$1(config)) return Object.freeze({
+		declaration: exported.declaration,
+		kind: "present-unsupported"
+	});
+	const observation = analyzeObjectRelationships(config, RELATIONSHIP_NAMES);
+	const relationship = (name) => observation.relationships.get(name) ?? { kind: "unresolved" };
+	const definition = Object.freeze({
+		config,
+		declaration: exported.declaration,
+		description: relationship("description"),
+		disallowedTools: relationship("disallowedTools"),
+		mcpServers: relationship("mcpServers"),
+		prompt: relationship("prompt"),
+		tools: relationship("tools")
+	});
+	return Object.freeze({
+		definition,
+		kind: "present-supported"
+	});
+};
+/**
+* Applies relationship-specific post-declaration mutation uncertainty.
+* @param analysis The definition source analysis.
+* @param definition The supported initial definition.
+* @param allowedReferences Direct uses in supported agents maps.
+* @returns The definition with only affected relationships unresolved.
+*/
+var applyClaudeAgentSdkAgentMutations = (analysis, definition, allowedReferences) => {
+	const mutations = analyzeClaudeAgentSdkMutations(analysis, definition.declaration, allowedReferences);
+	if (!mutations.hasUnknownMutation && mutations.mutatedMembers.size === 0) return definition;
+	const relationship = (name) => mutations.hasUnknownMutation || mutations.mutatedMembers.has(name) ? { kind: "unresolved" } : definition[name];
+	return Object.freeze({
+		...definition,
+		description: relationship("description"),
+		disallowedTools: relationship("disallowedTools"),
+		mcpServers: relationship("mcpServers"),
+		prompt: relationship("prompt"),
+		tools: relationship("tools")
+	});
+};
+//#endregion
+//#region src/source-analysis/bindings.ts
+/**
+* Classifies a direct relationship to one explicitly bound runtime symbol.
+* @param relationship The supported configuration relationship.
+* @param analysis The source containing the relationship.
+* @param reference The exact manifest binding.
+* @returns `true` for a match, `false` for proved absence, or `null` when unresolved.
+*/
+var classifyClaudeAgentSdkDirectBinding = (relationship, analysis, reference) => {
+	if (relationship.kind === "absent") return false;
+	if (relationship.kind === "unresolved" || reference.symbol === void 0) return null;
+	const candidate = unwrapExpression(relationship.expression);
+	if (!ts.isIdentifier(candidate) || !isModuleBindingVisible(candidate, analysis)) return ts.isStringLiteral(candidate) || ts.isNoSubstitutionTemplateLiteral(candidate) || ts.isNumericLiteral(candidate) || ts.isObjectLiteralExpression(candidate) || ts.isArrayLiteralExpression(candidate) || ts.isArrowFunction(candidate) || ts.isFunctionExpression(candidate) || ts.isClassExpression(candidate) || candidate.kind === ts.SyntaxKind.NullKeyword || candidate.kind === ts.SyntaxKind.TrueKeyword || candidate.kind === ts.SyntaxKind.FalseKeyword ? false : null;
+	if (isBoundIdentifier(candidate, analysis, reference)) return true;
+	return resolveBindingReferences(candidate, analysis).length > 0 ? false : null;
+};
+//#endregion
+//#region src/source-analysis/instruction-loaders.ts
+var classifyCall = (expression, analysis, reference) => {
+	const call = getDirectCall(expression);
+	if (call === null) return null;
+	const callee = unwrapExpression(call.expression);
+	if (!ts.isIdentifier(callee) || !isModuleBindingVisible(callee, analysis)) return null;
+	if (isBoundIdentifier(callee, analysis, reference)) return true;
+	return resolveBindingReferences(callee, analysis).length > 0 ? false : null;
+};
+var classifyPreset = (expression, analysis, reference) => {
+	const candidate = unwrapExpression(expression);
+	if (!ts.isObjectLiteralExpression(candidate)) return null;
+	const properties = getClosedObjectProperties(candidate);
+	if (properties === null || [...properties.keys()].some((name) => ![
+		"append",
+		"excludeDynamicSections",
+		"preset",
+		"type"
+	].includes(name)) || getStaticString(properties.get("type") ?? candidate) !== "preset" || getStaticString(properties.get("preset") ?? candidate) !== "claude_code") return null;
+	const append = properties.get("append");
+	return append === void 0 ? false : classifyCall(append, analysis, reference);
+};
+/**
+* Classifies a direct loader call used by a canonical Claude prompt relationship.
+* @param relationship The systemPrompt or AgentDefinition.prompt relationship.
+* @param analysis The source containing the relationship.
+* @param reference The exact declared instruction-loader binding.
+* @param supportsPreset Whether the query-level claude_code preset is allowed.
+* @returns `true` for wired, `false` for provably unwired, or `null` when unresolved.
+*/
+var classifyClaudeAgentSdkInstructionLoader = (relationship, analysis, reference, supportsPreset) => {
+	if (relationship.kind === "absent") return false;
+	if (relationship.kind === "unresolved" || reference.symbol === void 0) return null;
+	const candidate = unwrapExpression(relationship.expression);
+	if (ts.isArrayLiteralExpression(candidate)) return null;
+	const directCall = classifyCall(candidate, analysis, reference);
+	if (directCall !== null) return directCall;
+	if (supportsPreset) {
+		const preset = classifyPreset(candidate, analysis, reference);
+		if (preset !== null) return preset;
+	}
+	return ts.isStringLiteral(candidate) || ts.isNoSubstitutionTemplateLiteral(candidate) || ts.isNumericLiteral(candidate) || candidate.kind === ts.SyntaxKind.NullKeyword || candidate.kind === ts.SyntaxKind.TrueKeyword || candidate.kind === ts.SyntaxKind.FalseKeyword ? false : null;
+};
+//#endregion
+//#region src/source-analysis/mcp-servers.ts
+var SUPPORTED_PROPERTIES = /* @__PURE__ */ new Set([
+	"alwaysLoad",
+	"instructions",
+	"name",
+	"tools",
+	"version"
+]);
+var hasUnknownProperty = (config) => {
+	const properties = getClosedObjectProperties(config);
+	return properties === null || [...properties.keys()].some((name) => !SUPPORTED_PROPERTIES.has(name));
+};
+/**
+* Classifies one module-local createSdkMcpServer(...) declaration.
+* @param analysis The indexed server source.
+* @param symbol The exact module-local binding name.
+* @returns The supported server definition or `null`.
+*/
+var getClaudeAgentSdkMcpServerDefinition = (analysis, symbol) => {
+	const declaration = analysis.moduleConstDeclarations.get(symbol);
+	if (declaration?.initializer === void 0) return null;
+	const initializer = unwrapExpression(declaration.initializer);
+	if (!ts.isCallExpression(initializer) || initializer.arguments.length !== 1) return null;
+	const helper = unwrapExpression(initializer.expression);
+	if (!ts.isIdentifier(helper) || !analysis.imports.createSdkMcpServerNames.has(helper.text) || !isModuleBindingVisible(helper, analysis)) return null;
+	const config = unwrapExpression(initializer.arguments[0]);
+	if (!ts.isObjectLiteralExpression(config) || hasUnknownProperty(config)) return null;
+	const observation = analyzeObjectRelationships(config, [
+		"name",
+		"tools",
+		"version"
+	]);
+	const name = observation.relationships.get("name");
+	const tools = observation.relationships.get("tools") ?? { kind: "unresolved" };
+	const version = observation.relationships.get("version") ?? { kind: "unresolved" };
+	if (name?.kind !== "present" || tools.kind === "absent") return null;
+	return Object.freeze({
+		config,
+		declaration,
+		name: name.expression,
+		tools,
+		version
+	});
+};
+/**
+* Collects direct tool identifiers used by supported module-local SDK MCP servers.
+* @param analysis The source containing tool and server declarations.
+* @returns Identifier occurrences that are registrations rather than value escapes.
+*/
+var collectClaudeAgentSdkMcpToolReferences = (analysis) => {
+	const definitions = [...analysis.moduleConstDeclarations.keys()].flatMap((symbol) => {
+		const definition = getClaudeAgentSdkMcpServerDefinition(analysis, symbol);
+		return definition === null ? [] : [definition];
+	});
+	const collectionReferences = new Set(definitions.flatMap(({ tools }) => {
+		if (tools.kind !== "present") return [];
+		const candidate = unwrapExpression(tools.expression);
+		return ts.isIdentifier(candidate) ? [candidate] : [];
+	}));
+	return new Set(definitions.flatMap(({ tools }) => (getClaudeAgentSdkClosedArray(tools, analysis, collectionReferences) ?? []).filter((element) => ts.isIdentifier(element))));
+};
+//#endregion
+//#region src/source-analysis/sdk-tools.ts
+/**
+* Classifies one directly exported root tool(...) declaration.
+* @param analysis The indexed tool source.
+* @param symbol The exact exported tool registration symbol.
+* @returns The absent, unsupported, or structurally supported tool state.
+*/
+var getClaudeAgentSdkToolDefinition = (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,
+		kind: "present-unsupported"
+	});
+	const initializer = unwrapExpression(exported.declaration.initializer);
+	if (!ts.isCallExpression(initializer) || initializer.arguments.length !== 4 && initializer.arguments.length !== 5) return Object.freeze({
+		declaration: exported.declaration,
+		kind: "present-unsupported"
+	});
+	const helper = unwrapExpression(initializer.expression);
+	if (!ts.isIdentifier(helper) || !analysis.imports.toolNames.has(helper.text) || !isModuleBindingVisible(helper, analysis)) return Object.freeze({
+		declaration: exported.declaration,
+		kind: "present-unsupported"
+	});
+	const tool = Object.freeze({
+		call: initializer,
+		declaration: exported.declaration,
+		implementation: unwrapExpression(initializer.arguments[3]),
+		inputSchema: unwrapExpression(initializer.arguments[2]),
+		name: unwrapExpression(initializer.arguments[0])
+	});
+	return Object.freeze({
+		kind: "present-supported",
+		tool
+	});
+};
+//#endregion
+//#region src/source-analysis/source-analysis.ts
+var CLAUDE_AGENT_SDK_IMPORT_CONFIG = Object.freeze({
+	namedConstructorImports: [],
+	packageName: CLAUDE_AGENT_SDK_PACKAGE_NAME,
+	supportsDefaultConstructorImport: false
+});
+var indexClaudeAgentSdkImports = (sourceFile) => {
+	const createSdkMcpServerNames = /* @__PURE__ */ new Set();
+	const queryNames = /* @__PURE__ */ new Set();
+	const toolNames = /* @__PURE__ */ new Set();
+	for (const statement of sourceFile.statements) {
+		if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || statement.moduleSpecifier.text !== "@anthropic-ai/claude-agent-sdk" || statement.importClause?.isTypeOnly === true || statement.importClause?.namedBindings === void 0 || !ts.isNamedImports(statement.importClause.namedBindings)) continue;
+		for (const element of statement.importClause.namedBindings.elements) {
+			if (element.isTypeOnly) continue;
+			const importedName = element.propertyName?.text ?? element.name.text;
+			if (importedName === "createSdkMcpServer") createSdkMcpServerNames.add(element.name.text);
+			else if (importedName === "query") queryNames.add(element.name.text);
+			else if (importedName === "tool") toolNames.add(element.name.text);
+		}
+	}
+	return Object.freeze({
+		createSdkMcpServerNames,
+		queryNames,
+		toolNames
+	});
+};
+/**
+* Parses and indexes one Claude Agent SDK TypeScript module without executing it.
+* @param path The normalized repository source path.
+* @param bytes The exact repository bytes.
+* @param signal The active inspection signal.
+* @returns The source analysis or a stable invalid source result.
+*/
+var analyzeClaudeAgentSdkSource = (path, bytes, signal) => {
+	const result = analyzeTypeScriptModule(path, bytes, CLAUDE_AGENT_SDK_IMPORT_CONFIG, signal);
+	if (result.kind !== "valid") return result;
+	const analysis = Object.freeze({
+		...result.analysis,
+		imports: indexClaudeAgentSdkImports(result.analysis.sourceFile),
+		path
+	});
+	return Object.freeze({
+		analysis,
+		kind: "valid"
+	});
+};
+//#endregion
+//#region src/source-analysis/static-strings.ts
+/**
+* Resolves one exact supported static string without normalization or execution.
+* @param session The operation-local source session.
+* @param analysis The source containing the expression.
+* @param expression The candidate static string expression.
+* @returns The exact compiler-parsed string or an unsupported state.
+*/
+var resolveClaudeAgentSdkStaticString = (session, analysis, expression) => resolveStaticString({
+	analysis,
+	analyzeSource: (path) => session.analyzeSource(path),
+	expression,
+	getEntry: (path) => session.getEntry(path),
+	parsePath: parseRepositoryPath,
+	...session.signal === void 0 ? {} : { signal: session.signal }
+});
+//#endregion
+//#region src/diagnostics/index.ts
+var CLAUDE_AGENT_SDK_ADAPTER_DIAGNOSTICS = Object.freeze({
+	CLAUDE_AGENT_SDK_AGENT_OUTPUT_SCHEMA_NOT_WIRED: "The declared agent output schema is not wired to the detected Claude Agent SDK query output format.",
+	CLAUDE_AGENT_SDK_AGENT_OUTPUT_SCHEMA_SYMBOL_NOT_FOUND: "The declared agent output-schema symbol was not found.",
+	CLAUDE_AGENT_SDK_HANDOFF_ROUTING_DESCRIPTION_MISSING: "The detected Claude Agent SDK subagent registration has no supported routing description.",
+	CLAUDE_AGENT_SDK_HANDOFF_ROUTING_DESCRIPTION_NOT_WIRED: "The detected Claude Agent SDK subagent routing description does not use the target agent's effective routing description.",
+	CLAUDE_AGENT_SDK_HANDOFF_TARGET_AMBIGUOUS: "The detected Claude Agent SDK subagent target matches more than one registered moldea agent.",
+	CLAUDE_AGENT_SDK_INSTRUCTION_LOADER_NOT_WIRED: "The declared instruction loader is not wired to the detected Claude Agent SDK agent.",
+	CLAUDE_AGENT_SDK_INSTRUCTION_LOADER_SYMBOL_NOT_FOUND: "The declared instruction-loader symbol was not found.",
+	CLAUDE_AGENT_SDK_PACKAGE_MANIFEST_INVALID: "The owning package manifest is invalid for Claude Agent SDK dependency detection.",
+	CLAUDE_AGENT_SDK_RUNTIME_AGENT_SYMBOL_NOT_FOUND: "The declared runtime-agent symbol was not found.",
+	CLAUDE_AGENT_SDK_SOURCE_SYNTAX_INVALID: "The referenced Claude Agent SDK source file contains invalid TypeScript syntax.",
+	CLAUDE_AGENT_SDK_SOURCE_TEXT_INVALID: "The referenced Claude Agent SDK source file is not valid normalized text.",
+	CLAUDE_AGENT_SDK_TOOL_IMPLEMENTATION_NOT_WIRED: "The declared tool implementation is not wired to the detected Claude Agent SDK custom tool.",
+	CLAUDE_AGENT_SDK_TOOL_IMPLEMENTATION_SYMBOL_NOT_FOUND: "The declared tool-implementation symbol was not found.",
+	CLAUDE_AGENT_SDK_TOOL_INPUT_SCHEMA_NOT_WIRED: "The declared tool input schema is not wired to the detected Claude Agent SDK custom tool.",
+	CLAUDE_AGENT_SDK_TOOL_INPUT_SCHEMA_SYMBOL_NOT_FOUND: "The declared tool input-schema symbol was not found.",
+	CLAUDE_AGENT_SDK_TOOL_NAME_MISMATCH: "The declared tool name does not match the detected Claude Agent SDK MCP tool name.",
+	CLAUDE_AGENT_SDK_MCP_SERVER_KEY_UNSUPPORTED: "The detected Claude Agent SDK MCP server key cannot establish a canonical runtime-name segment.",
+	CLAUDE_AGENT_SDK_TOOL_REGISTRATION_NOT_WIRED: "The declared tool registration is not available to the detected Claude Agent SDK agent.",
+	CLAUDE_AGENT_SDK_TOOL_REGISTRATION_SYMBOL_NOT_FOUND: "The declared tool-registration symbol was not found.",
+	CLAUDE_AGENT_SDK_VERSION_UNSUPPORTED: "The observed Claude Agent SDK dependency range is disjoint from the supported range."
+});
+/**
+* Creates one frozen, safely namespaced Claude Agent SDK adapter diagnostic.
+* @param input The complete code, location, entity, and safe scalar details.
+* @returns The immutable adapter diagnostic.
+*/
+var createClaudeAgentSdkDiagnostic = (input) => Object.freeze({
+	...input,
+	details: Object.freeze({ ...input.details }),
+	entity: input.entity === null ? null : Object.freeze({ ...input.entity }),
+	message: CLAUDE_AGENT_SDK_ADAPTER_DIAGNOSTICS[input.code],
+	source: CLAUDE_AGENT_SDK_ADAPTER_ID
+});
+//#endregion
+//#region src/inspection/common.ts
+var LINE_BREAK_CODE_POINTS = /* @__PURE__ */ new Set([
+	10,
+	13,
+	133,
+	8232,
+	8233
+]);
+var isUnicodeWhiteSpace = (codePoint) => codePoint >= 9 && codePoint <= 13 || codePoint === 32 || codePoint === 133 || codePoint === 160 || codePoint === 5760 || codePoint >= 8192 && codePoint <= 8202 || codePoint >= 8232 && codePoint <= 8233 || codePoint === 8239 || codePoint === 8287 || codePoint === 12288;
+/** Compares exact strings without locale-dependent behavior. */
+var compareClaudeAgentSdkStrings = (left, right) => left < right ? -1 : left > right ? 1 : 0;
+/** Determines whether a runtime-visible value satisfies Core's machine-string contract. */
+var isClaudeAgentSdkMachineString = (value) => {
+	const codePoints = [...value].map((character) => character.codePointAt(0));
+	return codePoints.length > 0 && codePoints.every((codePoint) => codePoint < 55296 || codePoint > 57343) && !codePoints.includes(0) && !codePoints.some((codePoint) => LINE_BREAK_CODE_POINTS.has(codePoint)) && !isUnicodeWhiteSpace(codePoints[0]) && !isUnicodeWhiteSpace(codePoints.at(-1));
+};
+var freezeReference = (reference) => Object.freeze({
+	path: reference.path,
+	...reference.symbol === void 0 ? {} : { symbol: reference.symbol }
+});
+/** Creates one deeply immutable Claude Agent SDK evidence record. */
+var createClaudeAgentSdkEvidence = (evidence) => Object.freeze({
+	...evidence,
+	details: Object.freeze({ ...evidence.details }),
+	references: Object.freeze(evidence.references.map(freezeReference))
+});
+var createEntity = (agentId, capabilityId) => Object.freeze({
+	adapterId: CLAUDE_AGENT_SDK_ADAPTER_ID,
+	agentId,
+	...capabilityId === void 0 ? {} : {
+		capabilityId,
+		capabilityKind: "tool"
+	}
+});
+/**
+* Appends one stable package-owned diagnostic.
+* @param diagnostics The operation result collection.
+* @param code The stable diagnostic code.
+* @param path The exact affected path.
+* @param agentId The owning source-agent identifier.
+* @param range The optional scalar source range.
+* @param capabilityId The optional owning tool capability.
+* @param details Safe scalar diagnostic details.
+*/
+var addClaudeAgentSdkDiagnostic = (diagnostics, code, path, agentId, range = null, capabilityId, details = {}) => {
+	diagnostics.push(createClaudeAgentSdkDiagnostic({
+		code,
+		details,
+		entity: createEntity(agentId, capabilityId),
+		path,
+		pointer: null,
+		range
+	}));
+};
+/** Returns the Core scalar range for one node in its analyzed source. */
+var locateClaudeAgentSdkNode = (analysis, node) => analysis.text.locator.locateRange(node.getStart(analysis.sourceFile), node.getEnd());
+/**
+* Loads and validates one supported bound TypeScript source.
+* @param session The operation-local inspection session.
+* @param reference The exact manifest reference.
+* @param diagnostics The operation result collection.
+* @param agentId The owning agent identifier.
+* @param capabilityId The optional owning tool capability.
+* @returns The indexed source or `null` after unsupported or invalid input.
+*/
+var analyzeClaudeAgentSdkBoundReference = async (session, reference, diagnostics, agentId, capabilityId) => {
+	if (!isSupportedTypeScriptSourcePath(reference.path)) return null;
+	const result = await session.analyzeSource(reference.path);
+	if (result.kind === "invalid-text") {
+		addClaudeAgentSdkDiagnostic(diagnostics, "CLAUDE_AGENT_SDK_SOURCE_TEXT_INVALID", reference.path, agentId, null, capabilityId);
+		return null;
+	}
+	if (result.kind === "invalid-syntax") {
+		addClaudeAgentSdkDiagnostic(diagnostics, "CLAUDE_AGENT_SDK_SOURCE_SYNTAX_INVALID", reference.path, agentId, result.range, capabilityId);
+		return null;
+	}
+	return result.analysis;
+};
+//#endregion
+//#region src/inspection/resolution.ts
+var getReferenceCandidates = (analysis, expression, includeLocalConst) => {
+	const candidate = unwrapExpression(expression);
+	if (!ts.isIdentifier(candidate) || !isModuleBindingVisible(candidate, analysis)) return [];
+	const references = [...resolveBindingReferences(candidate, analysis)];
+	if (includeLocalConst && analysis.moduleConstDeclarations.has(candidate.text) && !references.some((reference) => reference.path === analysis.path && reference.symbol === candidate.text)) references.unshift(Object.freeze({
+		path: analysis.path,
+		symbol: candidate.text
+	}));
+	return references;
+};
+var loadCandidateSource = async (session, path) => {
+	const parsedPath = parseRepositoryPath(path);
+	if ((await session.getEntry(parsedPath))?.type !== "file") return null;
+	const source = await session.analyzeSource(parsedPath);
+	return source.kind === "valid" ? Object.freeze({
+		analysis: source.analysis,
+		path: parsedPath
+	}) : null;
+};
+/** Resolves one exact supported programmatic definition through local or relative binding identity. */
+var resolveClaudeAgentSdkAgentDefinition = async (session, analysis, expression) => {
+	const resolved = [];
+	for (const reference of getReferenceCandidates(analysis, expression, false)) {
+		const source = await loadCandidateSource(session, reference.path);
+		if (source === null) continue;
+		const result = getClaudeAgentSdkAgentDefinition(source.analysis, reference.symbol);
+		if (result.kind === "present-supported") resolved.push(Object.freeze({
+			analysis: source.analysis,
+			definition: result.definition,
+			path: source.path,
+			symbol: reference.symbol
+		}));
+	}
+	return resolved.length === 1 ? resolved[0] : null;
+};
+/** Resolves one exact supported SDK MCP server through local or relative binding identity. */
+var resolveClaudeAgentSdkMcpServer = async (session, analysis, expression) => {
+	const resolved = [];
+	for (const reference of getReferenceCandidates(analysis, expression, true)) {
+		const source = await loadCandidateSource(session, reference.path);
+		if (source === null) continue;
+		const definition = getClaudeAgentSdkMcpServerDefinition(source.analysis, reference.symbol);
+		if (definition !== null) resolved.push(Object.freeze({
+			analysis: source.analysis,
+			definition,
+			path: source.path,
+			symbol: reference.symbol
+		}));
+	}
+	return resolved.length === 1 ? resolved[0] : null;
+};
+/** Resolves one exact supported exported SDK tool through local or relative binding identity. */
+var resolveClaudeAgentSdkTool = async (session, analysis, expression) => {
+	const resolved = [];
+	for (const reference of getReferenceCandidates(analysis, expression, false)) {
+		const source = await loadCandidateSource(session, reference.path);
+		if (source === null) continue;
+		const result = getClaudeAgentSdkToolDefinition(source.analysis, reference.symbol);
+		if (result.kind === "present-supported") resolved.push(Object.freeze({
+			analysis: source.analysis,
+			definition: result.tool,
+			path: source.path,
+			symbol: reference.symbol
+		}));
+	}
+	return resolved.length === 1 ? resolved[0] : null;
+};
+//#endregion
+//#region src/inspection/handoffs.ts
+var resolveMapEntryName = async (session, inspected, entry) => {
+	if (entry.name !== null) return entry.name;
+	const keyExpression = entry.keyExpression;
+	if (!ts.isExpression(keyExpression)) return null;
+	const result = await resolveClaudeAgentSdkStaticString(session, inspected.analysis, keyExpression);
+	return result.kind === "supported" ? result.value : null;
+};
+var getMappedAgents = (context, target) => context.project.agents.filter(({ declaration }) => {
+	const runtimeAgent = declaration.bindings?.runtimeAgent;
+	return runtimeAgent?.path === target.path && runtimeAgent.symbol === target.symbol;
+});
+var inspectRoutingDescription = async (session, sourceAgentId, target, targetAgent, runtimeName, diagnostics) => {
+	const canonicalDescription = targetAgent.handoffDescription?.value ?? targetAgent.description.value;
+	const relationship = target.definition.description;
+	const safeDetails = {
+		targetAgentId: targetAgent.id,
+		...isClaudeAgentSdkMachineString(runtimeName) ? { targetRuntimeName: runtimeName } : {}
+	};
+	if (relationship.kind === "unresolved") return;
+	if (relationship.kind === "absent") {
+		addClaudeAgentSdkDiagnostic(diagnostics, "CLAUDE_AGENT_SDK_HANDOFF_ROUTING_DESCRIPTION_MISSING", target.path, sourceAgentId, locateClaudeAgentSdkNode(target.analysis, target.definition.declaration), void 0, safeDetails);
+		return;
+	}
+	const result = await resolveClaudeAgentSdkStaticString(session, target.analysis, relationship.expression);
+	if (result.kind !== "supported") return;
+	const code = result.value.length === 0 ? "CLAUDE_AGENT_SDK_HANDOFF_ROUTING_DESCRIPTION_MISSING" : result.value !== canonicalDescription ? "CLAUDE_AGENT_SDK_HANDOFF_ROUTING_DESCRIPTION_NOT_WIRED" : null;
+	if (code !== null) addClaudeAgentSdkDiagnostic(diagnostics, code, target.path, sourceAgentId, locateClaudeAgentSdkNode(target.analysis, relationship.expression), void 0, safeDetails);
+};
+/** Inspects active query-configured programmatic subagent registrations and routing metadata. */
+var inspectClaudeAgentSdkHandoffs = async (context, session, inspected, evidence, diagnostics) => {
+	const collectionReferences = collectClaudeAgentSdkRelationshipIdentifiers(inspected.wrapper.contexts.flatMap((queryContext) => [
+		queryContext.tools,
+		queryContext.disallowedTools,
+		queryContext.agents
+	]));
+	for (const queryContext of inspected.wrapper.contexts) {
+		session.signal?.throwIfAborted();
+		if (await classifyClaudeAgentSdkAgentAvailability(inspected.analysis, queryContext.tools, queryContext.disallowedTools, queryContext.agentSelection, queryContext.toolAliases, collectionReferences, (analysis, expression) => resolveClaudeAgentSdkStaticString(session, analysis, expression)) !== "available") continue;
+		const entries = getClaudeAgentSdkClosedMapEntries(queryContext.agents, inspected.analysis, collectionReferences);
+		if (entries === null) continue;
+		const resolvedNames = await Promise.all(entries.map((entry) => resolveMapEntryName(session, inspected, entry)));
+		const supportedNames = resolvedNames.filter((name) => name !== null);
+		if (supportedNames.length !== entries.length || new Set(supportedNames).size !== supportedNames.length) continue;
+		for (const [entryIndex, entry] of entries.entries()) {
+			session.signal?.throwIfAborted();
+			const runtimeName = resolvedNames[entryIndex];
+			if (runtimeName === void 0 || runtimeName === null) continue;
+			const unresolvedTarget = await resolveClaudeAgentSdkAgentDefinition(session, inspected.analysis, entry.value);
+			if (unresolvedTarget === null) continue;
+			const target = Object.freeze({
+				...unresolvedTarget,
+				definition: applyClaudeAgentSdkAgentMutations(unresolvedTarget.analysis, unresolvedTarget.definition, collectClaudeAgentSdkAgentDefinitionReferences(unresolvedTarget.analysis))
+			});
+			const mappedAgents = getMappedAgents(context, target);
+			const mappedAgent = mappedAgents.length === 1 ? mappedAgents[0] : void 0;
+			const safeRuntimeName = isClaudeAgentSdkMachineString(runtimeName) ? runtimeName : null;
+			const details = {
+				delegationAvailabilitySource: queryContext.tools.kind === "absent" ? "default-built-in-tools" : "explicit-built-in-tools",
+				delegationTool: "Agent",
+				registrationKind: "programmatic-subagent",
+				registrationScope: "query-session",
+				...mappedAgent === void 0 ? {} : { targetAgentId: mappedAgent.id },
+				...safeRuntimeName === null ? {} : { targetRuntimeName: safeRuntimeName }
+			};
+			if (mappedAgents.length > 1) addClaudeAgentSdkDiagnostic(diagnostics, "CLAUDE_AGENT_SDK_HANDOFF_TARGET_AMBIGUOUS", inspected.analysis.path, inspected.agent.id, locateClaudeAgentSdkNode(inspected.analysis, entry.value), void 0, safeRuntimeName === null ? {} : { targetRuntimeName: safeRuntimeName });
+			else if (mappedAgent !== void 0) await inspectRoutingDescription(session, inspected.agent.id, target, mappedAgent, runtimeName, diagnostics);
+			evidence.push(createClaudeAgentSdkEvidence({
+				agentId: inspected.agent.id,
+				capabilityId: null,
+				capabilityKind: null,
+				details,
+				kind: "handoff-registration",
+				references: [{ path: inspected.analysis.path }, {
+					path: target.path,
+					symbol: target.symbol
+				}],
+				runtimeName: safeRuntimeName,
+				source: CLAUDE_AGENT_SDK_ADAPTER_ID
+			}));
+		}
+	}
+};
+//#endregion
+//#region src/inspection/package-inspection.ts
+/** Inspects the nearest owning package manifest for one runtime source. */
+var inspectClaudeAgentSdkPackage = async (session, sourcePath, evidence, diagnostics, agentId) => {
+	const discovery = await session.discoverPackage(sourcePath);
+	if (discovery.kind === "absent") return;
+	if (discovery.kind === "invalid") {
+		addClaudeAgentSdkDiagnostic(diagnostics, "CLAUDE_AGENT_SDK_PACKAGE_MANIFEST_INVALID", discovery.path, agentId);
+		return;
+	}
+	const { observation } = discovery;
+	if (observation.compatibility === "unsupported") {
+		addClaudeAgentSdkDiagnostic(diagnostics, "CLAUDE_AGENT_SDK_VERSION_UNSUPPORTED", observation.path, agentId);
+		return;
+	}
+	for (const declaration of observation.declarations) evidence.push(createClaudeAgentSdkEvidence({
+		agentId,
+		capabilityId: null,
+		capabilityKind: null,
+		details: {
+			compatibility: observation.compatibility,
+			declaredRange: declaration.declaredRange,
+			dependencyKind: declaration.dependencyKind
+		},
+		kind: "runtime-package",
+		references: [{ path: observation.path }],
+		runtimeName: CLAUDE_AGENT_SDK_PACKAGE_NAME,
+		source: CLAUDE_AGENT_SDK_ADAPTER_ID
+	}));
+};
+//#endregion
+//#region src/inspection/relationships.ts
+var inspectCallableSymbol$1 = async (session, reference, agentId, diagnostics) => {
+	if (reference.symbol === void 0) return null;
+	const analysis = await analyzeClaudeAgentSdkBoundReference(session, reference, diagnostics, agentId);
+	if (analysis === null) return null;
+	const state = getCallableExportState(analysis, reference.symbol);
+	if (state.kind === "absent") {
+		addClaudeAgentSdkDiagnostic(diagnostics, "CLAUDE_AGENT_SDK_INSTRUCTION_LOADER_SYMBOL_NOT_FOUND", reference.path, agentId);
+		return false;
+	}
+	return state.kind === "present-supported" ? true : null;
+};
+var getInstructionRole = (relationship) => {
+	if (relationship.kind !== "present") return "query-system-prompt";
+	const candidate = unwrapExpression(relationship.expression);
+	if (!ts.isObjectLiteralExpression(candidate)) return "query-system-prompt";
+	const properties = getClosedObjectProperties(candidate);
+	return properties !== null && getStaticString(properties.get("type") ?? candidate) === "preset" && getStaticString(properties.get("preset") ?? candidate) === "claude_code" ? "query-preset-append" : "query-system-prompt";
+};
+var inspectQueryInstructionLoader = async (session, inspected, evidence, diagnostics) => {
+	const reference = inspected.agent.declaration.bindings?.instructionLoader;
+	if (reference?.symbol === void 0) return;
+	if (await inspectCallableSymbol$1(session, reference, inspected.agent.id, diagnostics) !== true) return;
+	const results = inspected.wrapper.contexts.map((context) => context.agentSelection.kind === "absent" ? classifyClaudeAgentSdkInstructionLoader(context.systemPrompt, inspected.analysis, reference, true) : null);
+	const wiredIndex = results.findIndex((result) => result === true);
+	if (wiredIndex >= 0) {
+		const context = inspected.wrapper.contexts[wiredIndex];
+		if (context !== void 0) evidence.push(createClaudeAgentSdkEvidence({
+			agentId: inspected.agent.id,
+			capabilityId: null,
+			capabilityKind: null,
+			details: { role: getInstructionRole(context.systemPrompt) },
+			kind: "instruction-loader",
+			references: [{ path: inspected.analysis.path }, {
+				path: reference.path,
+				symbol: reference.symbol
+			}],
+			runtimeName: reference.symbol,
+			source: CLAUDE_AGENT_SDK_ADAPTER_ID
+		}));
+	} else if (!inspected.wrapper.hasAmbiguousCandidate && results.every((result) => result === false)) addClaudeAgentSdkDiagnostic(diagnostics, "CLAUDE_AGENT_SDK_INSTRUCTION_LOADER_NOT_WIRED", inspected.analysis.path, inspected.agent.id);
+};
+var inspectDefinitionInstructionLoader = async (session, inspected, evidence, diagnostics) => {
+	const reference = inspected.agent.declaration.bindings?.instructionLoader;
+	if (reference?.symbol === void 0) return;
+	if (await inspectCallableSymbol$1(session, reference, inspected.agent.id, diagnostics) !== true) return;
+	const relationship = classifyClaudeAgentSdkInstructionLoader(inspected.definition.prompt, inspected.analysis, reference, false);
+	if (relationship === true) evidence.push(createClaudeAgentSdkEvidence({
+		agentId: inspected.agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: { role: "subagent-prompt" },
+		kind: "instruction-loader",
+		references: [{ path: inspected.analysis.path }, {
+			path: reference.path,
+			symbol: reference.symbol
+		}],
+		runtimeName: reference.symbol,
+		source: CLAUDE_AGENT_SDK_ADAPTER_ID
+	}));
+	else if (relationship === false) addClaudeAgentSdkDiagnostic(diagnostics, "CLAUDE_AGENT_SDK_INSTRUCTION_LOADER_NOT_WIRED", inspected.analysis.path, inspected.agent.id, inspected.definition.prompt.kind === "present" ? locateClaudeAgentSdkNode(inspected.analysis, inspected.definition.prompt.expression) : null);
+};
+var getOutputSchemaRelationship = (relationship) => {
+	if (relationship.kind !== "present") return relationship;
+	const candidate = unwrapExpression(relationship.expression);
+	if (!ts.isObjectLiteralExpression(candidate)) return { kind: "unresolved" };
+	const properties = getClosedObjectProperties(candidate);
+	if (properties === null || properties.size !== 2 || getStaticString(properties.get("type") ?? candidate) !== "json_schema") return properties !== null ? {
+		expression: candidate,
+		kind: "present"
+	} : { kind: "unresolved" };
+	const schema = properties.get("schema");
+	return schema === void 0 ? {
+		expression: candidate,
+		kind: "present"
+	} : {
+		expression: schema,
+		kind: "present"
+	};
+};
+var inspectQueryOutputSchema = async (session, inspected, evidence, diagnostics) => {
+	const reference = inspected.agent.declaration.bindings?.outputSchema;
+	if (reference?.symbol === void 0) return;
+	const schemaAnalysis = await analyzeClaudeAgentSdkBoundReference(session, reference, diagnostics, inspected.agent.id);
+	if (schemaAnalysis === null) return;
+	const schema = getConstExport(schemaAnalysis, reference.symbol);
+	if (schema.kind === "absent") {
+		addClaudeAgentSdkDiagnostic(diagnostics, "CLAUDE_AGENT_SDK_AGENT_OUTPUT_SCHEMA_SYMBOL_NOT_FOUND", reference.path, inspected.agent.id);
+		return;
+	}
+	if (schema.kind !== "present-supported") return;
+	const results = inspected.wrapper.contexts.map((context) => classifyClaudeAgentSdkDirectBinding(getOutputSchemaRelationship(context.outputFormat), inspected.analysis, reference));
+	if (results.includes(true)) evidence.push(createClaudeAgentSdkEvidence({
+		agentId: inspected.agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: {
+			role: "agent-output",
+			schemaKind: "json-schema"
+		},
+		kind: "schema",
+		references: [{ path: inspected.analysis.path }, {
+			path: reference.path,
+			symbol: reference.symbol
+		}],
+		runtimeName: reference.symbol,
+		source: CLAUDE_AGENT_SDK_ADAPTER_ID
+	}));
+	else if (!inspected.wrapper.hasAmbiguousCandidate && results.every((result) => result === false)) addClaudeAgentSdkDiagnostic(diagnostics, "CLAUDE_AGENT_SDK_AGENT_OUTPUT_SCHEMA_NOT_WIRED", inspected.analysis.path, inspected.agent.id);
+};
+/** Inspects canonical instruction and query-output-schema relationships. */
+var inspectClaudeAgentSdkRelationships = async (session, inspected, evidence, diagnostics) => {
+	if (inspected.kind === "query-wrapper") {
+		await inspectQueryInstructionLoader(session, inspected, evidence, diagnostics);
+		await inspectQueryOutputSchema(session, inspected, evidence, diagnostics);
+	} else await inspectDefinitionInstructionLoader(session, inspected, evidence, diagnostics);
+};
+//#endregion
+//#region src/package-discovery/index.ts
+/**
+* Discovers the nearest relevant Claude Agent SDK package declaration.
+* @param repository The Core-owned budget-aware repository reader.
+* @param sourcePath The bound source whose package scope is inspected.
+* @param signal The active inspection signal.
+* @returns The first observed declaration, invalid manifest, or absence result.
+* @throws
+* - INVALID_REPOSITORY_PATH: The repository path is invalid.
+* - ENTRY_NOT_FOUND: The requested repository entry was not found.
+* - ENTRY_NOT_FILE: The requested repository entry is not a file.
+* - ACCESS_DENIED: Access to the repository source was denied.
+* - SOURCE_UNAVAILABLE: The repository source is unavailable.
+* - SNAPSHOT_CHANGED: The repository snapshot changed during the operation.
+* - INVALID_SOURCE_DATA: The repository source returned invalid data.
+* - RESOURCE_LIMIT_EXCEEDED: A repository reading resource limit was exceeded.
+* - ABORTED: The repository operation was aborted.
+*/
+var discoverClaudeAgentSdkPackage = async (repository, sourcePath, signal) => {
+	const repositoryOptions = signal === void 0 ? void 0 : { signal };
+	const result = await discoverPackage({
+		packageName: CLAUDE_AGENT_SDK_PACKAGE_NAME,
+		reader: {
+			getEntry: (path) => repository.getEntry(parseRepositoryPath(path), repositoryOptions),
+			readFile: (path) => repository.readFile(parseRepositoryPath(path), repositoryOptions)
+		},
+		...signal === void 0 ? {} : { signal },
+		sourcePath,
+		supportedRange: CLAUDE_AGENT_SDK_SUPPORTED_RANGE
+	});
+	if (result.kind === "invalid") return Object.freeze({
+		kind: "invalid",
+		path: parseRepositoryPath(result.path)
+	});
+	if (result.kind === "observed") return Object.freeze({
+		kind: "observed",
+		observation: Object.freeze({
+			...result.observation,
+			path: parseRepositoryPath(result.observation.path)
+		})
+	});
+	return result;
+};
+//#endregion
+//#region src/inspection/session.ts
+/** Creates one operation-local Claude Agent SDK inspection session. */
+var createClaudeAgentSdkInspectionSession = (context) => createInspectionSession({
+	analyzeSource: analyzeClaudeAgentSdkSource,
+	discoverPackage: (path, signal) => discoverClaudeAgentSdkPackage(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 }
+});
+//#endregion
+//#region src/inspection/tools.ts
+var collectMcpServerReferences = (analysis) => {
+	const serverRelationships = [...analysis.exports.keys()].flatMap((symbol) => {
+		const result = getClaudeAgentSdkQueryWrapper(analysis, symbol);
+		return result.kind === "present-supported" ? result.wrapper.contexts.map(({ mcpServers }) => mcpServers) : [];
+	});
+	const collectionReferences = collectClaudeAgentSdkRelationshipIdentifiers(serverRelationships);
+	return new Set(serverRelationships.flatMap((relationship) => (getClaudeAgentSdkClosedMapEntries(relationship, analysis, collectionReferences) ?? []).map(({ value }) => value).filter((value) => ts.isIdentifier(value))));
+};
+var resolveEntryName = async (session, analysis, entry) => {
+	if (entry.name !== null) return entry.name;
+	const result = await resolveClaudeAgentSdkStaticString(session, analysis, entry.keyExpression);
+	return result.kind === "supported" ? result.value : null;
+};
+var inspectCallableSymbol = async (session, reference, agentId, capabilityId, diagnostics) => {
+	if (reference.symbol === void 0) return null;
+	const analysis = await analyzeClaudeAgentSdkBoundReference(session, reference, diagnostics, agentId, capabilityId);
+	if (analysis === null) return null;
+	const state = getCallableExportState(analysis, reference.symbol);
+	if (state.kind === "absent") {
+		addClaudeAgentSdkDiagnostic(diagnostics, "CLAUDE_AGENT_SDK_TOOL_IMPLEMENTATION_SYMBOL_NOT_FOUND", reference.path, agentId, null, capabilityId);
+		return false;
+	}
+	return state.kind === "present-supported" ? true : null;
+};
+var inspectConstSymbol = async (session, reference, agentId, capabilityId, diagnostics) => {
+	if (reference.symbol === void 0) return null;
+	const analysis = await analyzeClaudeAgentSdkBoundReference(session, reference, diagnostics, agentId, capabilityId);
+	if (analysis === null) return null;
+	const state = getConstExport(analysis, reference.symbol);
+	if (state.kind === "absent") {
+		addClaudeAgentSdkDiagnostic(diagnostics, "CLAUDE_AGENT_SDK_TOOL_INPUT_SCHEMA_SYMBOL_NOT_FOUND", reference.path, agentId, null, capabilityId);
+		return false;
+	}
+	return state.kind === "present-supported" ? true : null;
+};
+var inspectManifestTool = async (session, agentId, capabilityId, declaration, evidence, diagnostics) => {
+	const reference = declaration.registration;
+	if (reference?.symbol === void 0) return null;
+	const analysis = await analyzeClaudeAgentSdkBoundReference(session, reference, diagnostics, agentId, capabilityId);
+	if (analysis === null) return null;
+	const result = getClaudeAgentSdkToolDefinition(analysis, reference.symbol);
+	if (result.kind === "absent") {
+		addClaudeAgentSdkDiagnostic(diagnostics, "CLAUDE_AGENT_SDK_TOOL_REGISTRATION_SYMBOL_NOT_FOUND", reference.path, agentId, null, capabilityId);
+		return null;
+	}
+	if (result.kind !== "present-supported") return null;
+	const allowedReferences = collectClaudeAgentSdkMcpToolReferences(analysis);
+	const mutations = analyzeClaudeAgentSdkMutations(analysis, result.tool.declaration, allowedReferences);
+	const implementationRelationship = mutations.hasUnknownMutation || mutations.mutatedMembers.has("handler") ? null : classifyClaudeAgentSdkDirectBinding({
+		expression: result.tool.implementation,
+		kind: "present"
+	}, analysis, declaration.implementation);
+	if (await inspectCallableSymbol(session, declaration.implementation, agentId, capabilityId, diagnostics) === true && implementationRelationship === false) addClaudeAgentSdkDiagnostic(diagnostics, "CLAUDE_AGENT_SDK_TOOL_IMPLEMENTATION_NOT_WIRED", analysis.path, agentId, locateClaudeAgentSdkNode(analysis, result.tool.implementation), capabilityId);
+	if (declaration.inputSchema?.symbol !== void 0) {
+		const schemaState = await inspectConstSymbol(session, declaration.inputSchema, agentId, capabilityId, diagnostics);
+		const schemaRelationship = mutations.hasUnknownMutation || mutations.mutatedMembers.has("inputSchema") ? null : classifyClaudeAgentSdkDirectBinding({
+			expression: result.tool.inputSchema,
+			kind: "present"
+		}, analysis, declaration.inputSchema);
+		if (schemaState === true && schemaRelationship === true) evidence.push(createClaudeAgentSdkEvidence({
+			agentId,
+			capabilityId,
+			capabilityKind: "tool",
+			details: {
+				role: "tool-input",
+				schemaKind: "sdk-tool-input"
+			},
+			kind: "schema",
+			references: [{ path: analysis.path }, {
+				path: declaration.inputSchema.path,
+				symbol: declaration.inputSchema.symbol
+			}],
+			runtimeName: declaration.inputSchema.symbol,
+			source: CLAUDE_AGENT_SDK_ADAPTER_ID
+		}));
+		else if (schemaState === true && schemaRelationship === false) addClaudeAgentSdkDiagnostic(diagnostics, "CLAUDE_AGENT_SDK_TOOL_INPUT_SCHEMA_NOT_WIRED", analysis.path, agentId, locateClaudeAgentSdkNode(analysis, result.tool.inputSchema), capabilityId);
+	}
+	return Object.freeze({
+		analysis,
+		definition: result.tool,
+		reference: Object.freeze({
+			path: reference.path,
+			symbol: reference.symbol
+		})
+	});
+};
+var collectQueryMounts = async (session, queryAgent, diagnostics) => {
+	const mounts = [];
+	let hasUnresolvedCandidate = queryAgent.wrapper.hasAmbiguousCandidate;
+	const queryCollectionReferences = collectClaudeAgentSdkRelationshipIdentifiers(queryAgent.wrapper.contexts.flatMap((queryContext) => [queryContext.mcpServers, queryContext.disallowedTools]));
+	for (const queryContext of queryAgent.wrapper.contexts) {
+		const entries = getClaudeAgentSdkClosedMapEntries(queryContext.mcpServers, queryAgent.analysis, queryCollectionReferences);
+		if (entries === null) {
+			hasUnresolvedCandidate = true;
+			continue;
+		}
+		const resolvedNames = await Promise.all(entries.map((entry) => resolveEntryName(session, queryAgent.analysis, entry)));
+		const supportedNames = resolvedNames.filter((name) => name !== null);
+		if (supportedNames.length !== entries.length || new Set(supportedNames).size !== supportedNames.length) {
+			hasUnresolvedCandidate = true;
+			continue;
+		}
+		for (const [entryIndex, entry] of entries.entries()) {
+			const serverKey = resolvedNames[entryIndex];
+			if (serverKey === void 0 || serverKey === null) {
+				hasUnresolvedCandidate = true;
+				continue;
+			}
+			const server = await resolveClaudeAgentSdkMcpServer(session, queryAgent.analysis, entry.value);
+			if (server === null) {
+				hasUnresolvedCandidate = true;
+				continue;
+			}
+			const serverMutations = analyzeClaudeAgentSdkMutations(server.analysis, server.definition.declaration, collectMcpServerReferences(server.analysis));
+			if (serverMutations.hasUnknownMutation || serverMutations.mutatedMembers.has("tools")) {
+				hasUnresolvedCandidate = true;
+				continue;
+			}
+			if (!CLAUDE_AGENT_SDK_MCP_SERVER_KEY_PATTERN.test(serverKey)) {
+				addClaudeAgentSdkDiagnostic(diagnostics, "CLAUDE_AGENT_SDK_MCP_SERVER_KEY_UNSUPPORTED", queryAgent.analysis.path, queryAgent.agent.id, locateClaudeAgentSdkNode(queryAgent.analysis, entry.keyExpression));
+				hasUnresolvedCandidate = true;
+				continue;
+			}
+			const serverName = await resolveClaudeAgentSdkStaticString(session, server.analysis, server.definition.name);
+			const serverVersion = server.definition.version.kind === "present" ? await resolveClaudeAgentSdkStaticString(session, server.analysis, server.definition.version.expression) : {
+				kind: "supported",
+				value: "",
+				expression: server.definition.name
+			};
+			if (serverName.kind !== "supported" || serverVersion.kind !== "supported") {
+				hasUnresolvedCandidate = true;
+				continue;
+			}
+			const serverCollectionReferences = collectClaudeAgentSdkRelationshipIdentifiers([server.definition.tools]);
+			const toolElements = getClaudeAgentSdkClosedArray(server.definition.tools, server.analysis, serverCollectionReferences);
+			if (toolElements === null) {
+				hasUnresolvedCandidate = true;
+				continue;
+			}
+			for (const toolElement of toolElements) {
+				const resolvedTool = await resolveClaudeAgentSdkTool(session, server.analysis, toolElement);
+				if (resolvedTool === null) {
+					hasUnresolvedCandidate = true;
+					continue;
+				}
+				const toolMutations = analyzeClaudeAgentSdkMutations(resolvedTool.analysis, resolvedTool.definition.declaration, collectClaudeAgentSdkMcpToolReferences(resolvedTool.analysis));
+				if (toolMutations.hasUnknownMutation || toolMutations.mutatedMembers.has("name")) {
+					hasUnresolvedCandidate = true;
+					continue;
+				}
+				const name = await resolveClaudeAgentSdkStaticString(session, resolvedTool.analysis, resolvedTool.definition.name);
+				if (name.kind !== "supported") {
+					hasUnresolvedCandidate = true;
+					continue;
+				}
+				const runtimeName = `mcp__${serverKey}__${name.value}`;
+				const availability = await classifyClaudeAgentSdkMcpToolAvailability(queryAgent.analysis, "available", null, queryContext.disallowedTools, queryContext.agentSelection, queryContext.toolAliases, queryCollectionReferences, runtimeName, serverKey, (analysis, expression) => resolveClaudeAgentSdkStaticString(session, analysis, expression));
+				mounts.push(Object.freeze({
+					availability,
+					queryAgent,
+					queryContext,
+					runtimeName,
+					serverKey,
+					tool: Object.freeze({
+						analysis: resolvedTool.analysis,
+						definition: resolvedTool.definition,
+						path: resolvedTool.path,
+						symbol: resolvedTool.symbol,
+						underlyingName: name.value
+					})
+				}));
+			}
+		}
+	}
+	return Object.freeze({
+		hasUnresolvedCandidate,
+		mounts: Object.freeze(mounts),
+		queryAgent
+	});
+};
+var isActiveDefinitionContext = async (session, mount, inspected) => {
+	const queryAgent = mount.queryAgent;
+	const references = collectClaudeAgentSdkRelationshipIdentifiers([
+		mount.queryContext.tools,
+		mount.queryContext.disallowedTools,
+		mount.queryContext.agents
+	]);
+	const agentAvailability = await classifyClaudeAgentSdkAgentAvailability(queryAgent.analysis, mount.queryContext.tools, mount.queryContext.disallowedTools, mount.queryContext.agentSelection, mount.queryContext.toolAliases, references, (analysis, expression) => resolveClaudeAgentSdkStaticString(session, analysis, expression));
+	if (agentAvailability !== "available") return agentAvailability === "unavailable" ? false : null;
+	const entries = getClaudeAgentSdkClosedMapEntries(mount.queryContext.agents, queryAgent.analysis, references);
+	if (entries === null) return null;
+	const targetReference = inspected.agent.declaration.bindings?.runtimeAgent;
+	if (targetReference?.symbol === void 0) return false;
+	for (const entry of entries) {
+		const target = await resolveClaudeAgentSdkAgentDefinition(session, queryAgent.analysis, entry.value);
+		if (target?.path === targetReference.path && target.symbol === targetReference.symbol) return true;
+	}
+	return false;
+};
+var getEligibleMounts = async (session, inspected, collections) => {
+	if (inspected.kind === "query-wrapper") {
+		const matchingCollection = collections.find(({ queryAgent }) => queryAgent.agent.id === inspected.agent.id);
+		const directMounts = collections.flatMap(({ mounts }) => mounts.filter((mount) => mount.queryAgent.agent.id === inspected.agent.id));
+		return Object.freeze({
+			hasUnresolvedCandidate: matchingCollection?.hasUnresolvedCandidate ?? false,
+			mounts: Object.freeze(directMounts)
+		});
+	}
+	const mounts = [];
+	let hasUnresolvedCandidate = false;
+	for (const collection of collections) for (const mount of collection.mounts) {
+		const active = await isActiveDefinitionContext(session, mount, inspected);
+		if (active === null) hasUnresolvedCandidate = true;
+		else if (active) {
+			if (inspected.definition.mcpServers.kind !== "absent") hasUnresolvedCandidate = true;
+			const references = collectClaudeAgentSdkRelationshipIdentifiers([inspected.definition.tools, inspected.definition.disallowedTools]);
+			const availability = await classifyClaudeAgentSdkMcpToolAvailability(inspected.analysis, mount.availability, inspected.definition.tools, inspected.definition.disallowedTools, null, null, references, mount.runtimeName, mount.serverKey, (analysis, expression) => resolveClaudeAgentSdkStaticString(session, analysis, expression));
+			mounts.push(Object.freeze({
+				...mount,
+				availability
+			}));
+		}
+	}
+	return Object.freeze({
+		hasUnresolvedCandidate,
+		mounts: Object.freeze(mounts)
+	});
+};
+/** Inspects custom tool declarations, schemas, implementations, mounts, and availability. */
+var inspectClaudeAgentSdkTools = async (session, inspectedAgents, evidence, diagnostics) => {
+	const queryAgents = inspectedAgents.filter((inspected) => inspected.kind === "query-wrapper");
+	const mountCollections = await Promise.all(queryAgents.map((queryAgent) => collectQueryMounts(session, queryAgent, diagnostics)));
+	for (const inspected of inspectedAgents) {
+		const eligible = await getEligibleMounts(session, inspected, mountCollections);
+		for (const capabilityId of Object.keys(inspected.agent.declaration.tools ?? {}).sort(compareClaudeAgentSdkStrings)) {
+			const declaration = inspected.agent.declaration.tools?.[capabilityId];
+			if (declaration === void 0) continue;
+			const registration = await inspectManifestTool(session, inspected.agent.id, capabilityId, declaration, evidence, diagnostics);
+			if (registration === null) continue;
+			const exactMounts = eligible.mounts.filter((mount) => mount.tool.path === registration.reference.path && mount.tool.symbol === registration.reference.symbol);
+			const matchingMount = exactMounts.find((mount) => mount.availability === "available" && mount.runtimeName === declaration.name);
+			if (matchingMount !== void 0 && isClaudeAgentSdkMachineString(matchingMount.runtimeName)) {
+				evidence.push(createClaudeAgentSdkEvidence({
+					agentId: inspected.agent.id,
+					capabilityId,
+					capabilityKind: "tool",
+					details: {
+						availabilitySource: inspected.kind === "query-wrapper" ? "query" : inspected.definition.tools.kind === "absent" ? "inherited-subagent-tools" : "explicit-subagent-tools",
+						registrationKind: "sdk-mcp-tool",
+						serverKey: matchingMount.serverKey,
+						underlyingToolName: matchingMount.tool.underlyingName
+					},
+					kind: "tool-registration",
+					references: [
+						{ path: matchingMount.queryAgent.analysis.path },
+						{
+							path: registration.reference.path,
+							symbol: registration.reference.symbol
+						},
+						{
+							path: declaration.implementation.path,
+							...declaration.implementation.symbol === void 0 ? {} : { symbol: declaration.implementation.symbol }
+						}
+					],
+					runtimeName: matchingMount.runtimeName,
+					source: CLAUDE_AGENT_SDK_ADAPTER_ID
+				}));
+				continue;
+			}
+			const hasUnresolvedMount = eligible.hasUnresolvedCandidate || exactMounts.some(({ availability }) => availability === "unresolved");
+			const closedMounts = exactMounts.filter(({ availability }) => availability !== "unresolved");
+			const hasDeclaredRuntimeName = closedMounts.some(({ runtimeName }) => runtimeName === declaration.name);
+			if (hasUnresolvedMount) continue;
+			if (closedMounts.length > 0 && !hasDeclaredRuntimeName) {
+				const observedRuntimeName = closedMounts.length === 1 ? closedMounts[0]?.runtimeName : void 0;
+				addClaudeAgentSdkDiagnostic(diagnostics, "CLAUDE_AGENT_SDK_TOOL_NAME_MISMATCH", registration.analysis.path, inspected.agent.id, locateClaudeAgentSdkNode(registration.analysis, registration.definition.name), capabilityId, {
+					expectedRuntimeName: declaration.name,
+					...observedRuntimeName !== void 0 && isClaudeAgentSdkMachineString(observedRuntimeName) ? { observedRuntimeName } : {}
+				});
+			} else if (inspected.kind === "query-wrapper" || eligible.mounts.length > 0) addClaudeAgentSdkDiagnostic(diagnostics, "CLAUDE_AGENT_SDK_TOOL_REGISTRATION_NOT_WIRED", inspected.analysis.path, inspected.agent.id, null, capabilityId);
+		}
+	}
+};
+//#endregion
+//#region src/inspection/inspection.ts
+var inspectAgent = async (session, agent, evidence, diagnostics) => {
+	const runtimeAgent = agent.declaration.bindings?.runtimeAgent;
+	if (runtimeAgent === void 0) return null;
+	await inspectClaudeAgentSdkPackage(session, runtimeAgent.path, evidence, diagnostics, agent.id);
+	if (!isSupportedTypeScriptSourcePath(runtimeAgent.path)) return null;
+	evidence.push(createClaudeAgentSdkEvidence({
+		agentId: agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: { language: "typescript" },
+		kind: "language",
+		references: [runtimeAgent.symbol === void 0 ? { path: runtimeAgent.path } : {
+			path: runtimeAgent.path,
+			symbol: runtimeAgent.symbol
+		}],
+		runtimeName: null,
+		source: CLAUDE_AGENT_SDK_ADAPTER_ID
+	}));
+	if (runtimeAgent.symbol === void 0) return null;
+	const analysis = await analyzeClaudeAgentSdkBoundReference(session, runtimeAgent, diagnostics, agent.id);
+	if (analysis === null) return null;
+	if (!analysis.exports.has(runtimeAgent.symbol)) {
+		addClaudeAgentSdkDiagnostic(diagnostics, "CLAUDE_AGENT_SDK_RUNTIME_AGENT_SYMBOL_NOT_FOUND", runtimeAgent.path, agent.id);
+		return null;
+	}
+	const queryResult = getClaudeAgentSdkQueryWrapper(analysis, runtimeAgent.symbol);
+	if (queryResult.kind === "present-supported") {
+		evidence.push(createClaudeAgentSdkEvidence({
+			agentId: agent.id,
+			capabilityId: null,
+			capabilityKind: null,
+			details: {
+				call: "query",
+				patternId: "direct-query-wrapper"
+			},
+			kind: "runtime-pattern",
+			references: [{
+				path: runtimeAgent.path,
+				symbol: runtimeAgent.symbol
+			}],
+			runtimeName: isClaudeAgentSdkMachineString(runtimeAgent.symbol) ? runtimeAgent.symbol : null,
+			source: CLAUDE_AGENT_SDK_ADAPTER_ID
+		}));
+		return Object.freeze({
+			agent,
+			analysis,
+			kind: "query-wrapper",
+			wrapper: queryResult.wrapper
+		});
+	}
+	const definitionResult = getClaudeAgentSdkAgentDefinition(analysis, runtimeAgent.symbol);
+	if (definitionResult.kind !== "present-supported") return null;
+	const definition = applyClaudeAgentSdkAgentMutations(analysis, definitionResult.definition, collectClaudeAgentSdkAgentDefinitionReferences(analysis));
+	evidence.push(createClaudeAgentSdkEvidence({
+		agentId: agent.id,
+		capabilityId: null,
+		capabilityKind: null,
+		details: { patternId: "programmatic-agent-definition" },
+		kind: "agent-definition",
+		references: [{
+			path: runtimeAgent.path,
+			symbol: runtimeAgent.symbol
+		}],
+		runtimeName: isClaudeAgentSdkMachineString(runtimeAgent.symbol) ? runtimeAgent.symbol : null,
+		source: CLAUDE_AGENT_SDK_ADAPTER_ID
+	}));
+	return Object.freeze({
+		agent,
+		analysis,
+		definition,
+		kind: "programmatic-agent-definition"
+	});
+};
+/**
+* Inspects all scoped Claude Agent SDK agents through one deterministic 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.
+* - 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 inspectClaudeAgentSdk = async (context) => {
+	context.signal?.throwIfAborted();
+	const session = createClaudeAgentSdkInspectionSession(context);
+	const evidence = [];
+	const diagnostics = [];
+	const agents = [...context.agents].sort((left, right) => compareClaudeAgentSdkStrings(left.id, right.id));
+	const inspectedAgents = [];
+	for (const agent of agents) {
+		context.signal?.throwIfAborted();
+		const inspected = await inspectAgent(session, agent, evidence, diagnostics);
+		if (inspected !== null) inspectedAgents.push(inspected);
+	}
+	for (const inspected of inspectedAgents) {
+		context.signal?.throwIfAborted();
+		await inspectClaudeAgentSdkRelationships(session, inspected, evidence, diagnostics);
+		if (inspected.kind === "query-wrapper") await inspectClaudeAgentSdkHandoffs(context, session, inspected, evidence, diagnostics);
+	}
+	await inspectClaudeAgentSdkTools(session, inspectedAgents, evidence, diagnostics);
+	context.signal?.throwIfAborted();
+	return Object.freeze({
+		diagnostics: Object.freeze(diagnostics),
+		evidence: Object.freeze(evidence)
+	});
+};
+//#endregion
+//#region src/adapter/index.ts
+var claudeAgentSdkAdapter = Object.freeze({
+	id: CLAUDE_AGENT_SDK_ADAPTER_ID,
+	inspect: inspectClaudeAgentSdk,
+	supportedRepositoryFormatVersions: CLAUDE_AGENT_SDK_SUPPORTED_REPOSITORY_FORMAT_VERSIONS
+});
+//#endregion
+export { claudeAgentSdkAdapter };