@agentyx/core 0.1.0 → 0.2.0

package/README.md

@@ -1,60 +1,47 @@
 # @agentyx/core
 
-Domain foundations for [Agentyx](https://github.com/Andersseen/agentyx): the `.agentyx.json` configuration
-model, stack definitions, built-in stack/skill/MCP registries, optimization profiles, and
-resolution.
+Domain foundations for Agentyx: `.agentyx.json` parsing, pack definitions, built-in Skill/MCP/tool
+registries, project detection, JSON Schema generation, and provider-neutral resolution.
 
-This package has no dependency on Commander or any terminal UI — CLI concerns live in
-[`@agentyx/cli`](https://github.com/Andersseen/agentyx/tree/main/packages/cli).
+This package has no dependency on Commander or terminal UI. CLI concerns live in `@agentyx/cli`, and
+provider filesystem writes live in `@agentyx/adapters`.
 
 ```ts
 import {
-  builtInSkillRegistry,
-  builtInStacks,
+  builtInPacks,
   loadAgentyxConfig,
   resolveAgentyxConfig,
-  resolveStackMcpServerReferences,
-  resolveStacks,
-  resolveStackSkills,
+  resolvePackSkills,
+  resolvePacks,
 } from "@agentyx/core";
 
-resolveStacks(["angular"]);
-// ["core", "typescript", "angular"]
+builtInPacks.map((pack) => pack.name);
+// ["technical", "typescript", "angular", "efficiency", "agentic"]
 
-resolveStackSkills(["angular"]);
-// ["planning", "systematic-debugging", "verification", "typescript-modern", "angular-modern"]
+resolvePacks(["technical", "typescript", "angular"]);
+// ["technical", "typescript", "angular"]
 
-resolveStackMcpServerReferences(["angular"]);
-// [{ name: "context7", level: "recommended" }]
+resolvePackSkills(["typescript"]);
+// ["typescript-strict", "typescript-modeling", "typescript-modern"]
 
 resolveAgentyxConfig(await loadAgentyxConfig(process.cwd()));
-// { requestedStacks, resolvedStacks, skills, declaredMcpServers, mcpServers, profile, targets }
+// { requestedPacks, resolvedPacks, skills, declaredMcpServers, mcpServers, declaredTools, tools, enabled, targets }
 ```
 
-## Skills
+Packs are composable capability bundles. They can contribute default Skills, default MCP servers, and
+optional MCP/tool capabilities. Optional capabilities are active only when their identifier appears
+in `enable`.
 
-A skill is provider-independent instruction text: `{ name, description, content }` and nothing else.
-The built-in skills ship as `SKILL.md` files under `skills/`, with YAML frontmatter for the metadata
-and the Markdown body as the content, and are published alongside `dist/`.
-
-Resolution works on identifiers, and `SkillRegistry.get(name)` is what reads a body:
-
-```ts
-builtInSkillRegistry.names; // identifiers, no file is read
-builtInSkillRegistry.has("planning"); // no file is read
-builtInSkillRegistry.get("planning"); // reads, validates and caches SKILL.md
+```json
+{
+  "packs": ["technical", "typescript", "efficiency"],
+  "enable": ["rtk"],
+  "targets": ["codex"]
+}
 ```
 
-`createSkillRegistry(sources)` builds an independent registry from `{ name, load }` sources — the
-seam an external registry would use later. `parseSkillMarkdown(markdown, origin)` parses one
-`SKILL.md`, and `formatSkillMarkdown(skill)` renders one deterministically. That serializer is the
-canonical form every provider installs, which is why it lives here: an adapter decides where a skill
-goes, never what it says.
-
-MCP resolution keeps both declared and effective capabilities visible. Profiles are provider-neutral:
-`lean` enables essential MCP only, `balanced` enables essential and recommended MCP, and
-`autonomous` enables essential, recommended and optional MCP. Skill identifiers are not filtered by
-profile.
+Skills ship as `SKILL.md` assets under `skills/`. Resolution returns identifiers only; a Skill body
+is read only when `SkillRegistry.get(name)` is called.
 
 The JSON Schema for `.agentyx.json` ships with the package:
 
@@ -64,14 +51,8 @@ The JSON Schema for `.agentyx.json` ships with the package:
 }
 ```
 
-Resolution failures throw domain errors — `UnknownStackError`, `CircularStackDependencyError`,
-`UnknownSkillError`, `DuplicateSkillError`, `InvalidSkillError`, `AgentyxConfigNotFoundError`,
-`AgentyxConfigParseError`, `AgentyxConfigValidationError` — all extending `AgentyxError` with a stable
-`code`.
-
-Installing skills and effective MCP capabilities into an agent is
-[`@agentyx/adapters`](https://github.com/Andersseen/agentyx/tree/main/packages/adapters); core knows
-nothing about providers. See the [main README](https://github.com/Andersseen/agentyx#readme) for the
-full picture.
+Resolution failures throw domain errors extending `AgentyxError`, including `UnknownPackError`,
+`UnknownEnabledCapabilityError`, `UnknownSkillError`, `UnknownMcpServerError`, and
+`UnknownToolError`.
 
 MIT © Andersseen

package/dist/index.d.mts

@@ -36,6 +36,11 @@ declare class AgentyxConfigValidationError extends AgentyxError {
   readonly filePath: string | undefined;
   constructor(error: ZodError, filePath?: string);
 }
+declare class UnknownEnabledCapabilityError extends AgentyxError {
+  readonly capabilityName: string;
+  readonly knownCapabilities: readonly string[];
+  constructor(capabilityName: string, knownCapabilities: readonly string[]);
+}
 //#endregion
 //#region src/config/json-schema.d.ts
 /** Canonical identifier of the published `.agentyx.json` schema. */
@@ -51,25 +56,17 @@ declare const AGENTYX_CONFIG_SCHEMA_ID = "https://agentyx.dev/schema/agentyx.sch
 declare function buildAgentyxConfigJsonSchema(): Record<string, unknown>;
 //#endregion
 //#region src/config/schema.d.ts
-/** How much autonomy the generated environment should grant an agent. */
-declare const AGENTYX_PROFILES: readonly ["lean", "balanced", "autonomous"];
-declare const agentyxProfileSchema: z.ZodEnum<{
-  lean: "lean";
-  balanced: "balanced";
-  autonomous: "autonomous";
-}>;
-type AgentyxProfile = z.infer<typeof agentyxProfileSchema>;
-/** Applied when a configuration omits `profile`. */
-declare const DEFAULT_AGENTYX_PROFILE: AgentyxProfile;
+/**
+ * Targets stay free-form strings on purpose: third-party adapters should be
+ * able to register providers without a change to this schema.
+ */
+declare const agentyxTargetSchema: z.ZodString;
+declare const enabledCapabilityNameSchema: z.ZodString;
 /** The `.agentyx.json` project configuration. */
 declare const agentyxConfigSchema: z.ZodObject<{
   $schema: z.ZodOptional<z.ZodString>;
-  extends: z.ZodDefault<z.ZodArray<z.ZodString>>;
-  profile: z.ZodDefault<z.ZodEnum<{
-    lean: "lean";
-    balanced: "balanced";
-    autonomous: "autonomous";
-  }>>;
+  packs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  enable: z.ZodDefault<z.ZodArray<z.ZodString>>;
   targets: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
 /** A validated configuration, with defaults applied. */
@@ -100,11 +97,10 @@ declare function parseAgentyxConfig(value: unknown, filePath?: string): AgentyxC
 declare function loadAgentyxConfig(projectPath?: string): Promise<AgentyxConfig>;
 //#endregion
 //#region src/mcp/schema.d.ts
-declare const MCP_CAPABILITY_LEVELS: readonly ["essential", "recommended", "optional"];
+declare const MCP_CAPABILITY_LEVELS: readonly ["default", "optional"];
 declare const mcpCapabilityLevelSchema: z.ZodEnum<{
   optional: "optional";
-  essential: "essential";
-  recommended: "recommended";
+  default: "default";
 }>;
 declare const MCP_CONTEXT_COSTS: readonly ["low", "medium", "high"];
 declare const mcpContextCostSchema: z.ZodEnum<{
@@ -117,23 +113,21 @@ declare const mcpEnvReferenceSchema: z.ZodObject<{
 }, z.core.$strict>;
 declare const mcpServerReferenceSchema: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
   name: z.ZodString;
-  level: z.ZodDefault<z.ZodEnum<{
+  activation: z.ZodDefault<z.ZodEnum<{
     optional: "optional";
-    essential: "essential";
-    recommended: "recommended";
+    default: "default";
   }>>;
 }, z.core.$strict>]>, z.ZodTransform<{
   name: string;
-  level: "optional" | "essential" | "recommended";
+  activation: "optional" | "default";
 }, string | {
   name: string;
-  level: "optional" | "essential" | "recommended";
+  activation: "optional" | "default";
 }>>, z.ZodObject<{
   name: z.ZodString;
-  level: z.ZodEnum<{
+  activation: z.ZodEnum<{
     optional: "optional";
-    essential: "essential";
-    recommended: "recommended";
+    default: "default";
   }>;
 }, z.core.$strict>>;
 declare const mcpServerDefinitionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -191,6 +185,94 @@ interface McpServerRegistry {
 }
 declare function createMcpServerRegistry(sources: Iterable<McpServerSource>): McpServerRegistry;
 //#endregion
+//#region src/pack/schema.d.ts
+declare const PACK_CATEGORIES: readonly ["engineering", "language", "framework", "efficiency", "workflow"];
+declare const packCategorySchema: z.ZodEnum<{
+  engineering: "engineering";
+  language: "language";
+  framework: "framework";
+  efficiency: "efficiency";
+  workflow: "workflow";
+}>;
+/**
+ * Pack names are plain identifiers. They are intentionally not constrained to
+ * a closed list so that external registries can contribute packs later.
+ */
+declare const packNameSchema: z.ZodString;
+/** A pack is a composable provider-neutral capability bundle. */
+declare const packDefinitionSchema: z.ZodObject<{
+  name: z.ZodString;
+  category: z.ZodDefault<z.ZodEnum<{
+    engineering: "engineering";
+    language: "language";
+    framework: "framework";
+    efficiency: "efficiency";
+    workflow: "workflow";
+  }>>;
+  description: z.ZodOptional<z.ZodString>;
+  skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  mcpServers: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    activation: z.ZodDefault<z.ZodEnum<{
+      optional: "optional";
+      default: "default";
+    }>>;
+  }, z.core.$strict>]>, z.ZodTransform<{
+    name: string;
+    activation: "optional" | "default";
+  }, string | {
+    name: string;
+    activation: "optional" | "default";
+  }>>, z.ZodObject<{
+    name: z.ZodString;
+    activation: z.ZodEnum<{
+      optional: "optional";
+      default: "default";
+    }>;
+  }, z.core.$strict>>>>;
+  tools: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    name: z.ZodString;
+    activation: z.ZodDefault<z.ZodEnum<{
+      optional: "optional";
+      default: "default";
+    }>>;
+  }, z.core.$strict>]>, z.ZodTransform<{
+    name: string;
+    activation: "optional" | "default";
+  }, string | {
+    name: string;
+    activation: "optional" | "default";
+  }>>, z.ZodObject<{
+    name: z.ZodString;
+    activation: z.ZodEnum<{
+      optional: "optional";
+      default: "default";
+    }>;
+  }, z.core.$strict>>>>;
+}, z.core.$strict>;
+/** A validated pack definition, with defaults always present. */
+type PackDefinition = z.infer<typeof packDefinitionSchema>;
+type PackCategory = z.infer<typeof packCategorySchema>;
+/** The shape accepted when authoring a pack definition. */
+type PackDefinitionInput = z.input<typeof packDefinitionSchema>;
+//#endregion
+//#region src/pack/registry.d.ts
+/**
+ * A registry is a name lookup over pack definitions. Keeping it a plain map
+ * means the resolver stays independent of where definitions come from, so
+ * external registries can be added later without touching resolution.
+ */
+type PackRegistry = ReadonlyMap<string, PackDefinition>;
+/** Validates definitions and indexes them by name. */
+declare function createPackRegistry(definitions: Iterable<PackDefinitionInput>): PackRegistry;
+/**
+ * The packs Agentyx ships with, expressed as data. Relationships live here, not
+ * in the resolver.
+ */
+declare const builtInPacks: readonly PackDefinitionInput[];
+/** The registry used by default when no explicit registry is supplied. */
+declare const builtInPackRegistry: PackRegistry;
+//#endregion
 //#region src/skill/schema.d.ts
 /**
  * A Skill is reusable instruction text for a coding agent. It is deliberately
@@ -244,86 +326,94 @@ interface SkillRegistry {
  */
 declare function createSkillRegistry(sources: Iterable<SkillSource>): SkillRegistry;
 //#endregion
-//#region src/stack/schema.d.ts
-/**
- * A stack describes a development environment that can build on other stacks
- * and contribute provider-agnostic capabilities to them.
- */
-declare const stackDefinitionSchema: z.ZodObject<{
+//#region src/tool/schema.d.ts
+declare const TOOL_ACTIVATION_LEVELS: readonly ["default", "optional"];
+declare const toolActivationLevelSchema: z.ZodEnum<{
+  optional: "optional";
+  default: "default";
+}>;
+declare const toolNameSchema: z.ZodString;
+declare const toolReferenceSchema: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
   name: z.ZodString;
-  description: z.ZodOptional<z.ZodString>;
-  extends: z.ZodDefault<z.ZodArray<z.ZodString>>;
-  skills: z.ZodDefault<z.ZodArray<z.ZodString>>;
-  mcpServers: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-    name: z.ZodString;
-    level: z.ZodDefault<z.ZodEnum<{
-      optional: "optional";
-      essential: "essential";
-      recommended: "recommended";
-    }>>;
-  }, z.core.$strict>]>, z.ZodTransform<{
-    name: string;
-    level: "optional" | "essential" | "recommended";
-  }, string | {
-    name: string;
-    level: "optional" | "essential" | "recommended";
-  }>>, z.ZodObject<{
-    name: z.ZodString;
-    level: z.ZodEnum<{
-      optional: "optional";
-      essential: "essential";
-      recommended: "recommended";
-    }>;
-  }, z.core.$strict>>>>;
+  activation: z.ZodDefault<z.ZodEnum<{
+    optional: "optional";
+    default: "default";
+  }>>;
+}, z.core.$strict>]>, z.ZodTransform<{
+  name: string;
+  activation: "optional" | "default";
+}, string | {
+  name: string;
+  activation: "optional" | "default";
+}>>, z.ZodObject<{
+  name: z.ZodString;
+  activation: z.ZodEnum<{
+    optional: "optional";
+    default: "default";
+  }>;
+}, z.core.$strict>>;
+declare const toolDefinitionSchema: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodString;
+  kind: z.ZodLiteral<"executable">;
+  command: z.ZodString;
+  optional: z.ZodDefault<z.ZodBoolean>;
+  installHint: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
-/** A validated stack definition, with defaults always present. */
-type StackDefinition = z.infer<typeof stackDefinitionSchema>;
-/** The shape accepted when authoring a stack definition. */
-type StackDefinitionInput = z.input<typeof stackDefinitionSchema>;
+type ToolActivationLevel = z.infer<typeof toolActivationLevelSchema>;
+type ToolDefinition = z.infer<typeof toolDefinitionSchema>;
+type ToolDefinitionInput = z.input<typeof toolDefinitionSchema>;
+type ToolReference = z.infer<typeof toolReferenceSchema>;
+type ToolReferenceInput = z.input<typeof toolReferenceSchema>;
 //#endregion
