@agentyx/core 0.1.1 → 0.3.0

package/dist/index.d.mts

@@ -12,13 +12,17 @@ declare class AgentyxError extends Error {
   constructor(code: string, message: string, options?: ErrorOptions);
 }
 //#endregion
-//#region src/config/errors.d.ts
-/** A single configuration problem, addressed by its location in the document. */
-interface AgentyxConfigIssue {
+//#region src/issues.d.ts
+/** A single problem in an Agentyx document, addressed by its location in it. */
+interface AgentyxIssue {
   /** Dotted path to the offending value, or `(root)` for the document itself. */
   readonly path: string;
   readonly message: string;
 }
+//#endregion
+//#region src/config/errors.d.ts
+/** A single configuration problem, addressed by its location in the document. */
+type AgentyxConfigIssue = AgentyxIssue;
 /** Raised when the supplied directory has no `.agentyx.json`. */
 declare class AgentyxConfigNotFoundError extends AgentyxError {
   readonly filePath: string;
@@ -36,6 +40,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 +60,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 +101,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 +117,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 +189,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 +330,236 @@ 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?: PackRegistry, skillRegistry?: SkillRegistry, mcpRegistry?: McpServerRegistry, toolRegistry?: ToolRegistry): ResolvedAgentyxConfig;
+//#endregion
+//#region src/manifest/errors.d.ts
+/** Raised when `.agentyx.lock.json` is not valid JSON. */
+declare class AgentyxManifestParseError extends AgentyxError {
+  readonly filePath: string;
+  constructor(filePath: string, reason: string, options?: ErrorOptions);
+}
+/**
+ * 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.
  */
-declare function resolveAgentyxConfig(config: AgentyxConfig, registry?: StackRegistry, skillRegistry?: SkillRegistry, mcpRegistry?: McpServerRegistry): ResolvedAgentyxConfig;
+declare class AgentyxManifestValidationError extends AgentyxError {
+  readonly issues: readonly AgentyxIssue[];
+  readonly filePath: string | undefined;
+  constructor(error: ZodError, filePath?: string);
+}
+//#endregion
+//#region src/manifest/schema.d.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.
+ */
+declare const INSTALL_MANIFEST_VERSION = 1;
+/** A `SKILL.md` file Agentyx wrote, owned entirely by Agentyx. */
+declare const skillManifestEntrySchema: z.ZodObject<{
+  kind: z.ZodLiteral<"skill">;
+  path: z.ZodString;
+  skill: z.ZodString;
+  targets: z.ZodArray<z.ZodString>;
+  hash: z.ZodString;
+}, z.core.$strict>;
+/**
+ * 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.
+ */
+declare const mcpManifestEntrySchema: z.ZodObject<{
+  kind: z.ZodLiteral<"mcp">;
+  path: z.ZodString;
+  servers: z.ZodArray<z.ZodString>;
+  targets: z.ZodArray<z.ZodString>;
+  hash: z.ZodString;
+  created: z.ZodBoolean;
+}, z.core.$strict>;
+declare const installManifestEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"skill">;
+  path: z.ZodString;
+  skill: z.ZodString;
+  targets: z.ZodArray<z.ZodString>;
+  hash: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  kind: z.ZodLiteral<"mcp">;
+  path: z.ZodString;
+  servers: z.ZodArray<z.ZodString>;
+  targets: z.ZodArray<z.ZodString>;
+  hash: z.ZodString;
+  created: z.ZodBoolean;
+}, z.core.$strict>], "kind">;
+/** The `.agentyx.lock.json` record of everything Agentyx installed into a project. */
+declare const installManifestSchema: z.ZodObject<{
+  version: z.ZodLiteral<1>;
+  entries: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"skill">;
+    path: z.ZodString;
+    skill: z.ZodString;
+    targets: z.ZodArray<z.ZodString>;
+    hash: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"mcp">;
+    path: z.ZodString;
+    servers: z.ZodArray<z.ZodString>;
+    targets: z.ZodArray<z.ZodString>;
+    hash: z.ZodString;
+    created: z.ZodBoolean;
+  }, z.core.$strict>], "kind">>>;
+}, z.core.$strict>;
+type SkillManifestEntry = z.infer<typeof skillManifestEntrySchema>;
+type McpManifestEntry = z.infer<typeof mcpManifestEntrySchema>;
+type InstallManifestEntry = z.infer<typeof installManifestEntrySchema>;
+/** A validated manifest, with defaults applied. */
+type InstallManifest = z.infer<typeof installManifestSchema>;
+/** The shape accepted in a `.agentyx.lock.json` file. */
+type InstallManifestInput = z.input<typeof installManifestSchema>;
+//#endregion
+//#region src/manifest/io.d.ts
+declare const AGENTYX_MANIFEST_FILENAME = ".agentyx.lock.json";
+/** The absolute path `.agentyx.lock.json` is read from for a given project. */
+declare function agentyxManifestPath(projectPath?: string): string;
+/** A manifest that claims nothing — what a project has before its first install. */
+declare function emptyInstallManifest(): InstallManifest;
+/**
+ * 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.
+ */
+declare function hashContent(content: string): string;
+/**
+ * Validates an already-parsed manifest document.
+ *
+ * @throws {AgentyxManifestValidationError} when the document violates the schema.
+ */
+declare function parseInstallManifest(value: unknown, filePath?: string): InstallManifest;
+/**
+ * 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.
+ */
+declare function loadInstallManifest(projectPath?: string): Promise<InstallManifest>;
+/**
+ * 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.
+ */
+declare function formatInstallManifest(manifest: InstallManifest): string;
+/**
+ * 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.
+ */
+declare function manifestEntriesByPath(manifest: InstallManifest): ReadonlyMap<string, InstallManifestEntry>;
 //#endregion
 //#region src/mcp/built-in.d.ts
 declare const builtInMcpServerRegistry: McpServerRegistry;
@@ -347,27 +583,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 +645,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 +660,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", "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 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 +742,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, AGENTYX_MANIFEST_FILENAME, type AgentyxConfig, type AgentyxConfigInput, type AgentyxConfigIssue, AgentyxConfigNotFoundError, AgentyxConfigParseError, AgentyxConfigValidationError, AgentyxError, type AgentyxIssue, AgentyxManifestParseError, AgentyxManifestValidationError, CircularPackDependencyError, DuplicateMcpServerError, DuplicatePackError, DuplicateSkillError, DuplicateToolError, INSTALL_MANIFEST_VERSION, type InstallManifest, type InstallManifestEntry, type InstallManifestInput, InvalidMcpServerError, InvalidSkillError, InvalidToolError, MCP_CAPABILITY_LEVELS, MCP_CONTEXT_COSTS, type McpCapabilityLevel, type McpContextCost, type McpEnvReference, type McpManifestEntry, 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 SkillManifestEntry, 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, 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.d.mts.map