@agentyx/core 0.1.1 → 0.3.0

package/dist/index.mjs

@@ -3,6 +3,7 @@ import { access, readFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
 //#region src/errors.ts
 /**
 * Base class for every failure Agentyx raises deliberately.
@@ -20,6 +21,27 @@ var AgentyxError = class extends Error {
 	}
 };
 //#endregion
+//#region src/issues.ts
+/**
+* Turns a Zod failure into locations a reader can find in the file.
+*
+* Shared by every document Agentyx validates, so a problem in `.agentyx.json`
+* and a problem in `.agentyx.lock.json` are reported the same way.
+*/
+function toAgentyxIssues(error) {
+	return error.issues.map((issue) => ({
+		path: formatIssuePath(issue.path),
+		message: issue.message
+	}));
+}
+function formatIssuePath(path) {
+	if (path.length === 0) return "(root)";
+	return path.reduce((formatted, segment) => {
+		if (typeof segment === "number") return `${formatted}[${segment}]`;
+		return formatted === "" ? String(segment) : `${formatted}.${String(segment)}`;
+	}, "");
+}
+//#endregion
 //#region src/config/errors.ts
 /** Raised when the supplied directory has no `.agentyx.json`. */
 var AgentyxConfigNotFoundError = class extends AgentyxError {
@@ -45,7 +67,7 @@ var AgentyxConfigValidationError = class extends AgentyxError {
 	/** The file the configuration came from, when it was read from disk. */
 	filePath;
 	constructor(error, filePath) {
-		const issues = toConfigIssues(error);
+		const issues = toAgentyxIssues(error);
 		const location = filePath === void 0 ? "" : ` in ${filePath}`;
 		const details = issues.map((issue) => `  - ${issue.path}: ${issue.message}`).join("\n");
 		super("agentyx_config_invalid", `Invalid Agentyx configuration${location}:\n${details}`);
@@ -54,26 +76,20 @@ var AgentyxConfigValidationError = class extends AgentyxError {
 		this.filePath = filePath;
 	}
 };
-function toConfigIssues(error) {
-	return error.issues.map((issue) => ({
-		path: formatIssuePath(issue.path),
-		message: issue.message
-	}));
-}
-function formatIssuePath(path) {
-	if (path.length === 0) return "(root)";
-	return path.reduce((formatted, segment) => {
-		if (typeof segment === "number") return `${formatted}[${segment}]`;
-		return formatted === "" ? String(segment) : `${formatted}.${String(segment)}`;
-	}, "");
-}
+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;
+	}
+};
 //#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 +107,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 +151,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 +287,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 +360,380 @@ function createMcpServerRegistry(sources) {
 		get
 	};
 }