-//#region src/stack/registry.d.ts
-/**
- * A registry is a name lookup over stack definitions. Keeping it a plain map
- * means the resolver stays independent of where definitions come from, so
- * external registries can be added later without touching resolution.
- */
-type StackRegistry = ReadonlyMap<string, StackDefinition>;
-/** Validates definitions and indexes them by name. */
-declare function createStackRegistry(definitions: Iterable<StackDefinitionInput>): StackRegistry;
-/**
- * The stacks Agentyx ships with, expressed as data. Relationships live here, not
- * in the resolver.
- */
-declare const builtInStacks: readonly StackDefinitionInput[];
-/** The registry used by default when no explicit registry is supplied. */
-declare const builtInStackRegistry: StackRegistry;
+//#region src/tool/registry.d.ts
+interface ToolSource {
+  readonly name: string;
+  load(): ToolDefinitionInput;
+}
+interface ToolMetadata {
+  readonly name: string;
+  readonly description: string;
+  readonly kind: ToolDefinition["kind"];
+  readonly command: string;
+  readonly optional: boolean;
+}
+interface ToolRegistry {
+  readonly names: readonly string[];
+  has(name: string): boolean;
+  listMetadata(): readonly ToolMetadata[];
+  get(name: string): ToolDefinition;
+}
+declare function createToolRegistry(sources: Iterable<ToolSource>): ToolRegistry;
 //#endregion
 //#region src/config/resolver.d.ts
