@agentyx/core 0.4.0 → 0.6.0

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { access, readFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
+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 { fileURLToPath } from "node:url";
 import { createHash } from "node:crypto";
@@ -87,6 +87,39 @@ var UnknownEnabledCapabilityError = class extends AgentyxError {
 		this.knownCapabilities = knownCapabilities;
 	}
 };
+/** Raised when a configured local Skill directory cannot be loaded safely. */
+var LocalSkillDirectoryError = class extends AgentyxError {
+	directory;
+	constructor(directory, reason, options) {
+		super("local_skill_directory_error", `Could not load local Skill directory "${directory}": ${reason}`, options);
+		this.name = "LocalSkillDirectoryError";
+		this.directory = directory;
+	}
+};
+//#endregion
+//#region src/hook/schema.ts
+const HOOK_ACTIVATION_LEVELS = ["default", "optional"];
+const hookActivationLevelSchema = z.enum(HOOK_ACTIVATION_LEVELS);
+const HOOK_EVENTS = ["SessionStart"];
+const hookEventSchema = z.enum(HOOK_EVENTS);
+const hookNameSchema = z.string().min(1, "Hook names must be non-empty strings.").regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Hook names must be lowercase kebab-case, for example \"session-doctor-bootstrap\".");
+const hookDefinitionSchema = z.strictObject({
+	name: hookNameSchema.describe("Unique hook identifier."),
+	description: z.string().trim().min(1, "Hook descriptions must be non-empty strings."),
+	event: hookEventSchema.describe("The provider lifecycle event this hook runs on."),
+	command: z.string().trim().min(1, "Hook command must be a non-empty string."),
+	args: z.array(z.string()).default([])
+});
+const hookReferenceSchema = z.union([hookNameSchema, z.strictObject({
+	name: hookNameSchema.describe("Hook identifier."),
+	activation: hookActivationLevelSchema.default("default")
+})]).transform((value) => typeof value === "string" ? {
+	name: value,
+	activation: "default"
+} : value).pipe(z.strictObject({
+	name: hookNameSchema.describe("Hook identifier."),
+	activation: hookActivationLevelSchema.describe("Whether this hook is active by default or explicit opt-in.")
+}));
 //#endregion
 //#region src/mcp/schema.ts
 const MCP_CAPABILITY_LEVELS = ["default", "optional"];
@@ -195,7 +228,41 @@ const packDefinitionSchema = z.strictObject({
 	description: z.string().min(1, "Pack descriptions must be non-empty when provided.").describe("Short human-readable summary of the pack.").optional(),
 	skills: z.array(skillNameSchema).describe("Skills this pack contributes, in declaration order.").default([]),
 	mcpServers: z.array(mcpServerReferenceSchema).describe("MCP servers this pack contributes, in declaration order.").default([]),
-	tools: z.array(toolReferenceSchema).describe("Local tools this pack contributes, in declaration order.").default([])
+	tools: z.array(toolReferenceSchema).describe("Local tools this pack contributes, in declaration order.").default([]),
+	hooks: z.array(hookReferenceSchema).describe("Provider lifecycle hooks this pack contributes, in declaration order.").default([])
+});
+//#endregion
+//#region src/source/schema.ts
+const trustedSourceNameSchema = z.string().min(1, "Trusted source names must be non-empty strings.").regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Trusted source names must be lowercase kebab-case, for example \"superpowers\".");
+const trustedSourcePathSchema = z.string().min(1, "Trusted source paths must be non-empty strings.").regex(/^(?!\/)(?![A-Za-z]:)(?!.*(?:^|\/)\.\.(?:\/|$))[^\\\0]+$/, "Trusted source paths must be portable project-relative paths without parent traversal.");
+const trustedSourceReferenceSchema = z.strictObject({
+	name: trustedSourceNameSchema.describe("Known trusted source identifier."),
+	path: trustedSourcePathSchema.describe("Project-relative checkout path for this source."),
+	ref: z.string().trim().min(1, "Trusted source refs must be non-empty strings.").describe("Reviewed immutable commit, signed tag or pinned release identifier.")
+});
+const trustedSourceDefinitionSchema = z.strictObject({
+	name: trustedSourceNameSchema,
+	displayName: z.string().min(1),
+	repository: z.string().url(),
+	type: z.literal("codex-plugin"),
+	manifestPath: z.string().min(1),
+	recommendedPath: trustedSourcePathSchema,
+	description: z.string().min(1),
+	installStatus: z.enum(["metadata-only", "installable"]),
+	installNote: z.string().min(1)
+});
+const codexPluginManifestSchema = z.object({
+	name: trustedSourceNameSchema,
+	version: z.string().min(1),
+	description: z.string().min(1),
+	repository: z.string().url(),
+	license: z.string().min(1),
+	skills: z.string().min(1)
+}).passthrough();
+const trustedSourceSkillSummarySchema = z.strictObject({
+	name: skillNameSchema,
+	description: z.string().min(1),
+	hasResources: z.boolean()
 });
 //#endregion
 //#region src/config/schema.ts