-const builtInMcpServerRegistry = createMcpServerRegistry([{
-	name: "context7",
-	load: () => ({
+const builtInMcpServerRegistry = createMcpServerRegistry([
+	{
 		name: "context7",
-		description: "Fetch up-to-date library documentation from Context7.",
-		transport: "http",
-		contextCost: "medium",
-		url: "https://mcp.context7.com/mcp"
-	})
-}, {
-	name: "playwright",
-	load: () => ({
+		load: () => ({
+			name: "context7",
+			description: "Fetch up-to-date library documentation from Context7.",
+			transport: "http",
+			contextCost: "medium",
+			url: "https://mcp.context7.com/mcp"
+		})
+	},
+	{
 		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 = [
+		load: () => ({
+			name: "playwright",
+			description: "Automate and inspect browsers through Playwright MCP.",
+			transport: "stdio",
+			contextCost: "high",
+			command: "npx",
+			args: ["@playwright/mcp@latest"]
+		})
+	},
 	{
-		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: "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: "balanced",
-		goal: "Good default developer experience with conservative autonomy.",
-		mcpLevels: ["essential", "recommended"],
-		notes: ["Installs all resolved Skills.", "Includes default and recommended MCP capabilities."]
+		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: "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: "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 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"
+		]
+	},
+	{
+		name: "testing",
+		category: "engineering",
+		description: "Test design, isolation and stability at every level of the pyramid.",
+		skills: [
+			"test-strategy",
+			"test-doubles",
+			"e2e-testing",
+			"flaky-tests"
+		],
+		mcpServers: [{
+			name: "playwright",
+			activation: "optional"
+		}]
+	},
+	{
+		name: "security",
+		category: "engineering",
+		description: "Application security fundamentals for untrusted input, secrets and access.",
+		skills: [
+			"secure-coding",
+			"secrets-handling",
+			"dependency-security",
+			"auth-patterns"
+		]
+	},
+	{
+		name: "performance",
+		category: "engineering",
+		description: "Measure before optimizing, across application, browser and database.",
+		skills: [
+			"performance-profiling",
+			"web-vitals",
+			"query-performance"
+		],
+		mcpServers: [{
+			name: "chrome-devtools",
+			activation: "optional"
+		}]
+	},
+	{
+		name: "accessibility",
+		category: "engineering",
+		description: "Accessible markup, ARIA and keyboard interaction for web interfaces.",
+		skills: [
+			"semantic-html",
+			"aria-patterns",
+			"keyboard-navigation"
+		],
+		mcpServers: [{
+			name: "chrome-devtools",
+			activation: "optional"
+		}]
+	},
+	{
+		name: "refactoring",
+		category: "engineering",
+		description: "Change structure safely, including in legacy code with weak tests.",
+		skills: [
+			"refactoring-safely",
+			"legacy-code",
+			"dependency-hygiene"
+		]
+	},
+	{
+		name: "documentation",
+		category: "engineering",
+		description: "Documentation, interface reference and decision records that stay useful.",
+		skills: [
+			"technical-writing",
+			"api-documentation",
+			"decision-records"
+		]
+	},
+	{
+		name: "observability",
+		category: "engineering",
+		description: "Logging, metrics, tracing and incident response for running systems.",
+		skills: [
+			"structured-logging",
+			"metrics-and-tracing",
+			"incident-response"
+		],
+		mcpServers: [{
+			name: "sentry",
+			activation: "optional"
+		}]
+	},
+	{
+		name: "data",
+		category: "engineering",
+		description: "Schema design, migrations and transactional correctness.",
+		skills: [
+			"data-modeling",
+			"schema-migrations",
+			"transactions-and-consistency"
+		],
+		mcpServers: [{
+			name: "supabase",
+			activation: "optional"
+		}]
+	},
+	{
+		name: "git",
+		category: "workflow",
+		description: "Commit, branch and pull-request practice for reviewable history.",
+		skills: [
+			"commit-hygiene",
+			"branching-strategy",
+			"pull-requests"
+		],
+		mcpServers: [{
+			name: "github",
+			activation: "optional"
 		}]
+	},
+	{
+		name: "devops",
+		category: "workflow",
+		description: "Continuous integration, containers, deployment safety and infrastructure.",
+		skills: [
+			"ci-pipelines",
+			"containerization",
+			"deployment-safety",
+			"infrastructure-as-code"
+		]
 	}
 ];
 /** 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 +754,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 +933,65 @@ 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",
+	"test-strategy",
+	"test-doubles",
+	"e2e-testing",
+	"flaky-tests",
+	"secure-coding",
+	"secrets-handling",
+	"dependency-security",
+	"auth-patterns",
+	"performance-profiling",
+	"web-vitals",
+	"query-performance",
+	"semantic-html",
+	"aria-patterns",
+	"keyboard-navigation",
+	"refactoring-safely",
+	"legacy-code",
+	"dependency-hygiene",
+	"technical-writing",
+	"api-documentation",
+	"decision-records",
+	"structured-logging",
+	"metrics-and-tracing",
+	"incident-response",
+	"data-modeling",
+	"schema-migrations",
+	"transactions-and-consistency",
+	"commit-hygiene",
+	"branching-strategy",
+	"pull-requests",
+	"ci-pipelines",
+	"containerization",
+	"deployment-safety",
+	"infrastructure-as-code"
 ];
 /** The absolute path of a built-in skill's `SKILL.md`. */
 function builtInSkillPath(name) {
@@ -763,63 +1023,349 @@ 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]
 	};
 }
 //#endregion
+//#region src/manifest/errors.ts
+/** Raised when `.agentyx.lock.json` is not valid JSON. */
+var AgentyxManifestParseError = class extends AgentyxError {
+	filePath;
+	constructor(filePath, reason, options) {
+		super("agentyx_manifest_parse_error", `${filePath} is not valid JSON: ${reason}`, options);
+		this.name = "AgentyxManifestParseError";
+		this.filePath = filePath;
+	}
+};
+/**
+* Raised when the manifest parses as JSON but is not a manifest Agentyx
+* understands.
+*
+* This is never repaired. The manifest is what tells Agentyx which files it is
+* allowed to overwrite and delete, so guessing at a damaged one would be
+* guessing about destructive operations.
+*/
+var AgentyxManifestValidationError = class extends AgentyxError {
+	issues;
+	filePath;
+	constructor(error, filePath) {
+		const issues = toAgentyxIssues(error);
+		const location = filePath === void 0 ? "" : ` in ${filePath}`;
+		const details = issues.map((issue) => `  - ${issue.path}: ${issue.message}`).join("\n");
+		super("agentyx_manifest_invalid", `Invalid Agentyx install manifest${location}:\n${details}\nDelete the file to start from a clean install record.`);
+		this.name = "AgentyxManifestValidationError";
+		this.issues = issues;
+		this.filePath = filePath;
+	}
+};
+//#endregion
+//#region src/manifest/schema.ts
+/**
+* The manifest format version.
+*
+* A manifest written by a newer Agentyx fails validation instead of being
+* reinterpreted, because acting on a half-understood record of managed files is
+* how an installer deletes something it should not.
+*/
+const INSTALL_MANIFEST_VERSION = 1;
+/**
+* A path Agentyx manages, relative to the project root and always written with
+* `/` separators so a manifest reads the same on every platform.
+*/
+const managedPathSchema = z.string().min(1, "Managed paths must be non-empty strings.").refine((value) => !value.startsWith("/"), "Managed paths must be relative to the project root.").refine((value) => !value.includes("\\"), "Managed paths must use `/` separators.").refine((value) => !value.split("/").includes(".."), "Managed paths must not traverse outside the project root.");
+/** A SHA-256 digest of the exact bytes Agentyx last wrote to a managed path. */
+const contentHashSchema = z.string().regex(/^[0-9a-f]{64}$/, "Content hashes must be lowercase hexadecimal SHA-256 digests.");
+const targetsSchema = z.array(z.string().min(1, "Targets must be non-empty strings.")).min(1, "A manifest entry must record at least one target.");
+/** A `SKILL.md` file Agentyx wrote, owned entirely by Agentyx. */
+const skillManifestEntrySchema = z.strictObject({
+	kind: z.literal("skill"),
+	path: managedPathSchema,
+	skill: z.string().min(1, "Skill names must be non-empty strings."),
+	targets: targetsSchema,
+	hash: contentHashSchema
+});
+/**
+* A provider MCP configuration file Agentyx contributed entries to.
+*
+* Unlike a skill file this one is shared with the user, so the entry records
+* the server keys Agentyx added rather than claiming the whole document.
+* `created` says whether the file existed before Agentyx first wrote it, which
+* is the only thing that makes removing the file itself safe.
+*/
+const mcpManifestEntrySchema = z.strictObject({
+	kind: z.literal("mcp"),
+	path: managedPathSchema,
+	servers: z.array(z.string().min(1, "MCP server names must be non-empty strings.")),
+	targets: targetsSchema,
+	hash: contentHashSchema,
+	created: z.boolean()
+});
+const installManifestEntrySchema = z.discriminatedUnion("kind", [skillManifestEntrySchema, mcpManifestEntrySchema]);
+/** The `.agentyx.lock.json` record of everything Agentyx installed into a project. */
+const installManifestSchema = z.strictObject({
+	version: z.literal(1),
+	entries: z.array(installManifestEntrySchema).default([])
+});
+//#endregion
+//#region src/manifest/io.ts
+const AGENTYX_MANIFEST_FILENAME = ".agentyx.lock.json";
+/** The absolute path `.agentyx.lock.json` is read from for a given project. */
+function agentyxManifestPath(projectPath = process.cwd()) {
+	return resolve(projectPath, AGENTYX_MANIFEST_FILENAME);
+}
+/** A manifest that claims nothing — what a project has before its first install. */
+function emptyInstallManifest() {
+	return {
+		version: 1,
+		entries: []
+	};
+}
+/**
+* The SHA-256 digest Agentyx records for managed content.
+*
+* Comparing this digest with the file on disk is what separates "Agentyx wrote
+* this and may replace it" from "someone else owns this file", so it is
+* computed over the exact bytes written, never over a normalised form.
+*/
+function hashContent(content) {
+	return createHash("sha256").update(content, "utf8").digest("hex");
+}
+/**
+* Validates an already-parsed manifest document.
+*
+* @throws {AgentyxManifestValidationError} when the document violates the schema.
+*/
+function parseInstallManifest(value, filePath) {
+	const result = installManifestSchema.safeParse(value);
+	if (!result.success) throw new AgentyxManifestValidationError(result.error, filePath);
+	return result.data;
+}
+/**
+* Reads `.agentyx.lock.json` from `projectPath`.
+*
+* A missing manifest is a legitimate state — the project has simply never been
+* installed into — and yields an empty manifest. A manifest that exists but
+* cannot be understood is a hard failure: it governs which files Agentyx may
+* overwrite and delete, and a damaged one is never guessed at.
+*
+* @throws {AgentyxManifestParseError} when the file is not valid JSON.
+* @throws {AgentyxManifestValidationError} when the document violates the schema.
+*/
+async function loadInstallManifest(projectPath = process.cwd()) {
+	const filePath = agentyxManifestPath(projectPath);
+	let contents;
+	try {
+		contents = await readFile(filePath, "utf8");
+	} catch (cause) {
+		if (cause instanceof Error && cause.code === "ENOENT") return emptyInstallManifest();
+		throw cause;
+	}
+	let document;
+	try {
+		document = JSON.parse(contents);
+	} catch (cause) {
+		throw new AgentyxManifestParseError(filePath, cause instanceof Error ? cause.message : String(cause), { cause });
+	}
+	return parseInstallManifest(document, filePath);
+}
+/**
+* Serialises a manifest for writing.
+*
+* Entries and their lists are sorted so that reinstalling an unchanged project
+* produces a byte-identical file and the manifest never shows up as noise in a
+* diff. Writing is deliberately not done here — only the install executor
+* 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)
+	}).sort((left, right) => left.path.localeCompare(right.path));
+	return `${JSON.stringify({
+		version: manifest.version,
+		entries
+	}, null, 2)}\n`;
+}
+/**
+* Indexes manifest entries by managed path.
+*
+* Every ownership question — may this file be overwritten, may it be deleted —
+* is a lookup by path, so callers do not scan the list themselves.
+*/
+function manifestEntriesByPath(manifest) {
+	return new Map(manifest.entries.map((entry) => [entry.path, entry]));
+}
+function sorted(values) {
+	return [...values].sort();
+}
+//#endregion
 //#region src/meta.ts
 const agentyxCoreName = "agentyx-core";
 function getCoreStatus() {
@@ -844,7 +1390,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 +1402,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 +1527,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, 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 };
 
 //# sourceMappingURL=index.mjs.map