-/** A project configuration with its stack inheritance expanded. */
+/** A project configuration with its pack inheritance expanded. */
 interface ResolvedAgentyxConfig {
-  /** The stacks the project asked for, in configuration order. */
-  readonly requestedStacks: readonly string[];
-  /** The full inheritance chain, dependency-first and de-duplicated. */
-  readonly resolvedStacks: readonly string[];
+  /** The packs the project asked for, in configuration order. */
+  readonly requestedPacks: readonly string[];
+  /** Selected packs, de-duplicated while preserving configuration order. */
+  readonly resolvedPacks: readonly string[];
   /**
-   * Skill identifiers contributed by the resolved stacks, in resolution order.
+   * Skill identifiers contributed by the resolved packs, in resolution order.
    * Identifiers only — reading the instructions is a separate, explicit step.
    */
   readonly skills: readonly string[];
   readonly declaredMcpServers: readonly McpServerReference[];
   readonly mcpServers: readonly string[];
-  readonly profile: AgentyxProfile;
+  readonly declaredTools: readonly ToolReference[];
+  readonly tools: readonly string[];
+  readonly enabled: readonly string[];
   readonly targets: readonly string[];
 }
 /**
- * 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.
  */
-declare function resolveAgentyxConfig(config: AgentyxConfig, registry?: StackRegistry, skillRegistry?: SkillRegistry, mcpRegistry?: McpServerRegistry): ResolvedAgentyxConfig;
+declare function resolveAgentyxConfig(config: AgentyxConfig, registry?: PackRegistry, skillRegistry?: SkillRegistry, mcpRegistry?: McpServerRegistry, toolRegistry?: ToolRegistry): ResolvedAgentyxConfig;
 //#endregion
 //#region src/mcp/built-in.d.ts
 declare const builtInMcpServerRegistry: McpServerRegistry;