@@ -205,12 +272,21 @@ const packDefinitionSchema = z.strictObject({
 */
 const agentyxTargetSchema = z.string().min(1, "Targets must be non-empty strings.");
 const enabledCapabilityNameSchema = z.string().min(1, "Enabled capability names must be non-empty strings.").regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Enabled capability names must be lowercase kebab-case, for example \"rtk\".");
+/**
+* Portable project-relative path to a directory whose direct children are Agent Skills.
+* Backslashes, absolute paths and parent traversal are rejected so the same config is safe on
+* 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.");
 /** 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(),
 	packs: z.array(packNameSchema).describe("Capability packs this project selects.").default([]),
 	enable: z.array(enabledCapabilityNameSchema).describe("Optional capabilities to activate by explicit identifier.").default([]),
-	targets: z.array(agentyxTargetSchema).describe("Coding-agent providers this project targets.").default([])
+	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()
 });
 //#endregion
 //#region src/config/json-schema.ts
@@ -281,163 +357,6 @@ function isFileNotFound(cause) {
 	return cause instanceof Error && cause.code === "ENOENT";
 }
 //#endregion
-//#region src/mcp/errors.ts
-var UnknownMcpServerError = class extends AgentyxError {
-	serverName;
-	requiredBy;
-	knownServers;
-	constructor(serverName, requiredBy, knownServers) {
-		const origin = requiredBy === void 0 ? "" : ` (required by "${requiredBy}")`;
-		const known = knownServers.length > 0 ? [...knownServers].sort().join(", ") : "none";
-		super("unknown_mcp_server", `Unknown MCP server "${serverName}"${origin}. Known MCP servers: ${known}.`);
-		this.name = "UnknownMcpServerError";
-		this.serverName = serverName;
-		this.requiredBy = requiredBy;
-		this.knownServers = knownServers;
-	}
-};
-var DuplicateMcpServerError = class extends AgentyxError {
-	serverName;
-	constructor(serverName) {
-		super("duplicate_mcp_server", `Duplicate MCP server definition: "${serverName}".`);
-		this.name = "DuplicateMcpServerError";
-		this.serverName = serverName;
-	}
-};
-var InvalidMcpServerError = class extends AgentyxError {
-	origin;
-	reason;
-	constructor(origin, reason, options) {
-		const detail = typeof reason === "string" ? reason : formatIssues$1(reason);
-		super("invalid_mcp_server", `Invalid MCP server in ${origin}: ${detail}`, options);
-		this.name = "InvalidMcpServerError";
-		this.origin = origin;
-		this.reason = detail;
-	}
-};
-function formatIssues$1(error) {
-	return error.issues.map((issue) => {
-		const path = issue.path.map(String).join(".");
-		return path === "" ? issue.message : `${path}: ${issue.message}`;
-	}).join("; ");
-}
-//#endregion
-//#region src/mcp/registry.ts
-function createMcpServerRegistry(sources) {
-	const byName = /* @__PURE__ */ new Map();
-	for (const source of sources) {
-		const name = mcpServerNameSchema.safeParse(source.name);
-		if (!name.success) throw new InvalidMcpServerError(`MCP server source "${source.name}"`, name.error);
-		if (byName.has(name.data)) throw new DuplicateMcpServerError(name.data);
-		byName.set(name.data, source);
-	}
-	const names = [...byName.keys()];
-	const loaded = /* @__PURE__ */ new Map();
-	const get = (name) => {
-		const cached = loaded.get(name);
-		if (cached !== void 0) return cached;
-		const source = byName.get(name);
-		if (source === void 0) throw new UnknownMcpServerError(name, void 0, names);
-		const origin = `MCP server "${name}"`;
-		const server = mcpServerDefinitionSchema.safeParse(source.load());
-		if (!server.success) throw new InvalidMcpServerError(origin, server.error);
-		if (server.data.name !== name) throw new InvalidMcpServerError(origin, `it declares the name "${server.data.name}"`);
-		loaded.set(name, server.data);
-		return server.data;
-	};
-	return {
-		names,
-		has: (name) => byName.has(name),
-		listMetadata: () => names.map((name) => {
-			const server = get(name);
-			return {
-				name: server.name,
-				description: server.description,
-				transport: server.transport,
-				contextCost: server.contextCost
-			};
-		}),
-		get
-	};
-}
-const builtInMcpServerRegistry = createMcpServerRegistry([
-	{
-		name: "context7",
-		load: () => ({
-			name: "context7",
-			description: "Fetch up-to-date library documentation from Context7.",
-			transport: "http",
-			contextCost: "medium",
-			url: "https://mcp.context7.com/mcp"
-		})
-	},
-	{
-		name: "playwright",
-		load: () => ({
-			name: "playwright",
-			description: "Automate and inspect browsers through Playwright MCP.",
-			transport: "stdio",
-			contextCost: "high",
-			command: "npx",
-			args: ["@playwright/mcp@latest"]
-		})
-	},
-	{
-		name: "codebase-memory",
-		load: () => ({
-			name: "codebase-memory",
-			description: "Structural code-intelligence MCP backed by a persistent code knowledge graph.",
-			transport: "stdio",
-			contextCost: "high",
-			command: "codebase-memory-mcp"
-		})
-	},
-	{
-		name: "github",
-		load: () => ({
-			name: "github",
-			description: "Read repositories, issues, pull requests and workflow runs on GitHub.",
-			transport: "http",
-			contextCost: "high",
-			url: "https://api.githubcopilot.com/mcp/"
-		})
-	},
-	{
-		name: "sentry",
-		load: () => ({
-			name: "sentry",
-			description: "Inspect production issues, events and stack traces recorded by Sentry.",
-			transport: "http",
-			contextCost: "medium",
-			url: "https://mcp.sentry.dev/mcp"
-		})
-	},
-	{
-		name: "chrome-devtools",
-		load: () => ({
-			name: "chrome-devtools",
-			description: "Record performance traces and inspect pages through Chrome DevTools.",
-			transport: "stdio",
-			contextCost: "high",
-			command: "npx",
-			args: ["-y", "chrome-devtools-mcp@latest"]
-		})
-	},
-	{
-		name: "supabase",
-		load: () => ({
-			name: "supabase",
-			description: "Inspect and query Supabase project schemas, tables and logs.",
-			transport: "stdio",
-			contextCost: "high",
-			command: "npx",
-			args: ["-y", "@supabase/mcp-server-supabase@latest"],
-			env: { SUPABASE_ACCESS_TOKEN: { fromEnv: "SUPABASE_ACCESS_TOKEN" } }
-		})
-	}
-]);
-const builtInMcpServerNames = builtInMcpServerRegistry.names;
-//#endregion
 //#region src/pack/errors.ts
 /** Raised when a requested pack is not present in the registry. */
 var UnknownPackError = class extends AgentyxError {
@@ -540,6 +459,10 @@ const builtInPacks = [
 		tools: [{
 			name: "rtk",
 			activation: "optional"
+		}],
+		hooks: [{
+			name: "session-doctor-bootstrap",
+			activation: "default"
 		}]
 	},
 	{
@@ -688,54 +611,6 @@ const builtInPacks = [
 /** The registry used by default when no explicit registry is supplied. */
 const builtInPackRegistry = createPackRegistry(builtInPacks);
 //#endregion
-//#region src/pack/resolver.ts
-/**
-* Resolves selected packs without hidden inheritance.
-*
-* The result preserves configured order, removes duplicates by first
-* occurrence, and validates every requested pack.
-*
-* @throws {UnknownPackError} when a requested pack is missing.
-*/
-function resolvePacks(requestedPacks, registry = builtInPackRegistry) {
-	const resolved = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const name of requestedPacks) {
-		if (seen.has(name)) continue;
-		if (!registry.has(name)) throw new UnknownPackError(name, void 0, [...registry.keys()]);
-		seen.add(name);
-		resolved.push(name);
-	}
-	return resolved;
-}
-//#endregion
-//#region src/mcp/resolver.ts
-function collectPackMcpServerReferences(resolvedPacks, packRegistry, mcpRegistry) {
-	const servers = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const packName of resolvedPacks) for (const server of packRegistry.get(packName)?.mcpServers ?? []) {
-		const serverName = server.name;
-		if (seen.has(serverName)) continue;
-		if (!mcpRegistry.has(serverName)) throw new UnknownMcpServerError(serverName, packName, mcpRegistry.names);
-		seen.add(serverName);
-		servers.push(server);
-	}
-	return servers;
-}
-function filterEffectiveMcpServers(servers, enabledCapabilities) {
-	const enabled = new Set(enabledCapabilities);
-	return servers.filter((server) => server.activation === "default" || enabled.has(server.name)).map((server) => server.name);
-}
-function collectPackMcpServers(resolvedPacks, packRegistry, mcpRegistry, enabledCapabilities = []) {
-	return filterEffectiveMcpServers(collectPackMcpServerReferences(resolvedPacks, packRegistry, mcpRegistry), enabledCapabilities);
-}
-function resolvePackMcpServerReferences(requestedPacks, packRegistry = builtInPackRegistry, mcpRegistry = builtInMcpServerRegistry) {
-	return collectPackMcpServerReferences(resolvePacks(requestedPacks, packRegistry), packRegistry, mcpRegistry);
-}
-function resolvePackMcpServers(requestedPacks, packRegistry = builtInPackRegistry, mcpRegistry = builtInMcpServerRegistry, enabledCapabilities = []) {
-	return collectPackMcpServers(resolvePacks(requestedPacks, packRegistry), packRegistry, mcpRegistry, enabledCapabilities);
-}
-//#endregion
 //#region src/assets.ts
 /**
 * Location of the non-code assets that ship with `@agentyx/core`.
@@ -795,14 +670,14 @@ var InvalidSkillError = class extends AgentyxError {
 	origin;
 	reason;
 	constructor(origin, reason, options) {
-		const detail = typeof reason === "string" ? reason : formatIssues(reason);
+		const detail = typeof reason === "string" ? reason : formatIssues$2(reason);
 		super("invalid_skill", `Invalid skill in ${origin}: ${detail}`, options);
 		this.name = "InvalidSkillError";
 		this.origin = origin;
 		this.reason = detail;
 	}
 };
-function formatIssues(error) {
+function formatIssues$2(error) {
 	return error.issues.map((issue) => {
 		const path = issue.path.map(String).join(".");
 		return path === "" ? issue.message : `${path}: ${issue.message}`;
@@ -1021,31 +896,491 @@ function loadBuiltInSkill(name) {
 	return parseSkillMarkdown(markdown, filePath);
 }
 //#endregion
-//#region src/skill/resolver.ts
-/**
-* Collects the skills contributed by an already-resolved pack chain.
-*
-* Only identifiers are produced — no skill body is read — so this stays cheap
-* enough to run on every `resolve`.
-*
-* @throws {UnknownSkillError} when a pack references a skill the registry lacks.
-*/
-function collectPackSkills(resolvedPacks, packRegistry, skillRegistry) {
-	const skills = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const packName of resolvedPacks) for (const skillName of packRegistry.get(packName)?.skills ?? []) {
-		if (seen.has(skillName)) continue;
-		if (!skillRegistry.has(skillName)) throw new UnknownSkillError(skillName, packName, skillRegistry.names);
-		seen.add(skillName);
-		skills.push(skillName);
+//#region src/source/errors.ts
+var DuplicateTrustedSourceError = class extends AgentyxError {
+	sourceName;
+	constructor(sourceName) {
+		super("duplicate_trusted_source", `Duplicate trusted source "${sourceName}".`);
+		this.name = "DuplicateTrustedSourceError";
+		this.sourceName = sourceName;
 	}
-	return skills;
+};
+var UnknownTrustedSourceError = class extends AgentyxError {
+	sourceName;
+	knownSources;
+	constructor(sourceName, knownSources) {
+		const known = knownSources.length > 0 ? [...knownSources].sort().join(", ") : "none";
+		super("unknown_trusted_source", `Unknown trusted source "${sourceName}". Known trusted sources: ${known}.`);
+		this.name = "UnknownTrustedSourceError";
+		this.sourceName = sourceName;
+		this.knownSources = knownSources;
+	}
+};
+var TrustedSourceLoadError = class extends AgentyxError {
+	sourceName;
+	constructor(sourceName, reason, options) {
+		super("trusted_source_load_error", `Could not load trusted source "${sourceName}": ${reason}`, options);
+		this.name = "TrustedSourceLoadError";
+		this.sourceName = sourceName;
+	}
+};
+//#endregion
+//#region src/source/registry.ts
+const knownTrustedSources = [trustedSourceDefinitionSchema.parse({
+	name: "superpowers",
+	displayName: "Superpowers",
+	repository: "https://github.com/obra/superpowers",
+	type: "codex-plugin",
+	manifestPath: ".codex-plugin/plugin.json",
+	recommendedPath: ".agentyx/sources/superpowers",
+	description: "Agentic planning, TDD, debugging, code review and delivery workflows packaged as a Codex plugin.",
+	installStatus: "metadata-only",
+	installNote: "Agentyx can inspect and verify the local plugin checkout, but does not install its resource-bearing skills yet."
+})];
+const knownTrustedSourceRegistry = createTrustedSourceRegistry(knownTrustedSources);
+function createTrustedSourceRegistry(definitions) {
+	const registry = /* @__PURE__ */ new Map();
+	for (const definition of definitions) {
+		const parsed = trustedSourceDefinitionSchema.parse(definition);
+		if (registry.has(parsed.name)) throw new DuplicateTrustedSourceError(parsed.name);
+		registry.set(parsed.name, parsed);
+	}
+	return registry;
+}
+function getTrustedSourceDefinition(source, registry = knownTrustedSourceRegistry) {
+	const name = typeof source === "string" ? source : source.name;
+	const definition = registry.get(name);
+	if (definition === void 0) throw new UnknownTrustedSourceError(name, [...registry.keys()]);
+	return definition;
 }
+//#endregion
+//#region src/config/project.ts
 /**
-* Resolves the requested packs and returns the skills they contribute.
+* Loads `.agentyx.json` and any checked-in Agent Skills it declares.
 *
-* The result follows the resolved pack order, then each pack's declaration
-* order, and is de-duplicated by first occurrence. Skills do not extend other
+* A Skill root contains one directory per Skill, each with a `SKILL.md`. Roots must resolve inside
+* the project even through symlinks. Loading is local-only: this function never clones a repository
+* or accesses the network.
+*/
+async function loadAgentyxProject(projectPath = process.cwd()) {
+	const projectDir = resolve(projectPath);
+	const config = await loadAgentyxConfig(projectDir);
+	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]);
+	return {
+		config,
+		packRegistry: config.localPacks === void 0 ? builtInPackRegistry : createPackRegistry([...builtInPacks, ...config.localPacks]),
+		skillRegistry
+	};
+}
+async function loadLocalSkillSources(projectDir, directories) {
+	const projectRealPath = await realpath(projectDir);
+	const sources = [];
+	for (const directory of directories) {
+		const root = resolve(projectDir, directory);
+		let rootRealPath;
+		try {
+			rootRealPath = await realpath(root);
+		} catch (cause) {
+			throw localDirectoryError(directory, "the directory does not exist or cannot be read", cause);
+		}
+		if (!isInside$1(rootRealPath, projectRealPath)) throw new LocalSkillDirectoryError(directory, "the resolved path is outside the project");
+		let entries;
+		try {
+			entries = await readdir(rootRealPath, { withFileTypes: true });
+		} catch (cause) {
+			throw localDirectoryError(directory, "the directory cannot be listed", cause);
+		}
+		for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+			if (!entry.isDirectory()) continue;
+			const filePath = join(rootRealPath, entry.name, "SKILL.md");
+			let realFilePath;
+			try {
+				realFilePath = await realpath(filePath);
+			} catch (cause) {
+				if (cause instanceof Error && cause.code === "ENOENT") continue;
+				throw localDirectoryError(directory, `cannot read ${entry.name}/SKILL.md`, cause);
+			}
+			if (!isInside$1(realFilePath, rootRealPath)) throw new LocalSkillDirectoryError(directory, `${entry.name}/SKILL.md resolves outside the skill directory`);
+			let markdown;
+			try {
+				markdown = await readFile(realFilePath, "utf8");
+			} catch (cause) {
+				throw localDirectoryError(directory, `cannot read ${entry.name}/SKILL.md`, cause);
+			}
+			const skill = parseSkillMarkdown(markdown, filePath);
+			if (skill.name !== entry.name) throw new LocalSkillDirectoryError(directory, `${entry.name}/SKILL.md declares the name "${skill.name}"`);
+			sources.push({
+				name: skill.name,
+				load: () => skill
+			});
+		}
+	}
+	return sources;
+}
+function isInside$1(path, root) {
+	const pathFromRoot = relative(root, path);
+	return pathFromRoot === "" || !pathFromRoot.startsWith(`..${sep}`) && pathFromRoot !== ".." && !isAbsolute(pathFromRoot);
+}
+function localDirectoryError(directory, reason, cause) {
+	return new LocalSkillDirectoryError(directory, reason, cause instanceof Error ? { cause } : void 0);
+}
+//#endregion
+//#region src/hook/errors.ts
+var UnknownHookError = class extends AgentyxError {
+	hookName;
+	requiredBy;
+	knownHooks;
+	constructor(hookName, requiredBy, knownHooks) {
+		const origin = requiredBy === void 0 ? "" : ` (required by "${requiredBy}")`;
+		const known = knownHooks.length > 0 ? [...knownHooks].sort().join(", ") : "none";
+		super("unknown_hook", `Unknown hook "${hookName}"${origin}. Known hooks: ${known}.`);
+		this.name = "UnknownHookError";
+		this.hookName = hookName;
+		this.requiredBy = requiredBy;
+		this.knownHooks = knownHooks;
+	}
+};
+var DuplicateHookError = class extends AgentyxError {
+	hookName;
+	constructor(hookName) {
+		super("duplicate_hook", `Duplicate hook definition: "${hookName}".`);
+		this.name = "DuplicateHookError";
+		this.hookName = hookName;
+	}
+};
+var InvalidHookError = class extends AgentyxError {
+	origin;
+	reason;
+	constructor(origin, reason, options) {
+		const detail = typeof reason === "string" ? reason : formatIssues$1(reason);
+		super("invalid_hook", `Invalid hook in ${origin}: ${detail}`, options);
+		this.name = "InvalidHookError";
+		this.origin = origin;
+		this.reason = detail;
+	}
+};
+function formatIssues$1(error) {
+	return error.issues.map((issue) => {
+		const path = issue.path.map(String).join(".");
+		return path === "" ? issue.message : `${path}: ${issue.message}`;
+	}).join("; ");
+}
+//#endregion
+//#region src/hook/registry.ts
+function createHookRegistry(sources) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		const name = hookNameSchema.safeParse(source.name);
+		if (!name.success) throw new InvalidHookError(`Hook source "${source.name}"`, name.error);
+		if (byName.has(name.data)) throw new DuplicateHookError(name.data);
+		byName.set(name.data, source);
+	}
+	const names = [...byName.keys()];
+	const loaded = /* @__PURE__ */ new Map();
+	const get = (name) => {
+		const cached = loaded.get(name);
+		if (cached !== void 0) return cached;
+		const source = byName.get(name);
+		if (source === void 0) throw new UnknownHookError(name, void 0, names);
+		const origin = `Hook "${name}"`;
+		const hook = hookDefinitionSchema.safeParse(source.load());
+		if (!hook.success) throw new InvalidHookError(origin, hook.error);
+		if (hook.data.name !== name) throw new InvalidHookError(origin, `it declares the name "${hook.data.name}"`);
+		loaded.set(name, hook.data);
+		return hook.data;
+	};
+	return {
+		names,
+		has: (name) => byName.has(name),
+		listMetadata: () => names.map((name) => {
+			const hook = get(name);
+			return {
+				name: hook.name,
+				description: hook.description,
+				event: hook.event
+			};
+		}),
+		get
+	};
+}
+const builtInHookRegistry = createHookRegistry([{
+	name: "session-doctor-bootstrap",
+	load: () => ({
+		name: "session-doctor-bootstrap",
+		description: "Reports Agentyx project health at session start; silent when healthy.",
+		event: "SessionStart",
+		command: "npx",
+		args: [
+			"agentyx",
+			"doctor",
+			"--hook"
+		]
+	})
+}]);
+const builtInHookNames = builtInHookRegistry.names;
+//#endregion
+//#region src/pack/resolver.ts
+/**
+* Resolves selected packs without hidden inheritance.
+*
+* The result preserves configured order, removes duplicates by first
+* occurrence, and validates every requested pack.
+*
+* @throws {UnknownPackError} when a requested pack is missing.
+*/
+function resolvePacks(requestedPacks, registry = builtInPackRegistry) {
+	const resolved = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const name of requestedPacks) {
+		if (seen.has(name)) continue;
+		if (!registry.has(name)) throw new UnknownPackError(name, void 0, [...registry.keys()]);
+		seen.add(name);
+		resolved.push(name);
+	}
+	return resolved;
+}
+//#endregion
+//#region src/hook/resolver.ts
+function collectPackHookReferences(resolvedPacks, packRegistry, hookRegistry) {
+	const hooks = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const packName of resolvedPacks) for (const hook of packRegistry.get(packName)?.hooks ?? []) {
+		const hookName = hook.name;
+		if (seen.has(hookName)) continue;
+		if (!hookRegistry.has(hookName)) throw new UnknownHookError(hookName, packName, hookRegistry.names);
+		seen.add(hookName);
+		hooks.push(hook);
+	}
+	return hooks;
+}
+function filterEffectiveHooks(hooks, enabledCapabilities) {
+	const enabled = new Set(enabledCapabilities);
+	return hooks.filter((hook) => hook.activation === "default" || enabled.has(hook.name)).map((hook) => hook.name);
+}
+function collectPackHooks(resolvedPacks, packRegistry, hookRegistry, enabledCapabilities = []) {
+	return filterEffectiveHooks(collectPackHookReferences(resolvedPacks, packRegistry, hookRegistry), enabledCapabilities);
+}
+function resolvePackHookReferences(requestedPacks, packRegistry = builtInPackRegistry, hookRegistry = builtInHookRegistry) {
+	return collectPackHookReferences(resolvePacks(requestedPacks, packRegistry), packRegistry, hookRegistry);
+}
+function resolvePackHooks(requestedPacks, packRegistry = builtInPackRegistry, hookRegistry = builtInHookRegistry, enabledCapabilities = []) {
+	return collectPackHooks(resolvePacks(requestedPacks, packRegistry), packRegistry, hookRegistry, enabledCapabilities);
+}
+//#endregion
+//#region src/mcp/errors.ts
+var UnknownMcpServerError = class extends AgentyxError {
+	serverName;
+	requiredBy;
+	knownServers;
+	constructor(serverName, requiredBy, knownServers) {
+		const origin = requiredBy === void 0 ? "" : ` (required by "${requiredBy}")`;
+		const known = knownServers.length > 0 ? [...knownServers].sort().join(", ") : "none";
+		super("unknown_mcp_server", `Unknown MCP server "${serverName}"${origin}. Known MCP servers: ${known}.`);
+		this.name = "UnknownMcpServerError";
+		this.serverName = serverName;
+		this.requiredBy = requiredBy;
+		this.knownServers = knownServers;
+	}
+};
+var DuplicateMcpServerError = class extends AgentyxError {
+	serverName;
+	constructor(serverName) {
+		super("duplicate_mcp_server", `Duplicate MCP server definition: "${serverName}".`);
+		this.name = "DuplicateMcpServerError";
+		this.serverName = serverName;
+	}
+};
+var InvalidMcpServerError = class extends AgentyxError {
+	origin;
+	reason;
+	constructor(origin, reason, options) {
+		const detail = typeof reason === "string" ? reason : formatIssues(reason);
+		super("invalid_mcp_server", `Invalid MCP server in ${origin}: ${detail}`, options);
+		this.name = "InvalidMcpServerError";
+		this.origin = origin;
+		this.reason = detail;
+	}
+};
+function formatIssues(error) {
+	return error.issues.map((issue) => {
+		const path = issue.path.map(String).join(".");
+		return path === "" ? issue.message : `${path}: ${issue.message}`;
+	}).join("; ");
+}
+//#endregion
+//#region src/mcp/registry.ts
+function createMcpServerRegistry(sources) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		const name = mcpServerNameSchema.safeParse(source.name);
+		if (!name.success) throw new InvalidMcpServerError(`MCP server source "${source.name}"`, name.error);
+		if (byName.has(name.data)) throw new DuplicateMcpServerError(name.data);
+		byName.set(name.data, source);
+	}
+	const names = [...byName.keys()];
+	const loaded = /* @__PURE__ */ new Map();
+	const get = (name) => {
+		const cached = loaded.get(name);
+		if (cached !== void 0) return cached;
+		const source = byName.get(name);
+		if (source === void 0) throw new UnknownMcpServerError(name, void 0, names);
+		const origin = `MCP server "${name}"`;
+		const server = mcpServerDefinitionSchema.safeParse(source.load());
+		if (!server.success) throw new InvalidMcpServerError(origin, server.error);
+		if (server.data.name !== name) throw new InvalidMcpServerError(origin, `it declares the name "${server.data.name}"`);
+		loaded.set(name, server.data);
+		return server.data;
+	};
+	return {
+		names,
+		has: (name) => byName.has(name),
+		listMetadata: () => names.map((name) => {
+			const server = get(name);
+			return {
+				name: server.name,
+				description: server.description,
+				transport: server.transport,
+				contextCost: server.contextCost
+			};
+		}),
+		get
+	};
+}
+const builtInMcpServerRegistry = createMcpServerRegistry([
+	{
+		name: "context7",
+		load: () => ({
+			name: "context7",
+			description: "Fetch up-to-date library documentation from Context7.",
+			transport: "http",
+			contextCost: "medium",
+			url: "https://mcp.context7.com/mcp"
+		})
+	},
+	{
+		name: "playwright",
+		load: () => ({
+			name: "playwright",
+			description: "Automate and inspect browsers through Playwright MCP.",
+			transport: "stdio",
+			contextCost: "high",
+			command: "npx",
+			args: ["@playwright/mcp@latest"]
+		})
+	},
+	{
+		name: "codebase-memory",
+		load: () => ({
+			name: "codebase-memory",
+			description: "Structural code-intelligence MCP backed by a persistent code knowledge graph.",
+			transport: "stdio",
+			contextCost: "high",
+			command: "codebase-memory-mcp"
+		})
+	},
+	{
+		name: "github",
+		load: () => ({
+			name: "github",
+			description: "Read repositories, issues, pull requests and workflow runs on GitHub.",
+			transport: "http",
+			contextCost: "high",
+			url: "https://api.githubcopilot.com/mcp/"
+		})
+	},
+	{
+		name: "sentry",
+		load: () => ({
+			name: "sentry",
+			description: "Inspect production issues, events and stack traces recorded by Sentry.",
+			transport: "http",
+			contextCost: "medium",
+			url: "https://mcp.sentry.dev/mcp"
+		})
+	},
+	{
+		name: "chrome-devtools",
+		load: () => ({
+			name: "chrome-devtools",
+			description: "Record performance traces and inspect pages through Chrome DevTools.",
+			transport: "stdio",
+			contextCost: "high",
+			command: "npx",
+			args: ["-y", "chrome-devtools-mcp@latest"]
+		})
+	},
+	{
+		name: "supabase",
+		load: () => ({
+			name: "supabase",
+			description: "Inspect and query Supabase project schemas, tables and logs.",
+			transport: "stdio",
+			contextCost: "high",
+			command: "npx",
+			args: ["-y", "@supabase/mcp-server-supabase@latest"],
+			env: { SUPABASE_ACCESS_TOKEN: { fromEnv: "SUPABASE_ACCESS_TOKEN" } }
+		})
+	}
+]);
+const builtInMcpServerNames = builtInMcpServerRegistry.names;
+//#endregion
+//#region src/mcp/resolver.ts
+function collectPackMcpServerReferences(resolvedPacks, packRegistry, mcpRegistry) {
+	const servers = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const packName of resolvedPacks) for (const server of packRegistry.get(packName)?.mcpServers ?? []) {
+		const serverName = server.name;
+		if (seen.has(serverName)) continue;
+		if (!mcpRegistry.has(serverName)) throw new UnknownMcpServerError(serverName, packName, mcpRegistry.names);
+		seen.add(serverName);
+		servers.push(server);
+	}
+	return servers;
+}
+function filterEffectiveMcpServers(servers, enabledCapabilities) {
+	const enabled = new Set(enabledCapabilities);
+	return servers.filter((server) => server.activation === "default" || enabled.has(server.name)).map((server) => server.name);
+}
+function collectPackMcpServers(resolvedPacks, packRegistry, mcpRegistry, enabledCapabilities = []) {
+	return filterEffectiveMcpServers(collectPackMcpServerReferences(resolvedPacks, packRegistry, mcpRegistry), enabledCapabilities);
+}
+function resolvePackMcpServerReferences(requestedPacks, packRegistry = builtInPackRegistry, mcpRegistry = builtInMcpServerRegistry) {
+	return collectPackMcpServerReferences(resolvePacks(requestedPacks, packRegistry), packRegistry, mcpRegistry);
+}
+function resolvePackMcpServers(requestedPacks, packRegistry = builtInPackRegistry, mcpRegistry = builtInMcpServerRegistry, enabledCapabilities = []) {
+	return collectPackMcpServers(resolvePacks(requestedPacks, packRegistry), packRegistry, mcpRegistry, enabledCapabilities);
+}
+//#endregion
+//#region src/skill/resolver.ts
+/**
+* Collects the skills contributed by an already-resolved pack chain.
+*
+* Only identifiers are produced — no skill body is read — so this stays cheap
+* enough to run on every `resolve`.
+*
+* @throws {UnknownSkillError} when a pack references a skill the registry lacks.
+*/
+function collectPackSkills(resolvedPacks, packRegistry, skillRegistry) {
+	const skills = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const packName of resolvedPacks) for (const skillName of packRegistry.get(packName)?.skills ?? []) {
+		if (seen.has(skillName)) continue;
+		if (!skillRegistry.has(skillName)) throw new UnknownSkillError(skillName, packName, skillRegistry.names);
+		seen.add(skillName);
+		skills.push(skillName);
+	}
+	return skills;
+}
+/**
+* Resolves the requested packs and returns the skills they contribute.
+*
+* The result follows the resolved pack order, then each pack's declaration
+* order, and is de-duplicated by first occurrence. Skills do not extend other
 * skills, so there is nothing further to expand.
 *
 * @throws {UnknownPackError} when a requested pack is missing.
@@ -1167,15 +1502,19 @@ function resolvePackTools(requestedPacks, packRegistry = builtInPackRegistry, to
 * The input is never mutated.
 *
 * @throws {UnknownPackError} when a configured pack is missing.
-* @throws {CircularPackDependencyError} when inheritance forms a cycle.
 * @throws {UnknownSkillError} when a pack references an unknown skill.
 */
