@agentyx/core 0.1.1 → 0.2.0

package/dist/index.mjs

@@ -54,6 +54,17 @@ var AgentyxConfigValidationError = class extends AgentyxError {
 		this.filePath = filePath;
 	}
 };
+var UnknownEnabledCapabilityError = class extends AgentyxError {
+	capabilityName;
+	knownCapabilities;
+	constructor(capabilityName, knownCapabilities) {
+		const known = knownCapabilities.length > 0 ? [...knownCapabilities].sort().join(", ") : "none";
+		super("unknown_enabled_capability", `Unknown enabled capability "${capabilityName}". Known optional capabilities: ${known}.`);
+		this.name = "UnknownEnabledCapabilityError";
+		this.capabilityName = capabilityName;
+		this.knownCapabilities = knownCapabilities;
+	}
+};
 function toConfigIssues(error) {
 	return error.issues.map((issue) => ({
 		path: formatIssuePath(issue.path),
@@ -69,11 +80,7 @@ function formatIssuePath(path) {
 }
 //#endregion
 //#region src/mcp/schema.ts
-const MCP_CAPABILITY_LEVELS = [
-	"essential",
-	"recommended",
-	"optional"
-];
+const MCP_CAPABILITY_LEVELS = ["default", "optional"];
 const mcpCapabilityLevelSchema = z.enum(MCP_CAPABILITY_LEVELS);
 const MCP_CONTEXT_COSTS = [
 	"low",
@@ -91,14 +98,14 @@ const commonMcpServerDefinitionSchema = z.strictObject({
 });
 const explicitMcpServerReferenceSchema = z.strictObject({
 	name: mcpServerNameSchema.describe("MCP server identifier."),
-	level: mcpCapabilityLevelSchema.describe("How important this MCP capability is to the declaring stack.").default("recommended")
+	activation: mcpCapabilityLevelSchema.describe("Whether this MCP capability is active by default or explicit opt-in.").default("default")
 });
 const mcpServerReferenceSchema = z.union([mcpServerNameSchema, explicitMcpServerReferenceSchema]).transform((value) => typeof value === "string" ? {
 	name: value,
-	level: "recommended"
+	activation: "default"
 } : value).pipe(z.strictObject({
 	name: mcpServerNameSchema.describe("MCP server identifier."),
-	level: mcpCapabilityLevelSchema.describe("How important this MCP capability is to the declaring stack.")
+	activation: mcpCapabilityLevelSchema.describe("Whether this MCP capability is active by default or explicit opt-in.")
 }));
 const stdioMcpServerDefinitionSchema = commonMcpServerDefinitionSchema.extend({
 	transport: z.literal("stdio"),
@@ -135,44 +142,65 @@ const skillMetadataSchema = z.strictObject({
 */
 const skillDefinitionSchema = skillMetadataSchema.extend({ content: z.string().trim().min(1, "Skill content must be non-empty.").describe("The Markdown instructions handed to an agent.") });
 //#endregion
-//#region src/stack/schema.ts
-/**
-* Stack names are plain identifiers. They are intentionally not constrained to
-* a closed list so that external registries can contribute stacks later.
-*/
-const stackNameSchema = z.string().min(1, "Stack names must be non-empty strings.");
+//#region src/tool/schema.ts
+const TOOL_ACTIVATION_LEVELS = ["default", "optional"];
+const toolActivationLevelSchema = z.enum(TOOL_ACTIVATION_LEVELS);
+const toolNameSchema = z.string().min(1, "Tool names must be non-empty strings.").regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, "Tool names must be lowercase kebab-case, for example \"rtk\".");
+const toolReferenceSchema = z.union([toolNameSchema, z.strictObject({
+	name: toolNameSchema.describe("Tool identifier."),
+	activation: toolActivationLevelSchema.default("default")
+})]).transform((value) => typeof value === "string" ? {
+	name: value,
+	activation: "default"
+} : value).pipe(z.strictObject({
+	name: toolNameSchema.describe("Tool identifier."),
+	activation: toolActivationLevelSchema
+}));
+const toolDefinitionSchema = z.strictObject({
+	name: toolNameSchema.describe("Unique tool identifier."),
+	description: z.string().trim().min(1, "Tool descriptions must be non-empty strings."),
+	kind: z.literal("executable"),
+	command: z.string().trim().min(1, "Tool executable command must be a non-empty string."),
+	optional: z.boolean().default(true),
+	installHint: z.string().trim().min(1, "Tool install hints must be non-empty strings.").optional()
+});
+//#endregion
+//#region src/pack/schema.ts
+const PACK_CATEGORIES = [
+	"engineering",
+	"language",
+	"framework",
+	"efficiency",
+	"workflow"
+];
+const packCategorySchema = z.enum(PACK_CATEGORIES);
 /**
-* A stack describes a development environment that can build on other stacks
-* and contribute provider-agnostic capabilities to them.
+* Pack names are plain identifiers. They are intentionally not constrained to
+* a closed list so that external registries can contribute packs later.
 */
-const stackDefinitionSchema = z.strictObject({
-	name: stackNameSchema.describe("Unique stack identifier."),
-	description: z.string().min(1, "Stack descriptions must be non-empty when provided.").describe("Short human-readable summary of the stack.").optional(),
-	extends: z.array(stackNameSchema).describe("Stacks this stack builds on, in dependency-first order.").default([]),
-	skills: z.array(skillNameSchema).describe("Skills this stack contributes, in declaration order.").default([]),
-	mcpServers: z.array(mcpServerReferenceSchema).describe("MCP servers this stack contributes, in declaration order.").default([])
+const packNameSchema = z.string().min(1, "Pack names must be non-empty strings.");
+/** A pack is a composable provider-neutral capability bundle. */
+const packDefinitionSchema = z.strictObject({
+	name: packNameSchema.describe("Unique pack identifier."),
+	category: packCategorySchema.describe("Discoverability category; does not affect resolution.").default("engineering"),
+	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([])
 });
 //#endregion
 //#region src/config/schema.ts
-/** How much autonomy the generated environment should grant an agent. */
-const AGENTYX_PROFILES = [
-	"lean",
-	"balanced",
-	"autonomous"
-];
-const agentyxProfileSchema = z.enum(AGENTYX_PROFILES, { error: `Profile must be one of: ${AGENTYX_PROFILES.join(", ")}.` });
-/** Applied when a configuration omits `profile`. */
-const DEFAULT_AGENTYX_PROFILE = "balanced";
 /**
 * Targets stay free-form strings on purpose: third-party adapters should be
 * able to register providers without a change to this schema.
 */
 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\".");
 /** 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(),
-	extends: z.array(stackNameSchema).describe("Stacks this project builds on.").default([]),
-	profile: agentyxProfileSchema.describe("How much autonomy the generated environment grants.").default(DEFAULT_AGENTYX_PROFILE),
+	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([])
 });
 //#endregion
@@ -250,7 +278,7 @@ var UnknownMcpServerError = class extends AgentyxError {
 	requiredBy;
 	knownServers;
 	constructor(serverName, requiredBy, knownServers) {
-		const origin = requiredBy === void 0 ? "" : ` (required by stack "${requiredBy}")`;
+		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";
@@ -323,208 +351,210 @@ function createMcpServerRegistry(sources) {
 		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"]
-	})
-}]);
-const builtInMcpServerNames = builtInMcpServerRegistry.names;
-//#endregion
-//#region src/optimization/profile.ts
-const optimizationProfiles = [
+const builtInMcpServerRegistry = createMcpServerRegistry([
 	{
-		name: "lean",
-		goal: "Minimum context and tool overhead.",
-		mcpLevels: ["essential"],
-		notes: [
-			"Installs all resolved Skills.",
-			"Keeps MCP exposure to essential capabilities.",
-			"Prefers local CLI or native tools when they cover the same workflow."
-		]
+		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: "balanced",
-		goal: "Good default developer experience with conservative autonomy.",
-		mcpLevels: ["essential", "recommended"],
-		notes: ["Installs all resolved Skills.", "Includes default and recommended MCP capabilities."]
+		name: "playwright",
+		load: () => ({
+			name: "playwright",
+			description: "Automate and inspect browsers through Playwright MCP.",
+			transport: "stdio",
+			contextCost: "high",
+			command: "npx",
+			args: ["@playwright/mcp@latest"]
+		})
 	},
 	{
-		name: "autonomous",
-		goal: "Maximum agent capability from declared stack capabilities.",
-		mcpLevels: [
-			"essential",
-			"recommended",
-			"optional"
-		],
-		notes: ["Installs all resolved Skills.", "Includes optional MCP capabilities declared by the selected stacks."]
+		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"
+		})
 	}
-];
-const optimizationProfileNames = optimizationProfiles.map((profile) => profile.name);
-function getOptimizationProfile(name) {
-	const profile = optimizationProfiles.find((candidate) => candidate.name === name);
-	if (profile === void 0) throw new Error(`Unknown optimization profile: ${name}`);
-	return profile;
-}
-function isMcpLevelEnabled(profile, level) {
-	return getOptimizationProfile(profile).mcpLevels.includes(level);
-}
+]);
+const builtInMcpServerNames = builtInMcpServerRegistry.names;
 //#endregion
-//#region src/stack/errors.ts
-/**
-* Raised when a requested or inherited stack is not present in the registry.
-*
-* The offending name is exposed as `stackName`; `stack` stays the JS stack
-* trace inherited from `Error`.
-*/
-var UnknownStackError = class extends AgentyxError {
-	stackName;
+//#region src/pack/errors.ts
+/** Raised when a requested pack is not present in the registry. */
+var UnknownPackError = class extends AgentyxError {
+	packName;
 	requiredBy;
-	knownStacks;
-	constructor(stackName, requiredBy, knownStacks) {
+	knownPacks;
+	constructor(packName, requiredBy, knownPacks) {
 		const origin = requiredBy === void 0 ? "" : ` (required by "${requiredBy}")`;
-		const known = knownStacks.length > 0 ? [...knownStacks].sort().join(", ") : "none";
-		super("unknown_stack", `Unknown stack "${stackName}"${origin}. Known stacks: ${known}.`);
-		this.name = "UnknownStackError";
-		this.stackName = stackName;
+		const known = knownPacks.length > 0 ? [...knownPacks].sort().join(", ") : "none";
+		super("unknown_pack", `Unknown pack "${packName}"${origin}. Known packs: ${known}.`);
+		this.name = "UnknownPackError";
+		this.packName = packName;
 		this.requiredBy = requiredBy;
-		this.knownStacks = knownStacks;
+		this.knownPacks = knownPacks;
 	}
 };
-/** Raised when stack inheritance forms a cycle. */
-var CircularStackDependencyError = class extends AgentyxError {
-	/** The cycle path, starting and ending with the same stack. */
+/** @deprecated Packs no longer inherit from other packs. */
+var CircularPackDependencyError = class extends AgentyxError {
+	/** The cycle path, starting and ending with the same pack. */
 	cycle;
 	constructor(cycle) {
-		super("circular_stack_dependency", `Circular stack dependency: ${cycle.join(" -> ")}.`);
-		this.name = "CircularStackDependencyError";
+		super("circular_pack_dependency", `Circular pack dependency: ${cycle.join(" -> ")}.`);
+		this.name = "CircularPackDependencyError";
 		this.cycle = cycle;
 	}
 };
-/** Raised when a registry is built from definitions that reuse a stack name. */
-var DuplicateStackError = class extends AgentyxError {
-	stackName;
-	constructor(stackName) {
-		super("duplicate_stack", `Duplicate stack definition: "${stackName}".`);
-		this.name = "DuplicateStackError";
-		this.stackName = stackName;
+/** Raised when a registry is built from definitions that reuse a pack name. */
+var DuplicatePackError = class extends AgentyxError {
+	packName;
+	constructor(packName) {
+		super("duplicate_pack", `Duplicate pack definition: "${packName}".`);
+		this.name = "DuplicatePackError";
+		this.packName = packName;
 	}
 };
 //#endregion
-//#region src/stack/registry.ts
+//#region src/pack/registry.ts
 /** Validates definitions and indexes them by name. */
-function createStackRegistry(definitions) {
+function createPackRegistry(definitions) {
 	const registry = /* @__PURE__ */ new Map();
 	for (const definition of definitions) {
-		const stack = stackDefinitionSchema.parse(definition);
-		if (registry.has(stack.name)) throw new DuplicateStackError(stack.name);
-		registry.set(stack.name, stack);
+		const pack = packDefinitionSchema.parse(definition);
+		if (registry.has(pack.name)) throw new DuplicatePackError(pack.name);
+		registry.set(pack.name, pack);
 	}
 	return registry;
 }
 /**
-* The stacks Agentyx ships with, expressed as data. Relationships live here, not
+* The packs Agentyx ships with, expressed as data. Relationships live here, not
 * in the resolver.
 */
-const builtInStacks = [
+const builtInPacks = [
 	{
-		name: "core",
-		description: "Baseline development environment shared by every Agentyx stack.",
+		name: "technical",
+		category: "engineering",
+		description: "General software-engineering quality independent of language or framework.",
 		skills: [
-			"planning",
-			"systematic-debugging",
-			"verification"
+			"engineering-principles",
+			"code-quality",
+			"api-design",
+			"code-review"
 		]
 	},
 	{
 		name: "typescript",
-		description: "TypeScript development environment.",
-		extends: ["core"],
-		skills: ["typescript-modern"]
+		category: "language",
+		description: "TypeScript language conventions for strict, modern code.",
+		skills: [
+			"typescript-strict",
+			"typescript-modeling",
+			"typescript-modern"
+		]
 	},
 	{
 		name: "angular",
+		category: "framework",
 		description: "Modern Angular development environment.",
-		extends: ["typescript"],
-		skills: ["angular-modern"],
+		skills: [
+			"angular-modern",
+			"angular-signals",
+			"angular-architecture",
+			"angular-testing"
+		],
+		mcpServers: ["context7"]
+	},
+	{
+		name: "efficiency",
+		category: "efficiency",
+		description: "Reduce context and tool overhead without weakening verification.",
+		skills: [
+			"context-efficient-development",
+			"concise-output",
+			"targeted-exploration",
+			"focused-verification"
+		],
 		mcpServers: [{
-			name: "context7",
-			level: "recommended"
+			name: "codebase-memory",
+			activation: "optional"
+		}],
+		tools: [{
+			name: "rtk",
+			activation: "optional"
 		}]
+	},
+	{
+		name: "agentic",
+		category: "workflow",
+		description: "Provider-neutral development workflows for substantial coding-agent work.",
+		skills: [
+			"brainstorming",
+			"planning",
+			"systematic-debugging",
+			"verification",
+			"parallel-work",
+			"worktree-workflow",
+			"subagent-driven-development",
+			"requesting-code-review"
+		]
 	}
 ];
 /** The registry used by default when no explicit registry is supplied. */
-const builtInStackRegistry = createStackRegistry(builtInStacks);
+const builtInPackRegistry = createPackRegistry(builtInPacks);
 //#endregion
-//#region src/stack/resolver.ts
+//#region src/pack/resolver.ts
 /**
-* Expands the requested stacks into the full inheritance chain.
+* Resolves selected packs without hidden inheritance.
 *
-* The result is dependency-first, de-duplicated and deterministic: stacks are
-* visited in the order they are requested, and each stack's parents are visited
-* in declaration order before the stack itself.
+* The result preserves configured order, removes duplicates by first
+* occurrence, and validates every requested pack.
 *
-* @throws {UnknownStackError} when a requested or inherited stack is missing.
-* @throws {CircularStackDependencyError} when inheritance forms a cycle.
+* @throws {UnknownPackError} when a requested pack is missing.
 */
-function resolveStacks(requestedStacks, registry = builtInStackRegistry) {
+function resolvePacks(requestedPacks, registry = builtInPackRegistry) {
 	const resolved = [];
-	const settled = /* @__PURE__ */ new Set();
-	const path = [];
-	const visit = (name, requiredBy) => {
-		if (settled.has(name)) return;
-		const cycleStart = path.indexOf(name);
-		if (cycleStart !== -1) throw new CircularStackDependencyError([...path.slice(cycleStart), name]);
-		const definition = registry.get(name);
-		if (definition === void 0) throw new UnknownStackError(name, requiredBy, [...registry.keys()]);
-		path.push(name);
-		for (const parent of definition.extends) visit(parent, name);
-		path.pop();
-		settled.add(name);
+	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);
-	};
-	for (const name of requestedStacks) visit(name, void 0);
+	}
 	return resolved;
 }
 //#endregion
 //#region src/mcp/resolver.ts
-function collectStackMcpServerReferences(resolvedStacks, stackRegistry, mcpRegistry) {
+function collectPackMcpServerReferences(resolvedPacks, packRegistry, mcpRegistry) {
 	const servers = [];
 	const seen = /* @__PURE__ */ new Set();
-	for (const stackName of resolvedStacks) for (const server of stackRegistry.get(stackName)?.mcpServers ?? []) {
+	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, stackName, mcpRegistry.names);
+		if (!mcpRegistry.has(serverName)) throw new UnknownMcpServerError(serverName, packName, mcpRegistry.names);
 		seen.add(serverName);
 		servers.push(server);
 	}
 	return servers;
 }
-function filterEffectiveMcpServers(servers, profile) {
-	return servers.filter((server) => isMcpLevelEnabled(profile, server.level)).map((server) => server.name);
+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 collectStackMcpServers(resolvedStacks, stackRegistry, mcpRegistry, profile = DEFAULT_AGENTYX_PROFILE) {
-	return filterEffectiveMcpServers(collectStackMcpServerReferences(resolvedStacks, stackRegistry, mcpRegistry), profile);
+function collectPackMcpServers(resolvedPacks, packRegistry, mcpRegistry, enabledCapabilities = []) {
+	return filterEffectiveMcpServers(collectPackMcpServerReferences(resolvedPacks, packRegistry, mcpRegistry), enabledCapabilities);
 }
-function resolveStackMcpServerReferences(requestedStacks, stackRegistry = builtInStackRegistry, mcpRegistry = builtInMcpServerRegistry) {
-	return collectStackMcpServerReferences(resolveStacks(requestedStacks, stackRegistry), stackRegistry, mcpRegistry);
+function resolvePackMcpServerReferences(requestedPacks, packRegistry = builtInPackRegistry, mcpRegistry = builtInMcpServerRegistry) {
+	return collectPackMcpServerReferences(resolvePacks(requestedPacks, packRegistry), packRegistry, mcpRegistry);
 }
-function resolveStackMcpServers(requestedStacks, stackRegistry = builtInStackRegistry, mcpRegistry = builtInMcpServerRegistry, profile = DEFAULT_AGENTYX_PROFILE) {
-	return collectStackMcpServers(resolveStacks(requestedStacks, stackRegistry), stackRegistry, mcpRegistry, profile);
+function resolvePackMcpServers(requestedPacks, packRegistry = builtInPackRegistry, mcpRegistry = builtInMcpServerRegistry, enabledCapabilities = []) {
+	return collectPackMcpServers(resolvePacks(requestedPacks, packRegistry), packRegistry, mcpRegistry, enabledCapabilities);
 }
 //#endregion
 //#region src/assets.ts
@@ -545,18 +575,18 @@ const BUILT_IN_SKILLS_PATH = fileURLToPath(new URL("../skills", import.meta.url)
 //#endregion
 //#region src/skill/errors.ts
 /**
-* Raised when a stack references a skill the registry does not know.
+* Raised when a pack references a skill the registry does not know.
 *
-* The offending name is exposed as `skillName`; `stack` stays the JS stack
+* The offending name is exposed as `skillName`; `pack` stays the JS pack
 * trace inherited from `Error`.
 */
 var UnknownSkillError = class extends AgentyxError {
 	skillName;
-	/** The stack that declared the skill, when the failure came from resolution. */
+	/** The pack that declared the skill, when the failure came from resolution. */
 	requiredBy;
 	knownSkills;
 	constructor(skillName, requiredBy, knownSkills) {
-		const origin = requiredBy === void 0 ? "" : ` (required by stack "${requiredBy}")`;
+		const origin = requiredBy === void 0 ? "" : ` (required by pack "${requiredBy}")`;
 		const known = knownSkills.length > 0 ? [...knownSkills].sort().join(", ") : "none";
 		super("unknown_skill", `Unknown skill "${skillName}"${origin}. Known skills: ${known}.`);
 		this.name = "UnknownSkillError";
@@ -724,14 +754,32 @@ function createSkillRegistry(sources) {
 /**
 * The skills Agentyx ships with. The names are the directory names under
 * `packages/core/skills`, and knowing them without touching the filesystem is
-* what lets stack resolution validate references without reading any body.
+* what lets pack resolution validate references without reading any body.
 */
 const builtInSkillNames = [
+	"engineering-principles",
+	"code-quality",
+	"api-design",
+	"code-review",
 	"planning",
 	"systematic-debugging",
 	"verification",
+	"brainstorming",
+	"parallel-work",
+	"worktree-workflow",
+	"subagent-driven-development",
+	"requesting-code-review",
+	"typescript-strict",
+	"typescript-modeling",
 	"typescript-modern",
-	"angular-modern"
+	"angular-modern",
+	"angular-signals",
+	"angular-architecture",
+	"angular-testing",
+	"context-efficient-development",
+	"concise-output",
+	"targeted-exploration",
+	"focused-verification"
 ];
 /** The absolute path of a built-in skill's `SKILL.md`. */
 function builtInSkillPath(name) {
@@ -763,59 +811,169 @@ function loadBuiltInSkill(name) {
 //#endregion
 //#region src/skill/resolver.ts
 /**
-* Collects the skills contributed by an already-resolved stack chain.
+* 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 stack references a skill the registry lacks.
+* @throws {UnknownSkillError} when a pack references a skill the registry lacks.
 */
-function collectStackSkills(resolvedStacks, stackRegistry, skillRegistry) {
+function collectPackSkills(resolvedPacks, packRegistry, skillRegistry) {
 	const skills = [];
 	const seen = /* @__PURE__ */ new Set();
-	for (const stackName of resolvedStacks) for (const skillName of stackRegistry.get(stackName)?.skills ?? []) {
+	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, stackName, skillRegistry.names);
+		if (!skillRegistry.has(skillName)) throw new UnknownSkillError(skillName, packName, skillRegistry.names);
 		seen.add(skillName);
 		skills.push(skillName);
 	}
 	return skills;
 }
 /**
-* Expands the requested stacks and returns the skills they contribute.
+* Resolves the requested packs and returns the skills they contribute.
 *
-* The result follows the resolved stack order, then each stack's declaration
+* 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 {UnknownStackError} when a requested or inherited stack is missing.
-* @throws {CircularStackDependencyError} when stack inheritance forms a cycle.
-* @throws {UnknownSkillError} when a stack references a skill the registry lacks.
+* @throws {UnknownPackError} when a requested pack is missing.
+* @throws {UnknownSkillError} when a pack references a skill the registry lacks.
 */
-function resolveStackSkills(requestedStacks, stackRegistry = builtInStackRegistry, skillRegistry = builtInSkillRegistry) {
-	return collectStackSkills(resolveStacks(requestedStacks, stackRegistry), stackRegistry, skillRegistry);
+function resolvePackSkills(requestedPacks, packRegistry = builtInPackRegistry, skillRegistry = builtInSkillRegistry) {
+	return collectPackSkills(resolvePacks(requestedPacks, packRegistry), packRegistry, skillRegistry);
+}
+//#endregion
+//#region src/tool/errors.ts
+var UnknownToolError = class extends AgentyxError {
+	toolName;
+	requiredBy;
+	knownTools;
+	constructor(toolName, requiredBy, knownTools) {
+		const origin = requiredBy === void 0 ? "" : ` (required by "${requiredBy}")`;
+		const known = knownTools.length > 0 ? [...knownTools].sort().join(", ") : "none";
+		super("unknown_tool", `Unknown tool "${toolName}"${origin}. Known tools: ${known}.`);
+		this.name = "UnknownToolError";
+		this.toolName = toolName;
+		this.requiredBy = requiredBy;
+		this.knownTools = knownTools;
+	}
+};
+var DuplicateToolError = class extends AgentyxError {
+	toolName;
+	constructor(toolName) {
+		super("duplicate_tool", `Duplicate tool definition: "${toolName}".`);
+		this.name = "DuplicateToolError";
+		this.toolName = toolName;
+	}
+};
+var InvalidToolError = class extends AgentyxError {
+	constructor(origin, reason, options) {
+		const message = reason instanceof Error ? reason.message : String(reason);
+		super("invalid_tool", `Invalid ${origin}: ${message}.`, options);
+		this.name = "InvalidToolError";
+	}
+};
+//#endregion
+//#region src/tool/registry.ts
+function createToolRegistry(sources) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		const name = toolNameSchema.safeParse(source.name);
+		if (!name.success) throw new InvalidToolError(`tool source "${source.name}"`, name.error);
+		if (byName.has(name.data)) throw new DuplicateToolError(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 UnknownToolError(name, void 0, names);
+		const origin = `tool "${name}"`;
+		const tool = toolDefinitionSchema.safeParse(source.load());
+		if (!tool.success) throw new InvalidToolError(origin, tool.error);
+		if (tool.data.name !== name) throw new InvalidToolError(origin, `it declares the name "${tool.data.name}"`);
+		loaded.set(name, tool.data);
+		return tool.data;
+	};
+	return {
+		names,
+		has: (name) => byName.has(name),
+		listMetadata: () => names.map((name) => {
+			const tool = get(name);
+			return {
+				name: tool.name,
+				description: tool.description,
+				kind: tool.kind,
+				command: tool.command,
+				optional: tool.optional
+			};
+		}),
+		get
+	};
+}
+const builtInToolRegistry = createToolRegistry([{
+	name: "rtk",
+	load: () => ({
+		name: "rtk",
+		description: "Rust Token Killer command-output proxy for reducing coding-agent context noise.",
+		kind: "executable",
+		command: "rtk",
+		optional: true,
+		installHint: "Install from the rtk-ai/rtk project if your local workflow benefits from it."
+	})
+}]);
+const builtInToolNames = builtInToolRegistry.names;
+//#endregion
+//#region src/tool/resolver.ts
+function collectPackToolReferences(resolvedPacks, packRegistry, toolRegistry) {
+	const tools = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const packName of resolvedPacks) for (const tool of packRegistry.get(packName)?.tools ?? []) {
+		if (seen.has(tool.name)) continue;
+		if (!toolRegistry.has(tool.name)) throw new UnknownToolError(tool.name, packName, toolRegistry.names);
+		seen.add(tool.name);
+		tools.push(tool);
+	}
+	return tools;
+}
+function filterEffectiveTools(tools, enabledCapabilities) {
+	const enabled = new Set(enabledCapabilities);
+	return tools.filter((tool) => tool.activation === "default" || enabled.has(tool.name)).map((tool) => tool.name);
+}
+function resolvePackToolReferences(requestedPacks, packRegistry = builtInPackRegistry, toolRegistry = builtInToolRegistry) {
+	return collectPackToolReferences(resolvePacks(requestedPacks, packRegistry), packRegistry, toolRegistry);
+}
+function resolvePackTools(requestedPacks, packRegistry = builtInPackRegistry, toolRegistry = builtInToolRegistry, enabledCapabilities = []) {
+	return filterEffectiveTools(resolvePackToolReferences(requestedPacks, packRegistry, toolRegistry), enabledCapabilities);
 }
 //#endregion
 //#region src/config/resolver.ts
 /**
-* Combines a validated project configuration with stack and skill resolution.
+* Combines a validated project configuration with pack and skill resolution.
 * The input is never mutated.
 *
-* @throws {UnknownStackError} when a configured stack is missing.
-* @throws {CircularStackDependencyError} when inheritance forms a cycle.
-* @throws {UnknownSkillError} when a stack references an unknown skill.
+* @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 = builtInStackRegistry, skillRegistry = builtInSkillRegistry, mcpRegistry = builtInMcpServerRegistry) {
-	const requestedStacks = [...config.extends];
-	const resolvedStacks = resolveStacks(requestedStacks, registry);
-	const declaredMcpServers = collectStackMcpServerReferences(resolvedStacks, registry, mcpRegistry);
+function resolveAgentyxConfig(config, registry = builtInPackRegistry, skillRegistry = builtInSkillRegistry, mcpRegistry = builtInMcpServerRegistry, toolRegistry = builtInToolRegistry) {
+	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)];
+	for (const capability of config.enable) if (!knownOptionalCapabilities.includes(capability)) throw new UnknownEnabledCapabilityError(capability, knownOptionalCapabilities);
 	return {
-		requestedStacks,
-		resolvedStacks,
-		skills: collectStackSkills(resolvedStacks, registry, skillRegistry),
+		requestedPacks,
+		resolvedPacks,
+		skills: collectPackSkills(resolvedPacks, registry, skillRegistry),
 		declaredMcpServers,
-		mcpServers: filterEffectiveMcpServers(declaredMcpServers, config.profile),
-		profile: config.profile,
+		mcpServers: filterEffectiveMcpServers(declaredMcpServers, config.enable),
+		declaredTools,
+		tools: filterEffectiveTools(declaredTools, config.enable),
+		enabled: [...config.enable],
 		targets: [...config.targets]
 	};
 }
@@ -844,7 +1002,7 @@ async function detectProject(projectDir) {
 	const packageJsonPath = join(projectDir, "package.json");
 	const packageJson = await readPackageJson(packageJsonPath);
 	const packageManager = await detectPackageManager(projectDir, packageJson.data);
-	const detectedStacks = await detectStacks(projectDir, packageJson.data);
+	const detectedPacks = await detectPacks(projectDir, packageJson.data);
 	return {
 		projectDir,
 		packageJson: {
@@ -856,31 +1014,36 @@ async function detectProject(projectDir) {
 			error: packageJson.error
 		},
 		packageManager,
-		detectedStacks,
-		recommendedStack: recommendStack(detectedStacks)
+		detectedPacks,
+		recommendedPacks: recommendPacks(detectedPacks)
 	};
 }
 function buildAgentyxConfig(input) {
 	return {
-		extends: [input.stack],
-		profile: input.profile,
+		packs: [...input.packs],
+		enable: [...input.enable ?? []],
 		targets: [...input.targets]
 	};
 }
 function formatAgentyxConfig(config) {
 	return `${JSON.stringify(config, null, 2)}\n`;
 }
-function recommendStack(detectedStacks) {
-	if (detectedStacks.includes("angular")) return "angular";
-	if (detectedStacks.includes("typescript")) return "typescript";
+function recommendPacks(detectedPacks) {
+	if (detectedPacks.includes("angular")) return [
+		"technical",
+		"typescript",
+		"angular"
+	];
+	if (detectedPacks.includes("typescript")) return ["technical", "typescript"];
+	return ["technical"];
 }
-async function detectStacks(projectDir, packageJson) {
-	const stacks = [];
+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) stacks.push("typescript");
-	if (hasAngular) stacks.push("angular");
-	return stacks;
+	if (dependencies.has("typescript") || await exists(join(projectDir, "tsconfig.json")) || hasAngular) packs.push("typescript");
+	if (hasAngular) packs.push("angular");
+	return packs;
 }
 async function detectPackageManager(projectDir, packageJson) {
 	const lockfiles = [];
@@ -976,6 +1139,6 @@ function isNotFound(cause) {
 	return cause instanceof Error && cause.code === "ENOENT";
 }
 //#endregion
-export { AGENTYX_CONFIG_FILENAME, AGENTYX_CONFIG_SCHEMA_ID, AGENTYX_PROFILES, AgentyxConfigNotFoundError, AgentyxConfigParseError, AgentyxConfigValidationError, AgentyxError, CircularStackDependencyError, DEFAULT_AGENTYX_PROFILE, DuplicateMcpServerError, DuplicateSkillError, DuplicateStackError, InvalidMcpServerError, InvalidSkillError, MCP_CAPABILITY_LEVELS, MCP_CONTEXT_COSTS, PACKAGE_MANAGERS, UnknownMcpServerError, UnknownSkillError, UnknownStackError, agentyxConfigPath, agentyxConfigSchema, agentyxCoreName, agentyxProfileSchema, buildAgentyxConfig, buildAgentyxConfigJsonSchema, builtInMcpServerNames, builtInMcpServerRegistry, builtInSkillNames, builtInSkillRegistry, builtInStackRegistry, builtInStacks, collectStackMcpServerReferences, collectStackMcpServers, createMcpServerRegistry, createSkillRegistry, createStackRegistry, detectProject, filterEffectiveMcpServers, formatAgentyxConfig, formatSkillMarkdown, getCoreStatus, getOptimizationProfile, isMcpLevelEnabled, loadAgentyxConfig, mcpCapabilityLevelSchema, mcpContextCostSchema, mcpEnvReferenceSchema, mcpServerDefinitionSchema, mcpServerReferenceSchema, optimizationProfileNames, optimizationProfiles, parseAgentyxConfig, parseSkillMarkdown, resolveAgentyxConfig, resolveStackMcpServerReferences, resolveStackMcpServers, resolveStackSkills, resolveStacks, skillDefinitionSchema, stackDefinitionSchema };
+export { AGENTYX_CONFIG_FILENAME, AGENTYX_CONFIG_SCHEMA_ID, AgentyxConfigNotFoundError, AgentyxConfigParseError, AgentyxConfigValidationError, AgentyxError, CircularPackDependencyError, DuplicateMcpServerError, DuplicatePackError, DuplicateSkillError, DuplicateToolError, InvalidMcpServerError, InvalidSkillError, InvalidToolError, MCP_CAPABILITY_LEVELS, MCP_CONTEXT_COSTS, PACKAGE_MANAGERS, PACK_CATEGORIES, TOOL_ACTIVATION_LEVELS, UnknownEnabledCapabilityError, UnknownMcpServerError, UnknownPackError, UnknownSkillError, UnknownToolError, agentyxConfigPath, agentyxConfigSchema, agentyxCoreName, agentyxTargetSchema, buildAgentyxConfig, buildAgentyxConfigJsonSchema, builtInMcpServerNames, builtInMcpServerRegistry, builtInPackRegistry, builtInPacks, builtInSkillNames, builtInSkillRegistry, builtInToolNames, builtInToolRegistry, collectPackMcpServerReferences, collectPackMcpServers, collectPackToolReferences, createMcpServerRegistry, createPackRegistry, createSkillRegistry, createToolRegistry, detectProject, enabledCapabilityNameSchema, filterEffectiveMcpServers, filterEffectiveTools, formatAgentyxConfig, formatSkillMarkdown, getCoreStatus, loadAgentyxConfig, mcpCapabilityLevelSchema, mcpContextCostSchema, mcpEnvReferenceSchema, mcpServerDefinitionSchema, mcpServerReferenceSchema, packCategorySchema, packDefinitionSchema, packNameSchema, parseAgentyxConfig, parseSkillMarkdown, resolveAgentyxConfig, resolvePackMcpServerReferences, resolvePackMcpServers, resolvePackSkills, resolvePackToolReferences, resolvePackTools, resolvePacks, skillDefinitionSchema, toolActivationLevelSchema, toolDefinitionSchema, toolNameSchema, toolReferenceSchema };
 
 //# sourceMappingURL=index.mjs.map