@@ -347,27 +437,46 @@ declare class InvalidMcpServerError extends AgentyxError {
 }
 //#endregion
 //#region src/mcp/resolver.d.ts
-declare function collectStackMcpServerReferences(resolvedStacks: readonly string[], stackRegistry: StackRegistry, mcpRegistry: McpServerRegistry): McpServerReference[];
-declare function filterEffectiveMcpServers(servers: readonly McpServerReference[], profile: AgentyxProfile): string[];
-declare function collectStackMcpServers(resolvedStacks: readonly string[], stackRegistry: StackRegistry, mcpRegistry: McpServerRegistry, profile?: AgentyxProfile): string[];
-declare function resolveStackMcpServerReferences(requestedStacks: readonly string[], stackRegistry?: StackRegistry, mcpRegistry?: McpServerRegistry): McpServerReference[];
-declare function resolveStackMcpServers(requestedStacks: readonly string[], stackRegistry?: StackRegistry, mcpRegistry?: McpServerRegistry, profile?: AgentyxProfile): string[];
+declare function collectPackMcpServerReferences(resolvedPacks: readonly string[], packRegistry: PackRegistry, mcpRegistry: McpServerRegistry): McpServerReference[];
+declare function filterEffectiveMcpServers(servers: readonly McpServerReference[], enabledCapabilities: readonly string[]): string[];
+declare function collectPackMcpServers(resolvedPacks: readonly string[], packRegistry: PackRegistry, mcpRegistry: McpServerRegistry, enabledCapabilities?: readonly string[]): string[];
+declare function resolvePackMcpServerReferences(requestedPacks: readonly string[], packRegistry?: PackRegistry, mcpRegistry?: McpServerRegistry): McpServerReference[];
+declare function resolvePackMcpServers(requestedPacks: readonly string[], packRegistry?: PackRegistry, mcpRegistry?: McpServerRegistry, enabledCapabilities?: readonly string[]): string[];
 //#endregion
 //#region src/meta.d.ts
 declare const agentyxCoreName = "agentyx-core";
 declare function getCoreStatus(): string;
 //#endregion