-function resolveAgentyxConfig(config, registry = builtInPackRegistry, skillRegistry = builtInSkillRegistry, mcpRegistry = builtInMcpServerRegistry, toolRegistry = builtInToolRegistry) {
+function resolveAgentyxConfig(config, registry = builtInPackRegistry, skillRegistry = builtInSkillRegistry, mcpRegistry = builtInMcpServerRegistry, toolRegistry = builtInToolRegistry, hookRegistry = builtInHookRegistry) {
 	const requestedPacks = [...config.packs];
 	const resolvedPacks = resolvePacks(requestedPacks, registry);
 	const declaredMcpServers = collectPackMcpServerReferences(resolvedPacks, registry, mcpRegistry);
 	const declaredTools = collectPackToolReferences(resolvedPacks, registry, toolRegistry);
-	const knownOptionalCapabilities = [...declaredMcpServers.filter((server) => server.activation === "optional").map((server) => server.name), ...declaredTools.filter((tool) => tool.activation === "optional").map((tool) => tool.name)];
+	const declaredHooks = collectPackHookReferences(resolvedPacks, registry, hookRegistry);
+	const knownOptionalCapabilities = [
+		...declaredMcpServers.filter((server) => server.activation === "optional").map((server) => server.name),
+		...declaredTools.filter((tool) => tool.activation === "optional").map((tool) => tool.name),
+		...declaredHooks.filter((hook) => hook.activation === "optional").map((hook) => hook.name)
+	];
 	for (const capability of config.enable) if (!knownOptionalCapabilities.includes(capability)) throw new UnknownEnabledCapabilityError(capability, knownOptionalCapabilities);
 	return {
 		requestedPacks,
@@ -1185,6 +1524,8 @@ function resolveAgentyxConfig(config, registry = builtInPackRegistry, skillRegis
 		mcpServers: filterEffectiveMcpServers(declaredMcpServers, config.enable),
 		declaredTools,
 		tools: filterEffectiveTools(declaredTools, config.enable),
+		declaredHooks,
+		hooks: filterEffectiveHooks(declaredHooks, config.enable),
 		enabled: [...config.enable],
 		targets: [...config.targets]
 	};
@@ -1263,7 +1604,26 @@ const mcpManifestEntrySchema = z.strictObject({
 	hash: contentHashSchema,
 	created: z.boolean()
 });
-const installManifestEntrySchema = z.discriminatedUnion("kind", [skillManifestEntrySchema, mcpManifestEntrySchema]);
+/**
+* A provider hook configuration file Agentyx contributed entries to.
+*
+* Shares the `mcp` entry's shape and rationale: the file is shared with the
+* user, so the entry records the hook names Agentyx added rather than
+* claiming the whole document.
+*/
+const hookManifestEntrySchema = z.strictObject({
+	kind: z.literal("hook"),
+	path: managedPathSchema,
+	hooks: z.array(z.string().min(1, "Hook names must be non-empty strings.")),
+	targets: targetsSchema,
+	hash: contentHashSchema,
+	created: z.boolean()
+});
+const installManifestEntrySchema = z.discriminatedUnion("kind", [
+	skillManifestEntrySchema,
+	mcpManifestEntrySchema,
+	hookManifestEntrySchema
+]);
 /** The `.agentyx.lock.json` record of everything Agentyx installed into a project. */
 const installManifestSchema = z.strictObject({
 	version: z.literal(1),
@@ -1340,13 +1700,21 @@ async function loadInstallManifest(projectPath = process.cwd()) {
 * touches the filesystem.
 */
 function formatInstallManifest(manifest) {
-	const entries = [...manifest.entries].map((entry) => entry.kind === "skill" ? {
-		...entry,
-		targets: sorted(entry.targets)
-	} : {
-		...entry,
-		targets: sorted(entry.targets),
-		servers: sorted(entry.servers)
+	const entries = [...manifest.entries].map((entry) => {
+		if (entry.kind === "skill") return {
+			...entry,
+			targets: sorted(entry.targets)
+		};
+		if (entry.kind === "mcp") return {
+			...entry,
+			targets: sorted(entry.targets),
+			servers: sorted(entry.servers)
+		};
+		return {
+			...entry,
+			targets: sorted(entry.targets),
+			hooks: sorted(entry.hooks)
+		};
 	}).sort((left, right) => left.path.localeCompare(right.path));
 	return `${JSON.stringify({
 		version: manifest.version,
@@ -1527,6 +1895,94 @@ function isNotFound(cause) {
 	return cause instanceof Error && cause.code === "ENOENT";
 }
 //#endregion
-export { AGENTYX_CONFIG_FILENAME, AGENTYX_CONFIG_SCHEMA_ID, AGENTYX_MANIFEST_FILENAME, AgentyxConfigNotFoundError, AgentyxConfigParseError, AgentyxConfigValidationError, AgentyxError, AgentyxManifestParseError, AgentyxManifestValidationError, CircularPackDependencyError, DuplicateMcpServerError, DuplicatePackError, DuplicateSkillError, DuplicateToolError, INSTALL_MANIFEST_VERSION, InvalidMcpServerError, InvalidSkillError, InvalidToolError, MCP_CAPABILITY_LEVELS, MCP_CONTEXT_COSTS, PACKAGE_MANAGERS, PACK_CATEGORIES, TOOL_ACTIVATION_LEVELS, UnknownEnabledCapabilityError, UnknownMcpServerError, UnknownPackError, UnknownSkillError, UnknownToolError, agentyxConfigPath, agentyxConfigSchema, agentyxCoreName, agentyxManifestPath, agentyxTargetSchema, buildAgentyxConfig, buildAgentyxConfigJsonSchema, builtInMcpServerNames, builtInMcpServerRegistry, builtInPackRegistry, builtInPacks, builtInSkillNames, builtInSkillRegistry, builtInToolNames, builtInToolRegistry, collectPackMcpServerReferences, collectPackMcpServers, collectPackToolReferences, createMcpServerRegistry, createPackRegistry, createSkillRegistry, createToolRegistry, detectProject, emptyInstallManifest, enabledCapabilityNameSchema, filterEffectiveMcpServers, filterEffectiveTools, formatAgentyxConfig, formatInstallManifest, formatSkillMarkdown, getCoreStatus, hashContent, installManifestEntrySchema, installManifestSchema, loadAgentyxConfig, loadInstallManifest, manifestEntriesByPath, mcpCapabilityLevelSchema, mcpContextCostSchema, mcpEnvReferenceSchema, mcpManifestEntrySchema, mcpServerDefinitionSchema, mcpServerReferenceSchema, packCategorySchema, packDefinitionSchema, packNameSchema, parseAgentyxConfig, parseInstallManifest, parseSkillMarkdown, resolveAgentyxConfig, resolvePackMcpServerReferences, resolvePackMcpServers, resolvePackSkills, resolvePackToolReferences, resolvePackTools, resolvePacks, skillDefinitionSchema, skillManifestEntrySchema, toolActivationLevelSchema, toolDefinitionSchema, toolNameSchema, toolReferenceSchema };
+//#region src/source/inspection.ts
+async function inspectTrustedSource(projectPath, reference) {
+	const definition = getTrustedSourceDefinition(reference);
+	const projectDir = resolve(projectPath);
+	const projectRealPath = await realpath(projectDir);
+	const root = resolve(projectDir, reference.path);
+	const rootRealPath = await realpathOrThrow(reference.name, root, "the checkout path cannot be read");
+	if (!isInside(rootRealPath, projectRealPath)) throw new TrustedSourceLoadError(reference.name, "the checkout path resolves outside the project");
+	const manifestPath = join(rootRealPath, definition.manifestPath);
+	const manifest = await readManifest(reference.name, manifestPath);
+	if (manifest.name !== definition.name) throw new TrustedSourceLoadError(reference.name, `${definition.manifestPath} declares the name "${manifest.name}"`);
+	if (manifest.repository !== definition.repository) throw new TrustedSourceLoadError(reference.name, `${definition.manifestPath} declares repository "${manifest.repository}"`);
+	const skillsPath = resolve(dirname(manifestPath), manifest.skills);
+	if (!isInside(skillsPath, rootRealPath)) throw new TrustedSourceLoadError(reference.name, "the manifest skills path resolves outside the checkout");
+	const skillsRealPath = await realpathOrThrow(reference.name, skillsPath, "the manifest skills path cannot be read");
+	if (!isInside(skillsRealPath, rootRealPath)) throw new TrustedSourceLoadError(reference.name, "the manifest skills path resolves outside the checkout");
+	const skills = await inspectSkillSummaries(reference.name, skillsRealPath);
+	return {
+		definition,
+		reference,
+		rootPath: rootRealPath,
+		manifest,
+		skillsPath: skillsRealPath,
+		skills,
+		installable: definition.installStatus === "installable" && skills.every((skill) => !skill.hasResources),
+		installNote: definition.installNote
+	};
+}
+async function readManifest(sourceName, path) {
+	let raw;
+	try {
+		raw = await readFile(path, "utf8");
+	} catch (cause) {
+		throw trustedSourceLoadError(sourceName, "the plugin manifest cannot be read", cause);
+	}
+	try {
+		return codexPluginManifestSchema.parse(JSON.parse(raw));
+	} catch (cause) {
+		throw trustedSourceLoadError(sourceName, "the plugin manifest is invalid", cause);
+	}
+}
+async function inspectSkillSummaries(sourceName, skillsPath) {
+	let entries;
+	try {
+		entries = await readdir(skillsPath, { withFileTypes: true });
+	} catch (cause) {
+		throw trustedSourceLoadError(sourceName, "the plugin skills directory cannot be listed", cause);
+	}
+	const skills = [];
+	for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+		if (!entry.isDirectory()) continue;
+		const skillRoot = join(skillsPath, entry.name);
+		const skillPath = join(skillRoot, "SKILL.md");
+		let markdown;
+		try {
+			markdown = await readFile(skillPath, "utf8");
+		} catch (cause) {
+			if (cause instanceof Error && cause.code === "ENOENT") continue;
+			throw trustedSourceLoadError(sourceName, `cannot read ${entry.name}/SKILL.md`, cause);
+		}
+		const skill = parseSkillMarkdown(markdown, skillPath);
+		if (skill.name !== entry.name) throw new TrustedSourceLoadError(sourceName, `${entry.name}/SKILL.md declares the name "${skill.name}"`);
+		skills.push({
+			name: skill.name,
+			description: skill.description,
+			hasResources: await hasResources(skillRoot)
+		});
+	}
+	return skills;
+}
+async function hasResources(skillRoot) {
+	return (await readdir(skillRoot, { withFileTypes: true })).some((entry) => entry.name !== "SKILL.md");
+}
+async function realpathOrThrow(sourceName, path, reason) {
+	try {
+		return await realpath(path);
+	} catch (cause) {
+		throw trustedSourceLoadError(sourceName, reason, cause);
+	}
+}
+function isInside(path, root) {
+	const pathFromRoot = relative(root, path);
+	return pathFromRoot === "" || !pathFromRoot.startsWith(`..${sep}`) && pathFromRoot !== ".." && !isAbsolute(pathFromRoot);
+}
+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 };
 
 //# sourceMappingURL=index.mjs.map