@agentyx/core 0.6.0 → 0.8.0

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import { z } from "zod";
-import { access, readFile, readdir, realpath } from "node:fs/promises";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { readFileSync } from "node:fs";
+import { access, readFile, readdir, realpath, stat } from "node:fs/promises";
+import { delimiter, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { constants, readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { createHash } from "node:crypto";
 //#region src/errors.ts
@@ -96,6 +96,15 @@ var LocalSkillDirectoryError = class extends AgentyxError {
 		this.directory = directory;
 	}
 };
+/** Raised when a configured project-context path is missing or escapes the project. */
+var ProjectContextPathError = class extends AgentyxError {
+	path;
+	constructor(path, reason, options) {
+		super("project_context_path_error", `Invalid project context path "${path}": ${reason}.`, options);
+		this.name = "ProjectContextPathError";
+		this.path = path;
+	}
+};
 //#endregion
 //#region src/hook/schema.ts
 const HOOK_ACTIVATION_LEVELS = ["default", "optional"];
@@ -130,13 +139,15 @@ const MCP_CONTEXT_COSTS = [
 	"high"
 ];
 const mcpContextCostSchema = z.enum(MCP_CONTEXT_COSTS);
+const mcpRuntimeSchema = z.enum(["local", "may-download"]);
 const mcpServerNameSchema = z.string().min(1, "MCP server names must be non-empty strings.").regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "MCP server names must be lowercase kebab-case, for example \"context7\".");
 const mcpEnvReferenceSchema = z.strictObject({ fromEnv: z.string().trim().min(1, "Environment variable references must be non-empty strings.").regex(/^[A-Za-z_][A-Za-z0-9_]*$/, "Environment variable names must be valid shell names.") });
 const commonMcpServerDefinitionSchema = z.strictObject({
 	name: mcpServerNameSchema.describe("Unique MCP server identifier."),
 	description: z.string().trim().min(1, "MCP server descriptions must be non-empty strings."),
 	transport: z.enum(["stdio", "http"]),
-	contextCost: mcpContextCostSchema.describe("Qualitative context/tool-schema overhead classification; not token accounting.").optional()
+	contextCost: mcpContextCostSchema.describe("Qualitative context/tool-schema overhead classification; not token accounting.").optional(),
+	runtime: mcpRuntimeSchema.describe("Whether launching this server can fetch a package on first use; see MCP_RUNTIMES.").optional()
 });
 const explicitMcpServerReferenceSchema = z.strictObject({
 	name: mcpServerNameSchema.describe("MCP server identifier."),
@@ -278,6 +289,53 @@ const enabledCapabilityNameSchema = z.string().min(1, "Enabled capability names
 * every supported platform.
 */
 const skillDirectorySchema = z.string().min(1, "Skill directories must be non-empty strings.").regex(/^(?!\/)(?![A-Za-z]:)(?!.*(?:^|\/)\.\.(?:\/|$))[^\\\0]+$/, "Skill directories must be portable project-relative paths without parent traversal.");
+const projectIdSchema = z.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Project ids must be lowercase kebab-case identifiers.");
+const projectTextSchema = z.string().min(1, "Must not be blank.").refine((value) => value.trim().length > 0, "Must not be blank.").refine((value) => Array.from(value).every((character) => {
+	const codePoint = character.codePointAt(0) ?? 0;
+	return codePoint > 31 && (codePoint < 127 || codePoint > 159);
+}), "Must be single-line text without control characters.");
+const projectUrlSchema = z.string().url("Must be a valid URL.");
+const projectResourceNames = z.array(projectTextSchema).refine((items) => new Set(items).size === items.length, "Entries must be unique.");
+const projectDocsSchema = z.array(projectUrlSchema).refine((items) => new Set(items).size === items.length, "Documentation URLs must be unique.");
+const projectOwnsSchema = z.array(projectIdSchema).refine((items) => new Set(items).size === items.length, "Ownership entries must be unique.");
+const projectMetadataSchema = z.strictObject({
+	id: projectIdSchema.describe("Stable, human-authored project identifier in kebab-case."),
+	name: projectTextSchema.describe("Human-readable project name."),
+	description: projectTextSchema.optional().describe("Short description of this project."),
+	repository: projectUrlSchema.optional().describe("Repository URL; descriptive and never fetched."),
+	docs: projectDocsSchema.default([]).describe("Documentation URLs; descriptive only."),
+	mcp: projectResourceNames.default([]).describe("MCP server identifiers available to consult."),
+	owns: projectOwnsSchema.default([]).describe("Architectural capabilities owned by this project.")
+});
+const projectRelationTypeSchema = z.enum([
+	"uses",
+	"integrates",
+	"consumes",
+	"extends"
+]);
+const projectRelationSchema = z.strictObject({
+	id: projectIdSchema.describe("Stable identifier for the related project."),
+	name: projectTextSchema.describe("Human-readable related project name."),
+	type: projectRelationTypeSchema.describe("How the current project relates to this project."),
+	role: projectIdSchema.describe("Architectural role of the related project."),
+	repository: projectUrlSchema.optional().describe("Repository URL; descriptive and never fetched."),
+	docs: projectDocsSchema.default([]).describe("Documentation URLs; descriptive only."),
+	mcp: projectResourceNames.default([]).describe("MCP server identifiers available to consult."),
+	owns: projectOwnsSchema.default([]).describe("Architectural capabilities owned by this project."),
+	guidance: z.array(projectTextSchema).default([]).describe("Human-authored guidance for agents.")
+});
+const projectCommandSchema = z.strictObject({
+	command: projectTextSchema.describe("Suggested command; Agentyx never executes it."),
+	cwd: z.string().min(1).default(".").describe("Project-relative working directory.")
+});
+const projectContextSchema = z.strictObject({
+	commands: z.record(z.string().min(1).refine((name) => name.trim().length > 0, "Command names must not be blank."), projectCommandSchema).default({}),
+	areas: z.array(z.strictObject({
+		path: z.string().min(1),
+		purpose: projectTextSchema
+	})).default([]),
+	constraints: z.array(projectTextSchema).default([])
+}).describe("Explicit repository-local facts for the generated project context Skill.");
 /** The `.agentyx.json` project configuration. */
 const agentyxConfigSchema = z.strictObject({
 	$schema: z.string().min(1, "$schema must be a non-empty string.").describe("Optional path or URL to the Agentyx JSON Schema.").optional(),
@@ -286,7 +344,45 @@ const agentyxConfigSchema = z.strictObject({
 	targets: z.array(agentyxTargetSchema).describe("Coding-agent providers this project targets.").default([]),
 	skillDirectories: z.array(skillDirectorySchema).describe("Project-relative roots containing local Agent Skills.").optional(),
 	localPacks: z.array(packDefinitionSchema).describe("Project-owned packs that can reference built-in or local Skills.").optional(),
-	trustedSources: z.array(trustedSourceReferenceSchema).describe("Pinned local checkouts of known external skill/plugin sources.").optional()
+	trustedSources: z.array(trustedSourceReferenceSchema).describe("Pinned local checkouts of known external skill/plugin sources.").optional(),
+	project: projectMetadataSchema.optional().describe("Identity and ownership for this project."),
+	relations: z.array(projectRelationSchema).optional().describe("Direct architectural relationships."),
+	context: projectContextSchema.optional()
+}).superRefine((config, context) => {
+	const relations = config.relations ?? [];
+	if (relations.length > 0 && config.project === void 0) context.addIssue({
+		code: "custom",
+		path: ["project"],
+		message: "Project metadata is required when relations are configured."
+	});
+	const ids = /* @__PURE__ */ new Set();
+	for (const [index, relation] of relations.entries()) {
+		if (config.project?.id === relation.id) context.addIssue({
+			code: "custom",
+			path: [
+				"relations",
+				index,
+				"id"
+			],
+			message: "A project cannot relate to itself."
+		});
+		if (ids.has(relation.id)) context.addIssue({
+			code: "custom",
+			path: [
+				"relations",
+				index,
+				"id"
+			],
+			message: "Related project ids must be unique."
+		});
+		ids.add(relation.id);
+	}
+	const areaPaths = config.context?.areas.map((area) => area.path) ?? [];
+	if (new Set(areaPaths).size !== areaPaths.length) context.addIssue({
+		code: "custom",
+		path: ["context", "areas"],
+		message: "Area paths must be unique."
+	});
 });
 //#endregion
 //#region src/config/json-schema.ts
@@ -357,6 +453,23 @@ function isFileNotFound(cause) {
 	return cause instanceof Error && cause.code === "ENOENT";
 }
 //#endregion
+//#region src/assets.ts
+/**
+* Location of the non-code assets that ship with `@agentyx/core`.
+*
+* **This module must stay directly under `src/`.** The path is derived from
+* `import.meta.url` rather than the working directory, and `src/assets.ts` and
+* the bundled `dist/index.mjs` sit at the same depth below the package root, so
+* one relative path is correct both in development and in the published
+* package. Moving this file into a subdirectory breaks built-in skill loading;
+* `packages/core/test/built-in-skills.test.ts` guards against that.
+*
+* `skills/` is listed in the package's `files`, so it is published alongside
+* `dist/`.
+*/
+const BUILT_IN_SKILLS_PATH = fileURLToPath(new URL("../skills", import.meta.url));
+const PROJECT_CONTEXT_TEMPLATE_PATH = fileURLToPath(new URL("../templates/project-context.md", import.meta.url));
+//#endregion
 //#region src/pack/errors.ts
 /** Raised when a requested pack is not present in the registry. */
 var UnknownPackError = class extends AgentyxError {
@@ -611,22 +724,6 @@ const builtInPacks = [
 /** The registry used by default when no explicit registry is supplied. */
 const builtInPackRegistry = createPackRegistry(builtInPacks);
 //#endregion
-//#region src/assets.ts
-/**
-* Location of the non-code assets that ship with `@agentyx/core`.
-*
-* **This module must stay directly under `src/`.** The path is derived from
-* `import.meta.url` rather than the working directory, and `src/assets.ts` and
-* the bundled `dist/index.mjs` sit at the same depth below the package root, so
-* one relative path is correct both in development and in the published
-* package. Moving this file into a subdirectory breaks built-in skill loading;
-* `packages/core/test/built-in-skills.test.ts` guards against that.
-*
-* `skills/` is listed in the package's `files`, so it is published alongside
-* `dist/`.
-*/
-const BUILT_IN_SKILLS_PATH = fileURLToPath(new URL("../skills", import.meta.url));
-//#endregion
 //#region src/skill/errors.ts
 /**
 * Raised when a pack references a skill the registry does not know.
@@ -965,18 +1062,70 @@ function getTrustedSourceDefinition(source, registry = knownTrustedSourceRegistr
 async function loadAgentyxProject(projectPath = process.cwd()) {
 	const projectDir = resolve(projectPath);
 	const config = await loadAgentyxConfig(projectDir);
+	await validateContextPaths(projectDir, config.context);
 	for (const source of config.trustedSources ?? []) getTrustedSourceDefinition(source);
 	const localSources = await loadLocalSkillSources(projectDir, config.skillDirectories ?? []);
-	const skillRegistry = createSkillRegistry([...builtInSkillRegistry.names.map((name) => ({
-		name,
-		load: () => builtInSkillRegistry.get(name)
-	})), ...localSources]);
+	if (localSources.some((source) => source.name === "agentyx-project-context")) throw new DuplicateSkillError("agentyx-project-context");
+	const generatedSources = config.project !== void 0 || config.context !== void 0 && hasContext(config.context) ? [createProjectContextSkill(config.project, config.relations ?? [], config.context)] : [];
+	const skillRegistry = createSkillRegistry([
+		...builtInSkillRegistry.names.map((name) => ({
+			name,
+			load: () => builtInSkillRegistry.get(name)
+		})),
+		...localSources,
+		...generatedSources
+	]);
 	return {
 		config,
 		packRegistry: config.localPacks === void 0 ? builtInPackRegistry : createPackRegistry([...builtInPacks, ...config.localPacks]),
-		skillRegistry
+		skillRegistry,
+		graph: config.project === void 0 ? void 0 : {
+			project: config.project,
+			relations: config.relations ?? []
+		}
 	};
 }
+function createProjectContextSkill(project, relations, context) {
+	return {
+		name: "agentyx-project-context",
+		load: () => {
+			const template = readFileSync(PROJECT_CONTEXT_TEMPLATE_PATH, "utf8").trim();
+			const data = JSON.stringify({
+				project,
+				relations,
+				context
+			}, null, 2);
+			const longestFence = Math.max(0, ...Array.from(data.matchAll(/`+/g), (match) => match[0].length));
+			const fence = "`".repeat(Math.max(3, longestFence + 1));
+			return {
+				name: "agentyx-project-context",
+				description: "Repository facts and direct architectural relationships.",
+				content: template.replace("{{PROJECT_FACTS}}", `${fence}json\n${data}\n${fence}`)
+			};
+		}
+	};
+}
+function hasContext(context) {
+	return Object.keys(context.commands).length > 0 || context.areas.length > 0 || context.constraints.length > 0;
+}
+async function validateContextPaths(projectDir, context) {
+	if (context === void 0) return;
+	const paths = [...Object.values(context.commands).map(({ cwd }) => cwd), ...context.areas.map(({ path }) => path)];
+	const projectRealPath = await realpath(projectDir);
+	for (const path of paths) {
+		if (/^(?:\/|[A-Za-z]:)|\\|(?:^|\/)\.\.(?:\/|$)/.test(path)) throw new ProjectContextPathError(path, "it must be project-relative and cannot traverse parents");
+		const resolvedPath = resolve(projectDir, path);
+		let resolvedRealPath;
+		try {
+			resolvedRealPath = await realpath(resolvedPath);
+			if (!(await stat(resolvedRealPath)).isDirectory()) throw new ProjectContextPathError(path, "it must name a directory");
+		} catch (cause) {
+			if (cause instanceof ProjectContextPathError) throw cause;
+			throw new ProjectContextPathError(path, "it does not exist or cannot be read", cause instanceof Error ? { cause } : void 0);
+		}
+		if (!isInside$1(resolvedRealPath, projectRealPath)) throw new ProjectContextPathError(path, "it resolves outside the project");
+	}
+}
 async function loadLocalSkillSources(projectDir, directories) {
 	const projectRealPath = await realpath(projectDir);
 	const sources = [];
@@ -1116,6 +1265,7 @@ const builtInHookRegistry = createHookRegistry([{
 		event: "SessionStart",
 		command: "npx",
 		args: [
+			"--no-install",
 			"agentyx",
 			"doctor",
 			"--hook"
@@ -1245,7 +1395,8 @@ function createMcpServerRegistry(sources) {
 				name: server.name,
 				description: server.description,
 				transport: server.transport,
-				contextCost: server.contextCost
+				contextCost: server.contextCost,
+				runtime: server.runtime
 			};
 		}),
 		get
@@ -1259,6 +1410,7 @@ const builtInMcpServerRegistry = createMcpServerRegistry([
 			description: "Fetch up-to-date library documentation from Context7.",
 			transport: "http",
 			contextCost: "medium",
+			runtime: "local",
 			url: "https://mcp.context7.com/mcp"
 		})
 	},
@@ -1269,8 +1421,9 @@ const builtInMcpServerRegistry = createMcpServerRegistry([
 			description: "Automate and inspect browsers through Playwright MCP.",
 			transport: "stdio",
 			contextCost: "high",
+			runtime: "may-download",
 			command: "npx",
-			args: ["@playwright/mcp@latest"]
+			args: ["@playwright/mcp@0.0.81"]
 		})
 	},
 	{
@@ -1280,6 +1433,7 @@ const builtInMcpServerRegistry = createMcpServerRegistry([
 			description: "Structural code-intelligence MCP backed by a persistent code knowledge graph.",
 			transport: "stdio",
 			contextCost: "high",
+			runtime: "local",
 			command: "codebase-memory-mcp"
 		})
 	},
@@ -1290,6 +1444,7 @@ const builtInMcpServerRegistry = createMcpServerRegistry([
 			description: "Read repositories, issues, pull requests and workflow runs on GitHub.",
 			transport: "http",
 			contextCost: "high",
+			runtime: "local",
 			url: "https://api.githubcopilot.com/mcp/"
 		})
 	},
@@ -1300,6 +1455,7 @@ const builtInMcpServerRegistry = createMcpServerRegistry([
 			description: "Inspect production issues, events and stack traces recorded by Sentry.",
 			transport: "http",
 			contextCost: "medium",
+			runtime: "local",
 			url: "https://mcp.sentry.dev/mcp"
 		})
 	},
@@ -1310,8 +1466,9 @@ const builtInMcpServerRegistry = createMcpServerRegistry([
 			description: "Record performance traces and inspect pages through Chrome DevTools.",
 			transport: "stdio",
 			contextCost: "high",
+			runtime: "may-download",
 			command: "npx",
-			args: ["-y", "chrome-devtools-mcp@latest"]
+			args: ["-y", "chrome-devtools-mcp@1.9.0"]
 		})
 	},
 	{
@@ -1321,8 +1478,9 @@ const builtInMcpServerRegistry = createMcpServerRegistry([
 			description: "Inspect and query Supabase project schemas, tables and logs.",
 			transport: "stdio",
 			contextCost: "high",
+			runtime: "may-download",
 			command: "npx",
-			args: ["-y", "@supabase/mcp-server-supabase@latest"],
+			args: ["-y", "@supabase/mcp-server-supabase@0.13.0"],
 			env: { SUPABASE_ACCESS_TOKEN: { fromEnv: "SUPABASE_ACCESS_TOKEN" } }
 		})
 	}
@@ -1519,7 +1677,7 @@ function resolveAgentyxConfig(config, registry = builtInPackRegistry, skillRegis
 	return {
 		requestedPacks,
 		resolvedPacks,
-		skills: collectPackSkills(resolvedPacks, registry, skillRegistry),
+		skills: unique([...collectPackSkills(resolvedPacks, registry, skillRegistry), ...config.project !== void 0 || (config.relations?.length ?? 0) > 0 || hasProjectContext(config.context) ? ["agentyx-project-context"] : []]),
 		declaredMcpServers,
 		mcpServers: filterEffectiveMcpServers(declaredMcpServers, config.enable),
 		declaredTools,
@@ -1530,6 +1688,12 @@ function resolveAgentyxConfig(config, registry = builtInPackRegistry, skillRegis
 		targets: [...config.targets]
 	};
 }
+function hasProjectContext(context) {
+	return context !== void 0 && (Object.keys(context.commands).length > 0 || context.areas.length > 0 || context.constraints.length > 0);
+}
+function unique(values) {
+	return [...new Set(values)];
+}
 //#endregion
 //#region src/manifest/errors.ts
 /** Raised when `.agentyx.lock.json` is not valid JSON. */
@@ -1740,13 +1904,92 @@ function getCoreStatus() {
 	return "ready";
 }
 //#endregion
-//#region src/project/detector.ts
+//#region src/project/executable.ts
+/** Whether `command` resolves to an executable file, via `PATH` unless it already contains a `/`. */
+async function isExecutableOnPath(command) {
+	if (command.includes("/")) return isFileExecutable(command);
+	for (const directory of (process.env.PATH ?? "").split(delimiter)) {
+		if (directory.length === 0) continue;
+		if (await isFileExecutable(`${directory}/${command}`)) return true;
+	}
+	return false;
+}
+async function isFileExecutable(path) {
+	try {
+		await access(path, constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+//#endregion
+//#region src/project/signals.ts
 const PACKAGE_MANAGERS = [
 	"pnpm",
 	"npm",
 	"yarn",
 	"bun"
 ];
+/** Package name patterns matched exactly, or as a `@scope/*` prefix. */
+const TEST_FRAMEWORK_PATTERNS = [
+	"vitest",
+	"jest",
+	"@jest/*",
+	"@playwright/test",
+	"cypress",
+	"karma"
+];
+const BROWSER_TESTING_PATTERNS = ["@playwright/test", "cypress"];
+const OBSERVABILITY_PATTERNS = ["@sentry/*", "@opentelemetry/*"];
+const DATA_TOOLING_PATTERNS = [
+	"@supabase/*",
+	"drizzle-orm",
+	"prisma",
+	"@prisma/client",
+	"typeorm",
+	"sequelize"
+];
+const ACCESSIBILITY_PATTERNS = [
+	"axe-core",
+	"@axe-core/*",
+	"pa11y"
+];
+const DEPENDENCY_FIELDS = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
+];
+const CONTAINER_IGNORED = /* @__PURE__ */ new Set([
+	"node_modules",
+	".git",
+	"dist",
+	"build",
+	"coverage"
+]);
+/** Extensions counted as source files by the bounded repository-size scan. */
+const SOURCE_FILE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".vue",
+	".svelte",
+	".py",
+	".go",
+	".rs",
+	".java",
+	".kt",
+	".rb",
+	".php",
+	".css",
+	".scss",
+	".html"
+]);
+/** Maximum directory entries visited by `scanRepositorySize`, regardless of match. */
+const REPOSITORY_SCAN_ENTRY_LIMIT = 5e3;
 const lockfileManagers = /* @__PURE__ */ new Map([
 	["pnpm-lock.yaml", "pnpm"],
 	["package-lock.json", "npm"],
@@ -1754,52 +1997,142 @@ const lockfileManagers = /* @__PURE__ */ new Map([
 	["bun.lock", "bun"],
 	["bun.lockb", "bun"]
 ]);
-async function detectProject(projectDir) {
+/** Gathers every project signal with a bounded, cheap set of reads. */
+async function collectProjectSignals(projectDir) {
 	const packageJsonPath = join(projectDir, "package.json");
-	const packageJson = await readPackageJson(packageJsonPath);
-	const packageManager = await detectPackageManager(projectDir, packageJson.data);
-	const detectedPacks = await detectPacks(projectDir, packageJson.data);
+	const packageJsonResult = await readPackageJson(packageJsonPath);
+	const packageJson = packageJsonResult.data;
+	const [packageManager, containers, ci, monorepo, repositorySize, tsconfig, rtkAvailable] = await Promise.all([
+		detectPackageManager(projectDir, packageJson),
+		detectContainerFiles(projectDir),
+		detectCiFiles(projectDir),
+		detectMonorepo(projectDir, packageJson),
+		scanRepositorySize(projectDir),
+		exists(join(projectDir, "tsconfig.json")),
+		isExecutableOnPath(builtInToolRegistry.get("rtk").command)
+	]);
 	return {
 		projectDir,
 		packageJson: {
-			present: packageJson.present,
-			valid: packageJson.valid,
+			present: packageJsonResult.present,
+			valid: packageJsonResult.valid,
 			path: packageJsonPath,
-			name: getString(packageJson.data?.name),
-			packageManager: getString(packageJson.data?.packageManager),
-			error: packageJson.error
+			name: getString(packageJson?.name),
+			packageManager: getString(packageJson?.packageManager),
+			scripts: getStringRecord(packageJson?.scripts),
+			error: packageJsonResult.error
 		},
 		packageManager,
-		detectedPacks,
-		recommendedPacks: recommendPacks(detectedPacks)
+		typescript: {
+			dependency: findDependency(packageJson, "typescript"),
+			tsconfig
+		},
+		angular: findDependency(packageJson, "@angular/core"),
+		testFrameworks: findAnyDependency(packageJson, TEST_FRAMEWORK_PATTERNS),
+		browserTesting: findAnyDependency(packageJson, BROWSER_TESTING_PATTERNS),
+		observability: findAnyDependency(packageJson, OBSERVABILITY_PATTERNS),
+		dataTooling: findAnyDependency(packageJson, DATA_TOOLING_PATTERNS),
+		accessibilityTooling: findAnyDependency(packageJson, ACCESSIBILITY_PATTERNS),
+		containers,
+		ci,
+		monorepo,
+		repositorySize,
+		localTools: { rtkAvailable }
 	};
 }
-function buildAgentyxConfig(input) {
+/**
+* Counts source-like files under a bounded traversal, ignoring dependency, VCS and build output
+* directories. Stops after visiting `entryLimit` directory entries — cheap even on a monorepo — and
+* reports `capped` so callers never mistake a partial scan for a complete one.
+*/
+async function scanRepositorySize(projectDir, options = {}) {
+	const entryLimit = options.entryLimit ?? 5e3;
+	const directories = [projectDir];
+	let filesScanned = 0;
+	let entriesVisited = 0;
+	let capped = false;
+	while (directories.length > 0 && !capped) {
+		const directory = directories.shift();
+		if (directory === void 0) break;
+		let entries;
+		try {
+			entries = await readdir(directory, { withFileTypes: true });
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (entriesVisited >= entryLimit) {
+				capped = true;
+				break;
+			}
+			entriesVisited += 1;
+			if (entry.isDirectory()) {
+				if (entry.name.startsWith(".") || CONTAINER_IGNORED.has(entry.name)) continue;
+				directories.push(join(directory, entry.name));
+			} else if (entry.isFile() && SOURCE_FILE_EXTENSIONS.has(extname(entry.name))) filesScanned += 1;
+		}
+	}
 	return {
-		packs: [...input.packs],
-		enable: [...input.enable ?? []],
-		targets: [...input.targets]
+		filesScanned,
+		capped
 	};
 }
-function formatAgentyxConfig(config) {
-	return `${JSON.stringify(config, null, 2)}\n`;
+function findDependency(packageJson, pattern) {
+	for (const field of DEPENDENCY_FIELDS) {
+		const value = packageJson?.[field];
+		if (!isRecord(value)) continue;
+		if (pattern.endsWith("/*")) {
+			const prefix = pattern.slice(0, -1);
+			const name = Object.keys(value).find((key) => key.startsWith(prefix));
+			if (name !== void 0) return {
+				dependency: name,
+				field
+			};
+			continue;
+		}
+		if (pattern in value) return {
+			dependency: pattern,
+			field
+		};
+	}
 }
-function recommendPacks(detectedPacks) {
-	if (detectedPacks.includes("angular")) return [
-		"technical",
-		"typescript",
-		"angular"
-	];
-	if (detectedPacks.includes("typescript")) return ["technical", "typescript"];
-	return ["technical"];
+function findAnyDependency(packageJson, patterns) {
+	const matches = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const pattern of patterns) {
+		const match = findDependency(packageJson, pattern);
+		if (match !== void 0 && !seen.has(match.dependency)) {
+			seen.add(match.dependency);
+			matches.push(match);
+		}
+	}
+	return matches;
+}
+async function detectContainerFiles(projectDir) {
+	const [dockerfile, dockerCompose, compose] = await Promise.all([
+		exists(join(projectDir, "Dockerfile")),
+		exists(join(projectDir, "docker-compose.yml")),
+		exists(join(projectDir, "compose.yml"))
+	]);
+	return {
+		dockerfile,
+		compose: dockerCompose || compose
+	};
 }
-async function detectPacks(projectDir, packageJson) {
-	const packs = [];
-	const dependencies = collectDependencies(packageJson);
-	const hasAngular = dependencies.has("@angular/core");
-	if (dependencies.has("typescript") || await exists(join(projectDir, "tsconfig.json")) || hasAngular) packs.push("typescript");
-	if (hasAngular) packs.push("angular");
-	return packs;
+async function detectCiFiles(projectDir) {
+	return { githubActions: await exists(join(projectDir, ".github", "workflows")) };
+}
+async function detectMonorepo(projectDir, packageJson) {
+	const markers = [];
+	if (await exists(join(projectDir, "pnpm-workspace.yaml"))) markers.push("pnpm-workspace.yaml");
+	if (await exists(join(projectDir, "turbo.json"))) markers.push("turbo.json");
+	if (await exists(join(projectDir, "nx.json"))) markers.push("nx.json");
+	const workspaces = packageJson?.workspaces;
+	if (Array.isArray(workspaces) || isRecord(workspaces)) markers.push("package.json workspaces");
+	return {
+		detected: markers.length > 0,
+		markers
+	};
 }
 async function detectPackageManager(projectDir, packageJson) {
 	const lockfiles = [];
@@ -1862,16 +2195,6 @@ async function readPackageJson(path) {
 		};
 	}
 }
-function collectDependencies(packageJson) {
-	const dependencies = /* @__PURE__ */ new Set();
-	for (const field of [
-		packageJson?.dependencies,
-		packageJson?.devDependencies,
-		packageJson?.peerDependencies,
-		packageJson?.optionalDependencies
-	]) if (isRecord(field)) for (const name of Object.keys(field)) dependencies.add(name);
-	return dependencies;
-}
 function parsePackageManagerName(value) {
 	const name = value?.split("@")[0];
 	return PACKAGE_MANAGERS.includes(name) ? name : void 0;
@@ -1879,6 +2202,10 @@ function parsePackageManagerName(value) {
 function getString(value) {
 	return typeof value === "string" ? value : void 0;
 }
+function getStringRecord(value) {
+	if (!isRecord(value)) return {};
+	return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"));
+}
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1895,6 +2222,205 @@ function isNotFound(cause) {
 	return cause instanceof Error && cause.code === "ENOENT";
 }
 //#endregion
+//#region src/project/detector.ts
+/**
+* Factual project detection only. It gathers `ProjectSignals` and never decides which packs or
+* capabilities fit — that policy lives in `recommendCapabilities`, kept separate so each half stays
+* independently testable.
+*/
+async function detectProject(projectDir) {
+	const signals = await collectProjectSignals(projectDir);
+	return {
+		projectDir,
+		packageJson: signals.packageJson,
+		packageManager: signals.packageManager,
+		signals
+	};
+}
+function buildAgentyxConfig(input) {
+	return {
+		packs: [...input.packs],
+		enable: [...input.enable ?? []],
+		targets: [...input.targets]
+	};
+}
+function formatAgentyxConfig(config) {
+	return `${JSON.stringify(config, null, 2)}\n`;
+}
+//#endregion
+//#region src/project/recommend.ts
+const RECOMMENDATION_CONFIDENCES = ["high", "medium"];
+/**
+* Heuristic thresholds for the `codebase-memory` capability suggestion, in scanned source files.
+* These are approximate signals, not exact token accounting, and a monorepo is treated as already
+* complex enough to lower the bar.
+*/
+const CODEBASE_MEMORY_FILE_THRESHOLD = 2e3;
+const CODEBASE_MEMORY_MONOREPO_FILE_THRESHOLD = 800;
+/**
+* Applies conservative, deterministic policy on top of `ProjectSignals`. This is the only place
+* that turns an observed fact into a product suggestion — `ProjectSignals` stays fact-only so it
+* can be tested independently of pack names or capability policy.
+*
+* Never enables anything and never touches the filesystem: the caller decides what, if anything,
+* to do with the result.
+*/
+function recommendCapabilities(signals, options = {}) {
+	const packs = recommendPacks(signals);
+	const configuredPacks = options.configuredPacks ?? [];
+	return {
+		packs,
+		capabilities: recommendOptionalCapabilities(signals, /* @__PURE__ */ new Set([...packs.map((pack) => pack.name), ...configuredPacks]), configuredPacks)
+	};
+}
+function recommendPacks(signals) {
+	const packs = [];
+	if (signals.packageJson.present) packs.push(packRecommendation("technical", "high", ["package.json detected — baseline engineering practices apply to any software project."]));
+	const typescriptReasons = [...signals.typescript.dependency !== void 0 ? [dependencyReason("TypeScript", signals.typescript.dependency)] : [], ...signals.typescript.tsconfig ? ["tsconfig.json detected."] : []];
+	if (typescriptReasons.length > 0) packs.push(packRecommendation("typescript", "high", typescriptReasons));
+	if (signals.angular !== void 0) packs.push(packRecommendation("angular", "high", [dependencyReason("@angular/core", signals.angular)]));
+	const testingMatches = dedupeMatches([...signals.testFrameworks, ...signals.browserTesting]);
+	if (testingMatches.length > 0) packs.push(packRecommendation("testing", "high", testingMatches.map((match) => dependencyReason(match.dependency, match))));
+	const devopsReasons = [
+		...signals.containers.dockerfile ? ["Dockerfile detected."] : [],
+		...signals.containers.compose ? ["Container compose file detected."] : [],
+		...signals.ci.githubActions ? ["GitHub Actions workflow detected (.github/workflows)."] : []
+	];
+	if (devopsReasons.length > 0) packs.push(packRecommendation("devops", "high", devopsReasons));
+	if (signals.observability.length > 0) packs.push(packRecommendation("observability", "high", signals.observability.map((match) => dependencyReason(match.dependency, match))));
+	if (signals.dataTooling.length > 0) packs.push(packRecommendation("data", "high", signals.dataTooling.map((match) => dependencyReason(match.dependency, match))));
+	if (signals.accessibilityTooling.length > 0) packs.push(packRecommendation("accessibility", "high", signals.accessibilityTooling.map((match) => dependencyReason(match.dependency, match))));
+	return packs;
+}
+function recommendOptionalCapabilities(signals, activePacks, configuredPacks) {
+	const capabilities = [];
+	const playwrightMatch = signals.browserTesting.find((match) => match.dependency === "@playwright/test");
+	if (activePacks.has("testing") && playwrightMatch !== void 0) capabilities.push(capabilityRecommendation("playwright", "high", ["Playwright is already part of this project; browser MCP may be useful for interactive browser work."]));
+	if (signals.observability.find((match) => match.dependency.startsWith("@sentry/")) !== void 0) capabilities.push(capabilityRecommendation("sentry", "high", ["Sentry is already configured as a dependency."]));
+	if (signals.dataTooling.find((match) => match.dependency.startsWith("@supabase/")) !== void 0) capabilities.push(capabilityRecommendation("supabase", "high", ["Supabase is already configured as a dependency."]));
+	if (configuredPacks.includes("efficiency") && signals.localTools.rtkAvailable) capabilities.push(capabilityRecommendation("rtk", "high", ["RTK is already installed locally."]));
+	const sizeThreshold = signals.monorepo.detected ? 800 : CODEBASE_MEMORY_FILE_THRESHOLD;
+	if (signals.repositorySize.filesScanned >= sizeThreshold || signals.repositorySize.capped) capabilities.push(capabilityRecommendation("codebase-memory", "medium", [repositorySizeReason(signals)]));
+	return capabilities;
+}
+function repositorySizeReason(signals) {
+	const { filesScanned, capped } = signals.repositorySize;
+	const scope = signals.monorepo.detected ? " across this monorepo" : "";
+	return `Heuristic: found ${capped ? `at least ${filesScanned} source files (the scan was capped before finishing)` : `${filesScanned} source files`}${scope}. A persistent codebase-memory MCP may reduce repeated full-tree reads on a repository this size — this is an approximate signal, not an exact token measurement.`;
+}
+function packRecommendation(name, confidence, reasons) {
+	return {
+		kind: "pack",
+		name,
+		confidence,
+		reasons
+	};
+}
+/** Provenance comes from the pack registry itself — never a second, hand-maintained capability map. */
+function capabilityRecommendation(name, confidence, reasons) {
+	return {
+		kind: "capability",
+		name,
+		confidence,
+		reasons,
+		contributedBy: packsDeclaringOptionalCapability(name)
+	};
+}
+function packsDeclaringOptionalCapability(name) {
+	const packs = [];
+	for (const pack of builtInPackRegistry.values()) if (pack.mcpServers.some((server) => server.name === name && server.activation === "optional") || pack.tools.some((tool) => tool.name === name && tool.activation === "optional") || pack.hooks.some((hook) => hook.name === name && hook.activation === "optional")) packs.push(pack.name);
+	return packs;
+}
+function dependencyReason(label, match) {
+	return label === match.dependency ? `Detected ${match.dependency} in ${match.field}.` : `Detected ${label} (${match.dependency}) in ${match.field}.`;
+}
+function dedupeMatches(matches) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const match of matches) if (!seen.has(match.dependency)) {
+		seen.add(match.dependency);
+		result.push(match);
+	}
+	return result;
+}
+//#endregion
+//#region src/project-graph.ts
+var ProjectGraphNotConfiguredError = class extends AgentyxError {
+	constructor() {
+		super("project_graph_not_configured", "Project Graph requires a project object in .agentyx.json.");
+		this.name = "ProjectGraphNotConfiguredError";
+	}
+};
+function createProjectGraph(project, relations) {
+	return {
+		project,
+		relations: [...relations]
+	};
+}
+function renderProjectGraphText(graph) {
+	const rows = graph.relations.map((relation, index) => {
+		return `${index === graph.relations.length - 1 ? "└──" : "├──"} ${relation.type} [${relation.role}] → ${relation.name}`;
+	});
+	return [graph.project.name, ...rows].join("\n");
+}
+function renderProjectGraphJson(graph) {
+	return `${JSON.stringify(graph, null, 2)}\n`;
+}
+function renderProjectGraphMermaid(graph) {
+	const current = mermaidId(graph.project.id);
+	return ["graph LR", ...graph.relations.map((relation) => `  ${current}["${mermaidText(graph.project.name)}"] -->|${mermaidText(`${relation.type}: ${relation.role}`)}| ${mermaidId(relation.id)}["${mermaidText(relation.name)}"]`)].join("\n");
+}
+function renderProjectGraphSvg(graph) {
+	const width = 720;
+	const rowHeight = 92;
+	const height = Math.max(180, 100 + graph.relations.length * rowHeight);
+	const centerX = 360;
+	const centerY = height / 2;
+	const svg = [
+		`<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${width} ${height}" role="img" aria-labelledby="title desc">`,
+		`<title id="title">${xml(graph.project.name)} project graph</title>`,
+		`<desc id="desc">Direct architectural relationships from ${xml(graph.project.name)}.</desc>`,
+		"<defs><marker id=\"arrow\" markerWidth=\"10\" markerHeight=\"8\" refX=\"9\" refY=\"4\" orient=\"auto\"><path d=\"M0,0 L10,4 L0,8 z\" fill=\"#526579\"/></marker></defs>"
+	];
+	graph.relations.forEach((relation, index) => {
+		const y = 54 + index * rowHeight;
+		const right = index % 2 === 0;
+		const x = right ? 500 : 0;
+		const edgeStart = right ? 488 : 232;
+		const edgeEnd = right ? x : x + 220;
+		svg.push(`<line x1="${edgeStart}" y1="${centerY}" x2="${edgeEnd}" y2="${y + 24}" stroke="#526579" stroke-width="2" marker-end="url(#arrow)"/>`);
+		svg.push(`<text x="${right ? 494 : 226}" y="${Math.round((centerY + y + 24) / 2) - 7}" class="edge">${xml(truncate(`${relation.type} · ${relation.role}`, 34))}</text>`);
+		svg.push(`<rect x="${x}" y="${y}" width="220" height="48" rx="10" class="node"/>`);
+		svg.push(`<text x="${x + 110}" y="${y + 30}" class="label">${xml(truncate(relation.name, 22))}</text>`);
+	});
+	svg.push(`<rect x="232" y="${centerY - 34}" width="256" height="68" rx="14" class="current"/>`);
+	svg.push(`<text x="${centerX}" y="${centerY + 6}" class="label">${xml(truncate(graph.project.name, 30))}</text>`);
+	svg.push("<style>text{font-family:system-ui,sans-serif}.node{fill:#fff;stroke:#8da0b3;stroke-width:2}.current{fill:#e8f2ff;stroke:#2563a5;stroke-width:3}.label{text-anchor:middle;font-size:16px;font-weight:600;fill:#172536}.edge{text-anchor:middle;font-size:12px;fill:#34495e;paint-order:stroke;stroke:#fff;stroke-width:5px;stroke-linejoin:round}</style>");
+	svg.push("</svg>");
+	return `${svg.join("\n")}\n`;
+}
+function findProjectCapabilityOwners(graph, capability) {
+	const owners = graph.relations.filter((relation) => relation.owns.includes(capability));
+	return {
+		capability,
+		currentProject: graph.project.owns.includes(capability) ? graph.project : void 0,
+		relatedProjects: owners
+	};
+}
+function xml(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;");
+}
+function mermaidText(value) {
+	return value.replaceAll("&", "&amp;").replaceAll("|", "&#124;").replaceAll("[", "&#91;").replaceAll("]", "&#93;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function mermaidId(value) {
+	return `node_${Array.from(value).map((char) => char.codePointAt(0)?.toString(16) ?? "0").join("")}`;
+}
+function truncate(value, limit) {
+	const characters = Array.from(value);
+	return characters.length > limit ? `${characters.slice(0, limit - 1).join("")}…` : value;
+}
+//#endregion
 //#region src/source/inspection.ts
 async function inspectTrustedSource(projectPath, reference) {
 	const definition = getTrustedSourceDefinition(reference);
@@ -1983,6 +2509,6 @@ function trustedSourceLoadError(sourceName, reason, cause) {
 	return new TrustedSourceLoadError(sourceName, reason, cause instanceof Error ? { cause } : void 0);
 }
 //#endregion
-export { AGENTYX_CONFIG_FILENAME, AGENTYX_CONFIG_SCHEMA_ID, AGENTYX_MANIFEST_FILENAME, AgentyxConfigNotFoundError, AgentyxConfigParseError, AgentyxConfigValidationError, AgentyxError, AgentyxManifestParseError, AgentyxManifestValidationError, CircularPackDependencyError, DuplicateHookError, DuplicateMcpServerError, DuplicatePackError, DuplicateSkillError, DuplicateToolError, DuplicateTrustedSourceError, HOOK_ACTIVATION_LEVELS, HOOK_EVENTS, INSTALL_MANIFEST_VERSION, InvalidHookError, InvalidMcpServerError, InvalidSkillError, InvalidToolError, LocalSkillDirectoryError, MCP_CAPABILITY_LEVELS, MCP_CONTEXT_COSTS, PACKAGE_MANAGERS, PACK_CATEGORIES, TOOL_ACTIVATION_LEVELS, TrustedSourceLoadError, UnknownEnabledCapabilityError, UnknownHookError, UnknownMcpServerError, UnknownPackError, UnknownSkillError, UnknownToolError, UnknownTrustedSourceError, agentyxConfigPath, agentyxConfigSchema, agentyxCoreName, agentyxManifestPath, agentyxTargetSchema, buildAgentyxConfig, buildAgentyxConfigJsonSchema, builtInHookNames, builtInHookRegistry, builtInMcpServerNames, builtInMcpServerRegistry, builtInPackRegistry, builtInPacks, builtInSkillNames, builtInSkillRegistry, builtInToolNames, builtInToolRegistry, codexPluginManifestSchema, collectPackHookReferences, collectPackHooks, collectPackMcpServerReferences, collectPackMcpServers, collectPackToolReferences, createHookRegistry, createMcpServerRegistry, createPackRegistry, createSkillRegistry, createToolRegistry, createTrustedSourceRegistry, detectProject, emptyInstallManifest, enabledCapabilityNameSchema, filterEffectiveHooks, filterEffectiveMcpServers, filterEffectiveTools, formatAgentyxConfig, formatInstallManifest, formatSkillMarkdown, getCoreStatus, getTrustedSourceDefinition, hashContent, hookActivationLevelSchema, hookDefinitionSchema, hookEventSchema, hookManifestEntrySchema, hookNameSchema, hookReferenceSchema, inspectTrustedSource, installManifestEntrySchema, installManifestSchema, knownTrustedSourceRegistry, knownTrustedSources, loadAgentyxConfig, loadAgentyxProject, loadInstallManifest, manifestEntriesByPath, mcpCapabilityLevelSchema, mcpContextCostSchema, mcpEnvReferenceSchema, mcpManifestEntrySchema, mcpServerDefinitionSchema, mcpServerReferenceSchema, packCategorySchema, packDefinitionSchema, packNameSchema, parseAgentyxConfig, parseInstallManifest, parseSkillMarkdown, resolveAgentyxConfig, resolvePackHookReferences, resolvePackHooks, resolvePackMcpServerReferences, resolvePackMcpServers, resolvePackSkills, resolvePackToolReferences, resolvePackTools, resolvePacks, skillDefinitionSchema, skillDirectorySchema, skillManifestEntrySchema, toolActivationLevelSchema, toolDefinitionSchema, toolNameSchema, toolReferenceSchema, trustedSourceDefinitionSchema, trustedSourceNameSchema, trustedSourcePathSchema, trustedSourceReferenceSchema, trustedSourceSkillSummarySchema };
+export { AGENTYX_CONFIG_FILENAME, AGENTYX_CONFIG_SCHEMA_ID, AGENTYX_MANIFEST_FILENAME, AgentyxConfigNotFoundError, AgentyxConfigParseError, AgentyxConfigValidationError, AgentyxError, AgentyxManifestParseError, AgentyxManifestValidationError, CODEBASE_MEMORY_FILE_THRESHOLD, CODEBASE_MEMORY_MONOREPO_FILE_THRESHOLD, CircularPackDependencyError, DuplicateHookError, DuplicateMcpServerError, DuplicatePackError, DuplicateSkillError, DuplicateToolError, DuplicateTrustedSourceError, HOOK_ACTIVATION_LEVELS, HOOK_EVENTS, INSTALL_MANIFEST_VERSION, InvalidHookError, InvalidMcpServerError, InvalidSkillError, InvalidToolError, LocalSkillDirectoryError, MCP_CAPABILITY_LEVELS, MCP_CONTEXT_COSTS, PACKAGE_MANAGERS, PACK_CATEGORIES, ProjectContextPathError, ProjectGraphNotConfiguredError, RECOMMENDATION_CONFIDENCES, REPOSITORY_SCAN_ENTRY_LIMIT, TOOL_ACTIVATION_LEVELS, TrustedSourceLoadError, UnknownEnabledCapabilityError, UnknownHookError, UnknownMcpServerError, UnknownPackError, UnknownSkillError, UnknownToolError, UnknownTrustedSourceError, agentyxConfigPath, agentyxConfigSchema, agentyxCoreName, agentyxManifestPath, agentyxTargetSchema, buildAgentyxConfig, buildAgentyxConfigJsonSchema, builtInHookNames, builtInHookRegistry, builtInMcpServerNames, builtInMcpServerRegistry, builtInPackRegistry, builtInPacks, builtInSkillNames, builtInSkillRegistry, builtInToolNames, builtInToolRegistry, codexPluginManifestSchema, collectPackHookReferences, collectPackHooks, collectPackMcpServerReferences, collectPackMcpServers, collectPackToolReferences, collectProjectSignals, createHookRegistry, createMcpServerRegistry, createPackRegistry, createProjectGraph, createSkillRegistry, createToolRegistry, createTrustedSourceRegistry, detectProject, emptyInstallManifest, enabledCapabilityNameSchema, filterEffectiveHooks, filterEffectiveMcpServers, filterEffectiveTools, findProjectCapabilityOwners, formatAgentyxConfig, formatInstallManifest, formatSkillMarkdown, getCoreStatus, getTrustedSourceDefinition, hashContent, hookActivationLevelSchema, hookDefinitionSchema, hookEventSchema, hookManifestEntrySchema, hookNameSchema, hookReferenceSchema, inspectTrustedSource, installManifestEntrySchema, installManifestSchema, isExecutableOnPath, knownTrustedSourceRegistry, knownTrustedSources, loadAgentyxConfig, loadAgentyxProject, loadInstallManifest, manifestEntriesByPath, mcpCapabilityLevelSchema, mcpContextCostSchema, mcpEnvReferenceSchema, mcpManifestEntrySchema, mcpServerDefinitionSchema, mcpServerReferenceSchema, packCategorySchema, packDefinitionSchema, packNameSchema, parseAgentyxConfig, parseInstallManifest, parseSkillMarkdown, projectContextSchema, projectMetadataSchema, projectRelationSchema, projectRelationTypeSchema, recommendCapabilities, renderProjectGraphJson, renderProjectGraphMermaid, renderProjectGraphSvg, renderProjectGraphText, resolveAgentyxConfig, resolvePackHookReferences, resolvePackHooks, resolvePackMcpServerReferences, resolvePackMcpServers, resolvePackSkills, resolvePackToolReferences, resolvePackTools, resolvePacks, scanRepositorySize, skillDefinitionSchema, skillDirectorySchema, skillManifestEntrySchema, toolActivationLevelSchema, toolDefinitionSchema, toolNameSchema, toolReferenceSchema, trustedSourceDefinitionSchema, trustedSourceNameSchema, trustedSourcePathSchema, trustedSourceReferenceSchema, trustedSourceSkillSummarySchema };
 
 //# sourceMappingURL=index.mjs.map