-//#region src/optimization/profile.d.ts
-interface OptimizationProfileDefinition {
-  readonly name: AgentyxProfile;
-  readonly goal: string;
-  readonly mcpLevels: readonly McpCapabilityLevel[];
-  readonly notes: readonly string[];
+//#region src/pack/errors.d.ts
+/** Raised when a requested pack is not present in the registry. */
+declare class UnknownPackError extends AgentyxError {
+  readonly packName: string;
+  readonly requiredBy: string | undefined;
+  readonly knownPacks: readonly string[];
+  constructor(packName: string, requiredBy: string | undefined, knownPacks: readonly string[]);
 }
-declare const optimizationProfiles: readonly OptimizationProfileDefinition[];
-declare const optimizationProfileNames: readonly AgentyxProfile[];
-declare function getOptimizationProfile(name: AgentyxProfile): OptimizationProfileDefinition;
-declare function isMcpLevelEnabled(profile: AgentyxProfile, level: McpCapabilityLevel): boolean;
+/** @deprecated Packs no longer inherit from other packs. */
+declare class CircularPackDependencyError extends AgentyxError {
+  /** The cycle path, starting and ending with the same pack. */
+  readonly cycle: readonly string[];
+  constructor(cycle: readonly string[]);
+}
+/** Raised when a registry is built from definitions that reuse a pack name. */
+declare class DuplicatePackError extends AgentyxError {
+  readonly packName: string;
+  constructor(packName: string);
+}
+//#endregion
+//#region src/pack/resolver.d.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.
+ */
+declare function resolvePacks(requestedPacks: readonly string[], registry?: PackRegistry): string[];
 //#endregion
 //#region src/project/detector.d.ts
 declare const PACKAGE_MANAGERS: readonly ["pnpm", "npm", "yarn", "bun"];
@@ -390,13 +499,13 @@ interface ProjectDetection {
   readonly projectDir: string;
   readonly packageJson: ProjectPackageJsonDetection;
   readonly packageManager: PackageManagerDetection;
-  readonly detectedStacks: readonly string[];
-  readonly recommendedStack: string | undefined;
+  readonly detectedPacks: readonly string[];
+  readonly recommendedPacks: readonly string[];
 }
 declare function detectProject(projectDir: string): Promise<ProjectDetection>;
 declare function buildAgentyxConfig(input: {
-  readonly stack: string;
-  readonly profile: AgentyxProfile;
+  readonly packs: readonly string[];
+  readonly enable?: readonly string[];
   readonly targets: readonly string[];
 }): AgentyxConfigInput;
 declare function formatAgentyxConfig(config: AgentyxConfigInput): string;
@@ -405,22 +514,22 @@ declare function formatAgentyxConfig(config: AgentyxConfigInput): string;
 /**
  * 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.
  */
-declare const builtInSkillNames: readonly ["planning", "systematic-debugging", "verification", "typescript-modern", "angular-modern"];
+declare const builtInSkillNames: readonly ["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-signals", "angular-architecture", "angular-testing", "context-efficient-development", "concise-output", "targeted-exploration", "focused-verification"];
 /** The registry used by default when no explicit registry is supplied. */
 declare const builtInSkillRegistry: SkillRegistry;
 //#endregion
 //#region src/skill/errors.d.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`.
  */
 declare class UnknownSkillError extends AgentyxError {
   readonly skillName: string;
-  /** The stack that declared the skill, when the failure came from resolution. */
+  /** The pack that declared the skill, when the failure came from resolution. */
   readonly requiredBy: string | undefined;
   readonly knownSkills: readonly string[];
   constructor(skillName: string, requiredBy: string | undefined, knownSkills: readonly string[]);
@@ -487,55 +596,41 @@ declare function formatSkillMarkdown(skill: SkillDefinitionInput): string;
 //#endregion
 //#region src/skill/resolver.d.ts
 /**
- * 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.
  */
-declare function resolveStackSkills(requestedStacks: readonly string[], stackRegistry?: StackRegistry, skillRegistry?: SkillRegistry): string[];
+declare function resolvePackSkills(requestedPacks: readonly string[], packRegistry?: PackRegistry, skillRegistry?: SkillRegistry): string[];
 //#endregion
-//#region src/stack/errors.d.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`.
- */
-declare class UnknownStackError extends AgentyxError {
-  readonly stackName: string;
+//#region src/tool/built-in.d.ts
+declare const builtInToolRegistry: ToolRegistry;
+declare const builtInToolNames: readonly string[];
+//#endregion
+//#region src/tool/errors.d.ts
+declare class UnknownToolError extends AgentyxError {
+  readonly toolName: string;
   readonly requiredBy: string | undefined;
-  readonly knownStacks: readonly string[];
-  constructor(stackName: string, requiredBy: string | undefined, knownStacks: readonly string[]);
+  readonly knownTools: readonly string[];
+  constructor(toolName: string, requiredBy: string | undefined, knownTools: readonly string[]);
 }
-/** Raised when stack inheritance forms a cycle. */
-declare class CircularStackDependencyError extends AgentyxError {
-  /** The cycle path, starting and ending with the same stack. */
-  readonly cycle: readonly string[];
-  constructor(cycle: readonly string[]);
+declare class DuplicateToolError extends AgentyxError {
+  readonly toolName: string;
+  constructor(toolName: string);
 }
-/** Raised when a registry is built from definitions that reuse a stack name. */
-declare class DuplicateStackError extends AgentyxError {
-  readonly stackName: string;
-  constructor(stackName: string);
+declare class InvalidToolError extends AgentyxError {
+  constructor(origin: string, reason: unknown, options?: ErrorOptions);
 }
 //#endregion
-//#region src/stack/resolver.d.ts
-/**
- * Expands the requested stacks into the full inheritance chain.
- *
- * 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.
- *
- * @throws {UnknownStackError} when a requested or inherited stack is missing.
- * @throws {CircularStackDependencyError} when inheritance forms a cycle.
- */
-declare function resolveStacks(requestedStacks: readonly string[], registry?: StackRegistry): string[];
+//#region src/tool/resolver.d.ts
+declare function collectPackToolReferences(resolvedPacks: readonly string[], packRegistry: PackRegistry, toolRegistry: ToolRegistry): ToolReference[];
+declare function filterEffectiveTools(tools: readonly ToolReference[], enabledCapabilities: readonly string[]): string[];
+declare function resolvePackToolReferences(requestedPacks: readonly string[], packRegistry?: PackRegistry, toolRegistry?: ToolRegistry): ToolReference[];
+declare function resolvePackTools(requestedPacks: readonly string[], packRegistry?: PackRegistry, toolRegistry?: ToolRegistry, enabledCapabilities?: readonly string[]): string[];
 //#endregion
-export { AGENTYX_CONFIG_FILENAME, AGENTYX_CONFIG_SCHEMA_ID, AGENTYX_PROFILES, type AgentyxConfig, type AgentyxConfigInput, type AgentyxConfigIssue, AgentyxConfigNotFoundError, AgentyxConfigParseError, AgentyxConfigValidationError, AgentyxError, type AgentyxProfile, CircularStackDependencyError, DEFAULT_AGENTYX_PROFILE, DuplicateMcpServerError, DuplicateSkillError, DuplicateStackError, InvalidMcpServerError, InvalidSkillError, MCP_CAPABILITY_LEVELS, MCP_CONTEXT_COSTS, type McpCapabilityLevel, type McpContextCost, type McpEnvReference, type McpServerDefinition, type McpServerDefinitionInput, type McpServerMetadata, type McpServerReference, type McpServerReferenceInput, type McpServerRegistry, type McpServerSource, type OptimizationProfileDefinition, PACKAGE_MANAGERS, type PackageManagerDetection, type PackageManagerName, type ProjectDetection, type ProjectPackageJsonDetection, type ResolvedAgentyxConfig, type SkillDefinition, type SkillDefinitionInput, type SkillRegistry, type SkillSource, type StackDefinition, type StackDefinitionInput, type StackRegistry, 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, type AgentyxConfig, type AgentyxConfigInput, type AgentyxConfigIssue, AgentyxConfigNotFoundError, AgentyxConfigParseError, AgentyxConfigValidationError, AgentyxError, CircularPackDependencyError, DuplicateMcpServerError, DuplicatePackError, DuplicateSkillError, DuplicateToolError, InvalidMcpServerError, InvalidSkillError, InvalidToolError, MCP_CAPABILITY_LEVELS, MCP_CONTEXT_COSTS, type McpCapabilityLevel, type McpContextCost, type McpEnvReference, type McpServerDefinition, type McpServerDefinitionInput, type McpServerMetadata, type McpServerReference, type McpServerReferenceInput, type McpServerRegistry, type McpServerSource, PACKAGE_MANAGERS, PACK_CATEGORIES, type PackCategory, type PackDefinition, type PackDefinitionInput, type PackRegistry, type PackageManagerDetection, type PackageManagerName, type ProjectDetection, type ProjectPackageJsonDetection, type ResolvedAgentyxConfig, type SkillDefinition, type SkillDefinitionInput, type SkillRegistry, type SkillSource, TOOL_ACTIVATION_LEVELS, type ToolActivationLevel, type ToolDefinition, type ToolDefinitionInput, type ToolMetadata, type ToolReference, type ToolReferenceInput, type ToolRegistry, type ToolSource, 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.d.mts.map