@agentyx/core 0.7.0 → 0.9.0

package/dist/index.d.mts

@@ -7,7 +7,7 @@ import { ZodError, z } from "zod";
  * unexpected runtime errors, and branch on the stable `code` when they need to
  * handle a specific failure.
  */
-declare class AgentyxError extends Error {
+export declare class AgentyxError extends Error {
   readonly code: string;
   constructor(code: string, message: string, options?: ErrorOptions);
 }
@@ -24,36 +24,41 @@ interface AgentyxIssue {
 /** 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 {
+export declare class AgentyxConfigNotFoundError extends AgentyxError {
   readonly filePath: string;
   constructor(filePath: string, options?: ErrorOptions);
 }
 /** Raised when `.agentyx.json` is not valid JSON. */
-declare class AgentyxConfigParseError extends AgentyxError {
+export declare class AgentyxConfigParseError extends AgentyxError {
   readonly filePath: string;
   constructor(filePath: string, reason: string, options?: ErrorOptions);
 }
 /** Raised when the document parses as JSON but violates the Agentyx schema. */
-declare class AgentyxConfigValidationError extends AgentyxError {
+export declare class AgentyxConfigValidationError extends AgentyxError {
   readonly issues: readonly AgentyxConfigIssue[];
   /** The file the configuration came from, when it was read from disk. */
   readonly filePath: string | undefined;
   constructor(error: ZodError, filePath?: string);
 }
-declare class UnknownEnabledCapabilityError extends AgentyxError {
+export declare class UnknownEnabledCapabilityError extends AgentyxError {
   readonly capabilityName: string;
   readonly knownCapabilities: readonly string[];
   constructor(capabilityName: string, knownCapabilities: readonly string[]);
 }
 /** Raised when a configured local Skill directory cannot be loaded safely. */
-declare class LocalSkillDirectoryError extends AgentyxError {
+export declare class LocalSkillDirectoryError extends AgentyxError {
   readonly directory: string;
   constructor(directory: string, reason: string, options?: ErrorOptions);
 }
+/** Raised when a configured project-context path is missing or escapes the project. */
+export declare class ProjectContextPathError extends AgentyxError {
+  readonly path: string;
+  constructor(path: string, reason: string, options?: ErrorOptions);
+}
 //#endregion
 //#region src/config/json-schema.d.ts
 /** Canonical identifier of the published `.agentyx.json` schema. */
-declare const AGENTYX_CONFIG_SCHEMA_ID = "https://raw.githubusercontent.com/Andersseen/agentyx/main/packages/core/schema/agentyx.schema.json";
+export declare const AGENTYX_CONFIG_SCHEMA_ID = "https://raw.githubusercontent.com/Andersseen/agentyx/main/packages/core/schema/agentyx.schema.json";
 /**
  * Derives the JSON Schema for `.agentyx.json` from the Zod model, which stays the
  * single source of truth. The committed `schema/agentyx.schema.json` is generated
@@ -62,23 +67,65 @@ declare const AGENTYX_CONFIG_SCHEMA_ID = "https://raw.githubusercontent.com/Ande
  * The `input` view is used so that fields with defaults stay optional, which is
  * what an author writing the file cares about.
  */
-declare function buildAgentyxConfigJsonSchema(): Record<string, unknown>;
+export declare function buildAgentyxConfigJsonSchema(): Record<string, unknown>;
 //#endregion
 //#region src/config/schema.d.ts
 /**
  * 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;
+export declare const agentyxTargetSchema: z.ZodString;
+export declare const enabledCapabilityNameSchema: z.ZodString;
 /**
  * Portable project-relative path to a directory whose direct children are Agent Skills.
  * Backslashes, absolute paths and parent traversal are rejected so the same config is safe on
  * every supported platform.
  */
-declare const skillDirectorySchema: z.ZodString;
+export declare const skillDirectorySchema: z.ZodString;
+export declare const projectMetadataSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  repository: z.ZodOptional<z.ZodString>;
+  docs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  mcp: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  owns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const projectRelationTypeSchema: z.ZodEnum<{
+  uses: "uses";
+  integrates: "integrates";
+  consumes: "consumes";
+  extends: "extends";
+}>;
+export declare const projectRelationSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodEnum<{
+    uses: "uses";
+    integrates: "integrates";
+    consumes: "consumes";
+    extends: "extends";
+  }>;
+  role: z.ZodString;
+  repository: z.ZodOptional<z.ZodString>;
+  docs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  mcp: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  owns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  guidance: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const projectContextSchema: z.ZodObject<{
+  commands: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+    command: z.ZodString;
+    cwd: z.ZodDefault<z.ZodString>;
+  }, z.core.$strict>>>;
+  areas: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    purpose: z.ZodString;
+  }, z.core.$strict>>>;
+  constraints: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
 /** The `.agentyx.json` project configuration. */
-declare const agentyxConfigSchema: z.ZodObject<{
+export declare const agentyxConfigSchema: z.ZodObject<{
   $schema: z.ZodOptional<z.ZodString>;
   packs: z.ZodDefault<z.ZodArray<z.ZodString>>;
   enable: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -158,22 +205,61 @@ declare const agentyxConfigSchema: z.ZodObject<{
     path: z.ZodString;
     ref: z.ZodString;
   }, z.core.$strict>>>;
+  project: z.ZodOptional<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    repository: z.ZodOptional<z.ZodString>;
+    docs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    mcp: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    owns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  }, z.core.$strict>>;
+  relations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodEnum<{
+      uses: "uses";
+      integrates: "integrates";
+      consumes: "consumes";
+      extends: "extends";
+    }>;
+    role: z.ZodString;
+    repository: z.ZodOptional<z.ZodString>;
+    docs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    mcp: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    owns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    guidance: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  }, z.core.$strict>>>;
+  context: z.ZodOptional<z.ZodObject<{
+    commands: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+      command: z.ZodString;
+      cwd: z.ZodDefault<z.ZodString>;
+    }, z.core.$strict>>>;
+    areas: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      path: z.ZodString;
+      purpose: z.ZodString;
+    }, z.core.$strict>>>;
+    constraints: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  }, z.core.$strict>>;
 }, z.core.$strict>;
 /** A validated configuration, with defaults applied. */
 type AgentyxConfig = z.infer<typeof agentyxConfigSchema>;
 /** The shape accepted in a `.agentyx.json` file. */
 type AgentyxConfigInput = z.input<typeof agentyxConfigSchema>;
+type ProjectMetadata = z.infer<typeof projectMetadataSchema>;
+type ProjectRelation = z.infer<typeof projectRelationSchema>;
+type ProjectContext = z.infer<typeof projectContextSchema>;
 //#endregion
 //#region src/config/loader.d.ts
-declare const AGENTYX_CONFIG_FILENAME = ".agentyx.json";
+export declare const AGENTYX_CONFIG_FILENAME = ".agentyx.json";
 /** The absolute path `.agentyx.json` is read from for a given project. */
-declare function agentyxConfigPath(projectPath?: string): string;
+export declare function agentyxConfigPath(projectPath?: string): string;
 /**
  * Validates an already-parsed configuration document.
  *
  * @throws {AgentyxConfigValidationError} when the document violates the schema.
  */
-declare function parseAgentyxConfig(value: unknown, filePath?: string): AgentyxConfig;
+export declare function parseAgentyxConfig(value: unknown, filePath?: string): AgentyxConfig;
 /**
  * Reads and validates `.agentyx.json` from `projectPath`.
  *
@@ -184,11 +270,48 @@ declare function parseAgentyxConfig(value: unknown, filePath?: string): AgentyxC
  * @throws {AgentyxConfigParseError} when the file is not valid JSON.
  * @throws {AgentyxConfigValidationError} when the document violates the schema.
  */
-declare function loadAgentyxConfig(projectPath?: string): Promise<AgentyxConfig>;
+export declare function loadAgentyxConfig(projectPath?: string): Promise<AgentyxConfig>;
+//#endregion
+//#region src/project-graph.d.ts
+export declare class ProjectGraphNotConfiguredError extends AgentyxError {
+  constructor();
+}
+interface ProjectGraph {
+  readonly project: ProjectMetadata;
+  readonly relations: readonly ProjectRelation[];
+}
+export declare function createProjectGraph(project: ProjectMetadata, relations: readonly ProjectRelation[]): ProjectGraph;
+export declare function renderProjectGraphText(graph: ProjectGraph): string;
+export declare function renderProjectGraphJson(graph: ProjectGraph): string;
+export declare function renderProjectGraphMermaid(graph: ProjectGraph): string;
+export declare function renderProjectGraphSvg(graph: ProjectGraph): string;
+export declare function findProjectCapabilityOwners(graph: ProjectGraph, capability: string): {
+  capability: string;
+  currentProject: {
+    id: string;
+    name: string;
+    docs: string[];
+    mcp: string[];
+    owns: string[];
+    description?: string | undefined;
+    repository?: string | undefined;
+  } | undefined;
+  relatedProjects: {
+    id: string;
+    name: string;
+    type: "uses" | "integrates" | "consumes" | "extends";
+    role: string;
+    docs: string[];
+    mcp: string[];
+    owns: string[];
+    guidance: string[];
+    repository?: string | undefined;
+  }[];
+};
 //#endregion
 //#region src/pack/schema.d.ts
-declare const PACK_CATEGORIES: readonly ["engineering", "language", "framework", "efficiency", "workflow"];
-declare const packCategorySchema: z.ZodEnum<{
+export declare const PACK_CATEGORIES: readonly ["engineering", "language", "framework", "efficiency", "workflow"];
+export declare const packCategorySchema: z.ZodEnum<{
   engineering: "engineering";
   language: "language";
   framework: "framework";
@@ -199,9 +322,9 @@ declare const packCategorySchema: z.ZodEnum<{
  * 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;
+export declare const packNameSchema: z.ZodString;
 /** A pack is a composable provider-neutral capability bundle. */
-declare const packDefinitionSchema: z.ZodObject<{
+export declare const packDefinitionSchema: z.ZodObject<{
   name: z.ZodString;
   category: z.ZodDefault<z.ZodEnum<{
     engineering: "engineering";
@@ -284,21 +407,21 @@ type PackDefinitionInput = z.input<typeof packDefinitionSchema>;
  */
 type PackRegistry = ReadonlyMap<string, PackDefinition>;
 /** Validates definitions and indexes them by name. */
-declare function createPackRegistry(definitions: Iterable<PackDefinitionInput>): PackRegistry;
+export 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[];
+export declare const builtInPacks: readonly PackDefinitionInput[];
 /** The registry used by default when no explicit registry is supplied. */
-declare const builtInPackRegistry: PackRegistry;
+export declare const builtInPackRegistry: PackRegistry;
 //#endregion
 //#region src/skill/schema.d.ts
 /**
  * A Skill is reusable instruction text for a coding agent. It is deliberately
  * provider-independent: nothing here says how or where a provider installs it.
  */
-declare const skillDefinitionSchema: z.ZodObject<{
+export declare const skillDefinitionSchema: z.ZodObject<{
   name: z.ZodString;
   description: z.ZodString;
   content: z.ZodString;
@@ -344,7 +467,7 @@ interface SkillRegistry {
  * @throws {DuplicateSkillError} when two sources share a name.
  * @throws {InvalidSkillError} when a source name is not a valid skill name.
  */
-declare function createSkillRegistry(sources: Iterable<SkillSource>): SkillRegistry;
+export declare function createSkillRegistry(sources: Iterable<SkillSource>): SkillRegistry;
 //#endregion
 //#region src/config/project.d.ts
 /** A validated project configuration plus the registries it owns. */
@@ -352,6 +475,7 @@ interface AgentyxProject {
   readonly config: AgentyxConfig;
   readonly packRegistry: PackRegistry;
   readonly skillRegistry: SkillRegistry;
+  readonly graph: ProjectGraph | undefined;
 }
 /**
  * Loads `.agentyx.json` and any checked-in Agent Skills it declares.
@@ -360,20 +484,20 @@ interface AgentyxProject {
  * the project even through symlinks. Loading is local-only: this function never clones a repository
  * or accesses the network.
  */
-declare function loadAgentyxProject(projectPath?: string): Promise<AgentyxProject>;
+export declare function loadAgentyxProject(projectPath?: string): Promise<AgentyxProject>;
 //#endregion
 //#region src/hook/schema.d.ts
-declare const HOOK_ACTIVATION_LEVELS: readonly ["default", "optional"];
-declare const hookActivationLevelSchema: z.ZodEnum<{
+export declare const HOOK_ACTIVATION_LEVELS: readonly ["default", "optional"];
+export declare const hookActivationLevelSchema: z.ZodEnum<{
   default: "default";
   optional: "optional";
 }>;
-declare const HOOK_EVENTS: readonly ["SessionStart"];
-declare const hookEventSchema: z.ZodEnum<{
+export declare const HOOK_EVENTS: readonly ["SessionStart"];
+export declare const hookEventSchema: z.ZodEnum<{
   SessionStart: "SessionStart";
 }>;
-declare const hookNameSchema: z.ZodString;
-declare const hookDefinitionSchema: z.ZodObject<{
+export declare const hookNameSchema: z.ZodString;
+export declare const hookDefinitionSchema: z.ZodObject<{
   name: z.ZodString;
   description: z.ZodString;
   event: z.ZodEnum<{
@@ -382,7 +506,7 @@ declare const hookDefinitionSchema: z.ZodObject<{
   command: z.ZodString;
   args: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strict>;
-declare const hookReferenceSchema: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+export declare const hookReferenceSchema: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
   name: z.ZodString;
   activation: z.ZodDefault<z.ZodEnum<{
     default: "default";
@@ -424,24 +548,24 @@ interface HookRegistry {
   listMetadata(): readonly HookMetadata[];
   get(name: string): HookDefinition;
 }
-declare function createHookRegistry(sources: Iterable<HookSource>): HookRegistry;
+export declare function createHookRegistry(sources: Iterable<HookSource>): HookRegistry;
 //#endregion
 //#region src/mcp/schema.d.ts
-declare const MCP_CAPABILITY_LEVELS: readonly ["default", "optional"];
-declare const mcpCapabilityLevelSchema: z.ZodEnum<{
+export declare const MCP_CAPABILITY_LEVELS: readonly ["default", "optional"];
+export declare const mcpCapabilityLevelSchema: z.ZodEnum<{
   default: "default";
   optional: "optional";
 }>;
-declare const MCP_CONTEXT_COSTS: readonly ["low", "medium", "high"];
-declare const mcpContextCostSchema: z.ZodEnum<{
+export declare const MCP_CONTEXT_COSTS: readonly ["low", "medium", "high"];
+export declare const mcpContextCostSchema: z.ZodEnum<{
   low: "low";
   medium: "medium";
   high: "high";
 }>;
-declare const mcpEnvReferenceSchema: z.ZodObject<{
+export declare const mcpEnvReferenceSchema: z.ZodObject<{
   fromEnv: z.ZodString;
 }, z.core.$strict>;
-declare const mcpServerReferenceSchema: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+export declare const mcpServerReferenceSchema: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
   name: z.ZodString;
   activation: z.ZodDefault<z.ZodEnum<{
     default: "default";
@@ -460,7 +584,7 @@ declare const mcpServerReferenceSchema: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly
     optional: "optional";
   }>;
 }, z.core.$strict>>;
-declare const mcpServerDefinitionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const mcpServerDefinitionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   name: z.ZodString;
   description: z.ZodString;
   contextCost: z.ZodOptional<z.ZodEnum<{
@@ -522,16 +646,16 @@ interface McpServerRegistry {
   listMetadata(): readonly McpServerMetadata[];
   get(name: string): McpServerDefinition;
 }
-declare function createMcpServerRegistry(sources: Iterable<McpServerSource>): McpServerRegistry;
+export declare function createMcpServerRegistry(sources: Iterable<McpServerSource>): McpServerRegistry;
 //#endregion
 //#region src/tool/schema.d.ts
-declare const TOOL_ACTIVATION_LEVELS: readonly ["default", "optional"];
-declare const toolActivationLevelSchema: z.ZodEnum<{
+export declare const TOOL_ACTIVATION_LEVELS: readonly ["default", "optional"];
+export declare const toolActivationLevelSchema: z.ZodEnum<{
   default: "default";
   optional: "optional";
 }>;
-declare const toolNameSchema: z.ZodString;
-declare const toolReferenceSchema: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+export declare const toolNameSchema: z.ZodString;
+export declare const toolReferenceSchema: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
   name: z.ZodString;
   activation: z.ZodDefault<z.ZodEnum<{
     default: "default";
@@ -550,7 +674,7 @@ declare const toolReferenceSchema: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.Zo
     optional: "optional";
   }>;
 }, z.core.$strict>>;
-declare const toolDefinitionSchema: z.ZodObject<{
+export declare const toolDefinitionSchema: z.ZodObject<{
   name: z.ZodString;
   description: z.ZodString;
   kind: z.ZodLiteral<"executable">;
@@ -582,7 +706,7 @@ interface ToolRegistry {
   listMetadata(): readonly ToolMetadata[];
   get(name: string): ToolDefinition;
 }
-declare function createToolRegistry(sources: Iterable<ToolSource>): ToolRegistry;
+export declare function createToolRegistry(sources: Iterable<ToolSource>): ToolRegistry;
 //#endregion
 //#region src/config/resolver.d.ts
 /** A project configuration with its selected packs resolved. */
@@ -612,39 +736,39 @@ interface ResolvedAgentyxConfig {
  * @throws {UnknownPackError} when a configured pack is missing.
  * @throws {UnknownSkillError} when a pack references an unknown skill.
  */
-declare function resolveAgentyxConfig(config: AgentyxConfig, registry?: PackRegistry, skillRegistry?: SkillRegistry, mcpRegistry?: McpServerRegistry, toolRegistry?: ToolRegistry, hookRegistry?: HookRegistry): ResolvedAgentyxConfig;
+export declare function resolveAgentyxConfig(config: AgentyxConfig, registry?: PackRegistry, skillRegistry?: SkillRegistry, mcpRegistry?: McpServerRegistry, toolRegistry?: ToolRegistry, hookRegistry?: HookRegistry): ResolvedAgentyxConfig;
 //#endregion
 //#region src/hook/built-in.d.ts
-declare const builtInHookRegistry: HookRegistry;
-declare const builtInHookNames: readonly string[];
+export declare const builtInHookRegistry: HookRegistry;
+export declare const builtInHookNames: readonly string[];
 //#endregion
 //#region src/hook/errors.d.ts
-declare class UnknownHookError extends AgentyxError {
+export declare class UnknownHookError extends AgentyxError {
   readonly hookName: string;
   readonly requiredBy: string | undefined;
   readonly knownHooks: readonly string[];
   constructor(hookName: string, requiredBy: string | undefined, knownHooks: readonly string[]);
 }
-declare class DuplicateHookError extends AgentyxError {
+export declare class DuplicateHookError extends AgentyxError {
   readonly hookName: string;
   constructor(hookName: string);
 }
-declare class InvalidHookError extends AgentyxError {
+export declare class InvalidHookError extends AgentyxError {
   readonly origin: string;
   readonly reason: string;
   constructor(origin: string, reason: string | ZodError, options?: ErrorOptions);
 }
 //#endregion
 //#region src/hook/resolver.d.ts
-declare function collectPackHookReferences(resolvedPacks: readonly string[], packRegistry: PackRegistry, hookRegistry: HookRegistry): HookReference[];
-declare function filterEffectiveHooks(hooks: readonly HookReference[], enabledCapabilities: readonly string[]): string[];
-declare function collectPackHooks(resolvedPacks: readonly string[], packRegistry: PackRegistry, hookRegistry: HookRegistry, enabledCapabilities?: readonly string[]): string[];
-declare function resolvePackHookReferences(requestedPacks: readonly string[], packRegistry?: PackRegistry, hookRegistry?: HookRegistry): HookReference[];
-declare function resolvePackHooks(requestedPacks: readonly string[], packRegistry?: PackRegistry, hookRegistry?: HookRegistry, enabledCapabilities?: readonly string[]): string[];
+export declare function collectPackHookReferences(resolvedPacks: readonly string[], packRegistry: PackRegistry, hookRegistry: HookRegistry): HookReference[];
+export declare function filterEffectiveHooks(hooks: readonly HookReference[], enabledCapabilities: readonly string[]): string[];
+export declare function collectPackHooks(resolvedPacks: readonly string[], packRegistry: PackRegistry, hookRegistry: HookRegistry, enabledCapabilities?: readonly string[]): string[];
+export declare function resolvePackHookReferences(requestedPacks: readonly string[], packRegistry?: PackRegistry, hookRegistry?: HookRegistry): HookReference[];
+export declare function resolvePackHooks(requestedPacks: readonly string[], packRegistry?: PackRegistry, hookRegistry?: HookRegistry, enabledCapabilities?: readonly string[]): string[];
 //#endregion
 //#region src/manifest/errors.d.ts
 /** Raised when `.agentyx.lock.json` is not valid JSON. */
-declare class AgentyxManifestParseError extends AgentyxError {
+export declare class AgentyxManifestParseError extends AgentyxError {
   readonly filePath: string;
   constructor(filePath: string, reason: string, options?: ErrorOptions);
 }
@@ -656,7 +780,7 @@ declare class AgentyxManifestParseError extends AgentyxError {
  * allowed to overwrite and delete, so guessing at a damaged one would be
  * guessing about destructive operations.
  */
-declare class AgentyxManifestValidationError extends AgentyxError {
+export declare class AgentyxManifestValidationError extends AgentyxError {
   readonly issues: readonly AgentyxIssue[];
   readonly filePath: string | undefined;
   constructor(error: ZodError, filePath?: string);
@@ -670,9 +794,9 @@ declare class AgentyxManifestValidationError extends AgentyxError {
  * 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;
+export declare const INSTALL_MANIFEST_VERSION = 1;
 /** A `SKILL.md` file Agentyx wrote, owned entirely by Agentyx. */
-declare const skillManifestEntrySchema: z.ZodObject<{
+export declare const skillManifestEntrySchema: z.ZodObject<{
   kind: z.ZodLiteral<"skill">;
   path: z.ZodString;
   skill: z.ZodString;
@@ -687,7 +811,7 @@ declare const skillManifestEntrySchema: z.ZodObject<{
  * `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<{
+export declare const mcpManifestEntrySchema: z.ZodObject<{
   kind: z.ZodLiteral<"mcp">;
   path: z.ZodString;
   servers: z.ZodArray<z.ZodString>;
@@ -702,7 +826,7 @@ declare const mcpManifestEntrySchema: z.ZodObject<{
  * user, so the entry records the hook names Agentyx added rather than
  * claiming the whole document.
  */
-declare const hookManifestEntrySchema: z.ZodObject<{
+export declare const hookManifestEntrySchema: z.ZodObject<{
   kind: z.ZodLiteral<"hook">;
   path: z.ZodString;
   hooks: z.ZodArray<z.ZodString>;
@@ -710,7 +834,7 @@ declare const hookManifestEntrySchema: z.ZodObject<{
   hash: z.ZodString;
   created: z.ZodBoolean;
 }, z.core.$strict>;
-declare const installManifestEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+export declare const installManifestEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   kind: z.ZodLiteral<"skill">;
   path: z.ZodString;
   skill: z.ZodString;
@@ -732,7 +856,7 @@ declare const installManifestEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
   created: z.ZodBoolean;
 }, z.core.$strict>], "kind">;
 /** The `.agentyx.lock.json` record of everything Agentyx installed into a project. */
-declare const installManifestSchema: z.ZodObject<{
+export declare const installManifestSchema: z.ZodObject<{
   version: z.ZodLiteral<1>;
   entries: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"skill">;
@@ -766,11 +890,11 @@ type InstallManifest = z.infer<typeof installManifestSchema>;
 type InstallManifestInput = z.input<typeof installManifestSchema>;
 //#endregion
 //#region src/manifest/io.d.ts
-declare const AGENTYX_MANIFEST_FILENAME = ".agentyx.lock.json";
+export 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;
+export declare function agentyxManifestPath(projectPath?: string): string;
 /** A manifest that claims nothing — what a project has before its first install. */
-declare function emptyInstallManifest(): InstallManifest;
+export declare function emptyInstallManifest(): InstallManifest;
 /**
  * The SHA-256 digest Agentyx records for managed content.
  *
@@ -778,13 +902,13 @@ declare function emptyInstallManifest(): InstallManifest;
  * 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;
+export 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;
+export declare function parseInstallManifest(value: unknown, filePath?: string): InstallManifest;
 /**
  * Reads `.agentyx.lock.json` from `projectPath`.
  *
@@ -796,7 +920,7 @@ declare function parseInstallManifest(value: unknown, filePath?: string): Instal
  * @throws {AgentyxManifestParseError} when the file is not valid JSON.
  * @throws {AgentyxManifestValidationError} when the document violates the schema.
  */
-declare function loadInstallManifest(projectPath?: string): Promise<InstallManifest>;
+export declare function loadInstallManifest(projectPath?: string): Promise<InstallManifest>;
 /**
  * Serialises a manifest for writing.
  *
@@ -805,63 +929,63 @@ declare function loadInstallManifest(projectPath?: string): Promise<InstallManif
  * diff. Writing is deliberately not done here — only the install executor
  * touches the filesystem.
  */
-declare function formatInstallManifest(manifest: InstallManifest): string;
+export 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>;
+export declare function manifestEntriesByPath(manifest: InstallManifest): ReadonlyMap<string, InstallManifestEntry>;
 //#endregion
 //#region src/mcp/built-in.d.ts
-declare const builtInMcpServerRegistry: McpServerRegistry;
-declare const builtInMcpServerNames: readonly string[];
+export declare const builtInMcpServerRegistry: McpServerRegistry;
+export declare const builtInMcpServerNames: readonly string[];
 //#endregion
 //#region src/mcp/errors.d.ts
-declare class UnknownMcpServerError extends AgentyxError {
+export declare class UnknownMcpServerError extends AgentyxError {
   readonly serverName: string;
   readonly requiredBy: string | undefined;
   readonly knownServers: readonly string[];
   constructor(serverName: string, requiredBy: string | undefined, knownServers: readonly string[]);
 }
-declare class DuplicateMcpServerError extends AgentyxError {
+export declare class DuplicateMcpServerError extends AgentyxError {
   readonly serverName: string;
   constructor(serverName: string);
 }
-declare class InvalidMcpServerError extends AgentyxError {
+export declare class InvalidMcpServerError extends AgentyxError {
   readonly origin: string;
   readonly reason: string;
   constructor(origin: string, reason: string | ZodError, options?: ErrorOptions);
 }
 //#endregion
 //#region src/mcp/resolver.d.ts
-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[];
+export declare function collectPackMcpServerReferences(resolvedPacks: readonly string[], packRegistry: PackRegistry, mcpRegistry: McpServerRegistry): McpServerReference[];
+export declare function filterEffectiveMcpServers(servers: readonly McpServerReference[], enabledCapabilities: readonly string[]): string[];
+export declare function collectPackMcpServers(resolvedPacks: readonly string[], packRegistry: PackRegistry, mcpRegistry: McpServerRegistry, enabledCapabilities?: readonly string[]): string[];
+export declare function resolvePackMcpServerReferences(requestedPacks: readonly string[], packRegistry?: PackRegistry, mcpRegistry?: McpServerRegistry): McpServerReference[];
+export 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;
+export declare const agentyxCoreName = "agentyx-core";
+export declare function getCoreStatus(): string;
 //#endregion
 //#region src/pack/errors.d.ts
 /** Raised when a requested pack is not present in the registry. */
-declare class UnknownPackError extends AgentyxError {
+export 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[]);
 }
 /** @deprecated Packs no longer inherit from other packs. */
-declare class CircularPackDependencyError extends AgentyxError {
+export 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 {
+export declare class DuplicatePackError extends AgentyxError {
   readonly packName: string;
   constructor(packName: string);
 }
@@ -875,10 +999,10 @@ declare class DuplicatePackError extends AgentyxError {
  *
  * @throws {UnknownPackError} when a requested pack is missing.
  */
-declare function resolvePacks(requestedPacks: readonly string[], registry?: PackRegistry): string[];
+export declare function resolvePacks(requestedPacks: readonly string[], registry?: PackRegistry): string[];
 //#endregion
 //#region src/project/signals.d.ts
-declare const PACKAGE_MANAGERS: readonly ["pnpm", "npm", "yarn", "bun"];
+export declare const PACKAGE_MANAGERS: readonly ["pnpm", "npm", "yarn", "bun"];
 type PackageManagerName = (typeof PACKAGE_MANAGERS)[number];
 interface PackageManagerDetection {
   readonly name: PackageManagerName | undefined;
@@ -892,6 +1016,7 @@ interface ProjectPackageJsonDetection {
   readonly path: string;
   readonly name: string | undefined;
   readonly packageManager: string | undefined;
+  readonly scripts: Readonly<Record<string, string>>;
   readonly error: string | undefined;
 }
 type DependencyField = "dependencies" | "devDependencies" | "peerDependencies" | "optionalDependencies";
@@ -907,6 +1032,17 @@ interface ContainerFileSignals {
 interface CiFileSignals {
   readonly githubActions: boolean;
 }
+/**
+ * Rust facts. `detected` requires a `Cargo.toml` that declares a `[package]` or `[workspace]`
+ * table; stray `.rs` files never count. The other fields are supporting context only.
+ */
+interface RustSignal {
+  readonly detected: boolean;
+  readonly workspace: boolean;
+  readonly cargoLock: boolean;
+  /** `rust-toolchain.toml` or `rust-toolchain`, whichever is present. */
+  readonly toolchainFile: string | undefined;
+}
 interface MonorepoSignal {
   readonly detected: boolean;
   readonly markers: readonly string[];
@@ -932,6 +1068,7 @@ interface ProjectSignals {
     readonly tsconfig: boolean;
   };
   readonly angular: TechnologyMatch | undefined;
+  readonly rust: RustSignal;
   readonly testFrameworks: readonly TechnologyMatch[];
   readonly browserTesting: readonly TechnologyMatch[];
   readonly observability: readonly TechnologyMatch[];
@@ -946,15 +1083,15 @@ interface ProjectSignals {
   };
 }
 /** Maximum directory entries visited by `scanRepositorySize`, regardless of match. */
-declare const REPOSITORY_SCAN_ENTRY_LIMIT = 5000;
+export declare const REPOSITORY_SCAN_ENTRY_LIMIT = 5000;
 /** Gathers every project signal with a bounded, cheap set of reads. */
-declare function collectProjectSignals(projectDir: string): Promise<ProjectSignals>;
+export declare function collectProjectSignals(projectDir: string): Promise<ProjectSignals>;
 /**
  * Counts source-like files under a bounded traversal, ignoring dependency, VCS and build output
  * directories. Stops after visiting `entryLimit` directory entries — cheap even on a monorepo — and
  * reports `capped` so callers never mistake a partial scan for a complete one.
  */
-declare function scanRepositorySize(projectDir: string, options?: {
+export declare function scanRepositorySize(projectDir: string, options?: {
   readonly entryLimit?: number;
 }): Promise<RepositorySizeSignal>;
 //#endregion
@@ -971,20 +1108,20 @@ interface ProjectDetection {
  * capabilities fit — that policy lives in `recommendCapabilities`, kept separate so each half stays
  * independently testable.
  */
-declare function detectProject(projectDir: string): Promise<ProjectDetection>;
-declare function buildAgentyxConfig(input: {
+export declare function detectProject(projectDir: string): Promise<ProjectDetection>;
+export declare function buildAgentyxConfig(input: {
   readonly packs: readonly string[];
   readonly enable?: readonly string[];
   readonly targets: readonly string[];
 }): AgentyxConfigInput;
-declare function formatAgentyxConfig(config: AgentyxConfigInput): string;
+export declare function formatAgentyxConfig(config: AgentyxConfigInput): string;
 //#endregion
 //#region src/project/executable.d.ts
 /** Whether `command` resolves to an executable file, via `PATH` unless it already contains a `/`. */
-declare function isExecutableOnPath(command: string): Promise<boolean>;
+export declare function isExecutableOnPath(command: string): Promise<boolean>;
 //#endregion
 //#region src/project/recommend.d.ts
-declare const RECOMMENDATION_CONFIDENCES: readonly ["high", "medium"];
+export declare const RECOMMENDATION_CONFIDENCES: readonly ["high", "medium"];
 type RecommendationConfidence = (typeof RECOMMENDATION_CONFIDENCES)[number];
 type RecommendationKind = "pack" | "capability";
 /**
@@ -1013,8 +1150,8 @@ interface RecommendCapabilitiesOptions {
  * These are approximate signals, not exact token accounting, and a monorepo is treated as already
  * complex enough to lower the bar.
  */
-declare const CODEBASE_MEMORY_FILE_THRESHOLD = 2000;
-declare const CODEBASE_MEMORY_MONOREPO_FILE_THRESHOLD = 800;
+export declare const CODEBASE_MEMORY_FILE_THRESHOLD = 2000;
+export declare const CODEBASE_MEMORY_MONOREPO_FILE_THRESHOLD = 800;
 /**
  * Applies conservative, deterministic policy on top of `ProjectSignals`. This is the only place
  * that turns an observed fact into a product suggestion — `ProjectSignals` stays fact-only so it
@@ -1023,7 +1160,7 @@ declare const CODEBASE_MEMORY_MONOREPO_FILE_THRESHOLD = 800;
  * Never enables anything and never touches the filesystem: the caller decides what, if anything,
  * to do with the result.
  */
-declare function recommendCapabilities(signals: ProjectSignals, options?: RecommendCapabilitiesOptions): RecommendationResult;
+export declare function recommendCapabilities(signals: ProjectSignals, options?: RecommendCapabilitiesOptions): RecommendationResult;
 //#endregion
 //#region src/skill/built-in.d.ts
 /**
@@ -1031,9 +1168,9 @@ declare function recommendCapabilities(signals: ProjectSignals, options?: Recomm
  * `packages/core/skills`, and knowing them without touching the filesystem is
  * what lets pack resolution validate references without reading any body.
  */
-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"];
+export 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", "rust-idiomatic-development", "rust-filesystem-safety", "rust-testing-portability", "cargo-project-verification", "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;
+export declare const builtInSkillRegistry: SkillRegistry;
 //#endregion
 //#region src/skill/errors.d.ts
 /**
@@ -1042,7 +1179,7 @@ declare const builtInSkillRegistry: SkillRegistry;
  * The offending name is exposed as `skillName`; `pack` stays the JS pack
  * trace inherited from `Error`.
  */
-declare class UnknownSkillError extends AgentyxError {
+export declare class UnknownSkillError extends AgentyxError {
   readonly skillName: string;
   /** The pack that declared the skill, when the failure came from resolution. */
   readonly requiredBy: string | undefined;
@@ -1050,7 +1187,7 @@ declare class UnknownSkillError extends AgentyxError {
   constructor(skillName: string, requiredBy: string | undefined, knownSkills: readonly string[]);
 }
 /** Raised when a registry is built from sources that reuse a skill name. */
-declare class DuplicateSkillError extends AgentyxError {
+export declare class DuplicateSkillError extends AgentyxError {
   readonly skillName: string;
   constructor(skillName: string);
 }
@@ -1061,7 +1198,7 @@ declare class DuplicateSkillError extends AgentyxError {
  * Built-in skills ship with Agentyx, so this is a programmer error rather than
  * something a user can fix in their project.
  */
-declare class InvalidSkillError extends AgentyxError {
+export declare class InvalidSkillError extends AgentyxError {
   /** Where the skill came from: a file path, or a label for an in-memory source. */
   readonly origin: string;
   readonly reason: string;
@@ -1090,7 +1227,7 @@ declare class InvalidSkillError extends AgentyxError {
  *
  * @throws {InvalidSkillError} when the frontmatter or the resulting skill is invalid.
  */
-declare function parseSkillMarkdown(markdown: string, origin: string): SkillDefinition;
+export declare function parseSkillMarkdown(markdown: string, origin: string): SkillDefinition;
 /**
  * Renders a skill as canonical `SKILL.md` text — the inverse of
  * `parseSkillMarkdown`, and the single representation every consumer installs.
@@ -1107,7 +1244,7 @@ declare function parseSkillMarkdown(markdown: string, origin: string): SkillDefi
  * description cannot be represented in the flat frontmatter subset the parser
  * accepts.
  */
-declare function formatSkillMarkdown(skill: SkillDefinitionInput): string;
+export declare function formatSkillMarkdown(skill: SkillDefinitionInput): string;
 //#endregion
 //#region src/skill/resolver.d.ts
 /**
@@ -1120,32 +1257,32 @@ declare function formatSkillMarkdown(skill: SkillDefinitionInput): string;
  * @throws {UnknownPackError} when a requested pack is missing.
  * @throws {UnknownSkillError} when a pack references a skill the registry lacks.
  */
-declare function resolvePackSkills(requestedPacks: readonly string[], packRegistry?: PackRegistry, skillRegistry?: SkillRegistry): string[];
+export declare function resolvePackSkills(requestedPacks: readonly string[], packRegistry?: PackRegistry, skillRegistry?: SkillRegistry): string[];
 //#endregion
 //#region src/source/errors.d.ts
-declare class DuplicateTrustedSourceError extends AgentyxError {
+export declare class DuplicateTrustedSourceError extends AgentyxError {
   readonly sourceName: string;
   constructor(sourceName: string);
 }
-declare class UnknownTrustedSourceError extends AgentyxError {
+export declare class UnknownTrustedSourceError extends AgentyxError {
   readonly sourceName: string;
   readonly knownSources: readonly string[];
   constructor(sourceName: string, knownSources: readonly string[]);
 }
-declare class TrustedSourceLoadError extends AgentyxError {
+export declare class TrustedSourceLoadError extends AgentyxError {
   readonly sourceName: string;
   constructor(sourceName: string, reason: string, options?: ErrorOptions);
 }
 //#endregion
 //#region src/source/schema.d.ts
-declare const trustedSourceNameSchema: z.ZodString;
-declare const trustedSourcePathSchema: z.ZodString;
-declare const trustedSourceReferenceSchema: z.ZodObject<{
+export declare const trustedSourceNameSchema: z.ZodString;
+export declare const trustedSourcePathSchema: z.ZodString;
+export declare const trustedSourceReferenceSchema: z.ZodObject<{
   name: z.ZodString;
   path: z.ZodString;
   ref: z.ZodString;
 }, z.core.$strict>;
-declare const trustedSourceDefinitionSchema: z.ZodObject<{
+export declare const trustedSourceDefinitionSchema: z.ZodObject<{
   name: z.ZodString;
   displayName: z.ZodString;
   repository: z.ZodString;
@@ -1159,7 +1296,7 @@ declare const trustedSourceDefinitionSchema: z.ZodObject<{
   }>;
   installNote: z.ZodString;
 }, z.core.$strict>;
-declare const codexPluginManifestSchema: z.ZodObject<{
+export declare const codexPluginManifestSchema: z.ZodObject<{
   name: z.ZodString;
   version: z.ZodString;
   description: z.ZodString;
@@ -1167,7 +1304,7 @@ declare const codexPluginManifestSchema: z.ZodObject<{
   license: z.ZodString;
   skills: z.ZodString;
 }, z.core.$loose>;
-declare const trustedSourceSkillSummarySchema: z.ZodObject<{
+export declare const trustedSourceSkillSummarySchema: z.ZodObject<{
   name: z.ZodString;
   description: z.ZodString;
   hasResources: z.ZodBoolean;
@@ -1188,39 +1325,39 @@ interface TrustedSourceInspection {
   readonly installable: boolean;
   readonly installNote: string;
 }
-declare function inspectTrustedSource(projectPath: string, reference: TrustedSourceReference): Promise<TrustedSourceInspection>;
+export declare function inspectTrustedSource(projectPath: string, reference: TrustedSourceReference): Promise<TrustedSourceInspection>;
 //#endregion
 //#region src/source/registry.d.ts
 type TrustedSourceRegistry = ReadonlyMap<string, TrustedSourceDefinition>;
-declare const knownTrustedSources: readonly TrustedSourceDefinition[];
-declare const knownTrustedSourceRegistry: TrustedSourceRegistry;
-declare function createTrustedSourceRegistry(definitions: Iterable<TrustedSourceDefinition>): TrustedSourceRegistry;
-declare function getTrustedSourceDefinition(source: string | TrustedSourceReference, registry?: TrustedSourceRegistry): TrustedSourceDefinition;
+export declare const knownTrustedSources: readonly TrustedSourceDefinition[];
+export declare const knownTrustedSourceRegistry: TrustedSourceRegistry;
+export declare function createTrustedSourceRegistry(definitions: Iterable<TrustedSourceDefinition>): TrustedSourceRegistry;
+export declare function getTrustedSourceDefinition(source: string | TrustedSourceReference, registry?: TrustedSourceRegistry): TrustedSourceDefinition;
 //#endregion
 //#region src/tool/built-in.d.ts
-declare const builtInToolRegistry: ToolRegistry;
-declare const builtInToolNames: readonly string[];
+export declare const builtInToolRegistry: ToolRegistry;
+export declare const builtInToolNames: readonly string[];
 //#endregion
 //#region src/tool/errors.d.ts
-declare class UnknownToolError extends AgentyxError {
+export declare class UnknownToolError extends AgentyxError {
   readonly toolName: string;
   readonly requiredBy: string | undefined;
   readonly knownTools: readonly string[];
   constructor(toolName: string, requiredBy: string | undefined, knownTools: readonly string[]);
 }
-declare class DuplicateToolError extends AgentyxError {
+export declare class DuplicateToolError extends AgentyxError {
   readonly toolName: string;
   constructor(toolName: string);
 }
-declare class InvalidToolError extends AgentyxError {
+export declare class InvalidToolError extends AgentyxError {
   constructor(origin: string, reason: unknown, options?: ErrorOptions);
 }
 //#endregion
 //#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[];
+export declare function collectPackToolReferences(resolvedPacks: readonly string[], packRegistry: PackRegistry, toolRegistry: ToolRegistry): ToolReference[];
+export declare function filterEffectiveTools(tools: readonly ToolReference[], enabledCapabilities: readonly string[]): string[];
+export declare function resolvePackToolReferences(requestedPacks: readonly string[], packRegistry?: PackRegistry, toolRegistry?: ToolRegistry): ToolReference[];
+export declare function resolvePackTools(requestedPacks: readonly string[], packRegistry?: PackRegistry, toolRegistry?: ToolRegistry, enabledCapabilities?: readonly string[]): string[];
 //#endregion
-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, type AgentyxProject, CODEBASE_MEMORY_FILE_THRESHOLD, CODEBASE_MEMORY_MONOREPO_FILE_THRESHOLD, type CiFileSignals, CircularPackDependencyError, type CodexPluginManifest, type ContainerFileSignals, type DependencyField, DuplicateHookError, DuplicateMcpServerError, DuplicatePackError, DuplicateSkillError, DuplicateToolError, DuplicateTrustedSourceError, HOOK_ACTIVATION_LEVELS, HOOK_EVENTS, type HookActivationLevel, type HookDefinition, type HookDefinitionInput, type HookEvent, type HookManifestEntry, type HookMetadata, type HookReference, type HookReferenceInput, type HookRegistry, type HookSource, INSTALL_MANIFEST_VERSION, type InstallManifest, type InstallManifestEntry, type InstallManifestInput, InvalidHookError, InvalidMcpServerError, InvalidSkillError, InvalidToolError, LocalSkillDirectoryError, 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, type MonorepoSignal, PACKAGE_MANAGERS, PACK_CATEGORIES, type PackCategory, type PackDefinition, type PackDefinitionInput, type PackRegistry, type PackageManagerDetection, type PackageManagerName, type ProjectDetection, type ProjectPackageJsonDetection, type ProjectSignals, RECOMMENDATION_CONFIDENCES, REPOSITORY_SCAN_ENTRY_LIMIT, type Recommendation, type RecommendationConfidence, type RecommendationKind, type RecommendationResult, type RepositorySizeSignal, type ResolvedAgentyxConfig, type SkillDefinition, type SkillDefinitionInput, type SkillManifestEntry, type SkillRegistry, type SkillSource, TOOL_ACTIVATION_LEVELS, type TechnologyMatch, type ToolActivationLevel, type ToolDefinition, type ToolDefinitionInput, type ToolMetadata, type ToolReference, type ToolReferenceInput, type ToolRegistry, type ToolSource, type TrustedSourceDefinition, TrustedSourceLoadError, type TrustedSourceReference, type TrustedSourceSkillSummary, UnknownEnabledCapabilityError, UnknownHookError, UnknownMcpServerError, UnknownPackError, UnknownSkillError, UnknownToolError, UnknownTrustedSourceError, agentyxConfigPath, agentyxConfigSchema, agentyxCoreName, agentyxManifestPath, agentyxTargetSchema, buildAgentyxConfig, buildAgentyxConfigJsonSchema, builtInHookNames, builtInHookRegistry, builtInMcpServerNames, builtInMcpServerRegistry, builtInPackRegistry, builtInPacks, builtInSkillNames, builtInSkillRegistry, builtInToolNames, builtInToolRegistry, codexPluginManifestSchema, collectPackHookReferences, collectPackHooks, collectPackMcpServerReferences, collectPackMcpServers, collectPackToolReferences, collectProjectSignals, createHookRegistry, createMcpServerRegistry, createPackRegistry, createSkillRegistry, createToolRegistry, createTrustedSourceRegistry, detectProject, emptyInstallManifest, enabledCapabilityNameSchema, filterEffectiveHooks, filterEffectiveMcpServers, filterEffectiveTools, formatAgentyxConfig, formatInstallManifest, formatSkillMarkdown, getCoreStatus, getTrustedSourceDefinition, hashContent, hookActivationLevelSchema, hookDefinitionSchema, hookEventSchema, hookManifestEntrySchema, hookNameSchema, hookReferenceSchema, inspectTrustedSource, installManifestEntrySchema, installManifestSchema, isExecutableOnPath, knownTrustedSourceRegistry, knownTrustedSources, loadAgentyxConfig, loadAgentyxProject, loadInstallManifest, manifestEntriesByPath, mcpCapabilityLevelSchema, mcpContextCostSchema, mcpEnvReferenceSchema, mcpManifestEntrySchema, mcpServerDefinitionSchema, mcpServerReferenceSchema, packCategorySchema, packDefinitionSchema, packNameSchema, parseAgentyxConfig, parseInstallManifest, parseSkillMarkdown, recommendCapabilities, resolveAgentyxConfig, resolvePackHookReferences, resolvePackHooks, resolvePackMcpServerReferences, resolvePackMcpServers, resolvePackSkills, resolvePackToolReferences, resolvePackTools, resolvePacks, scanRepositorySize, skillDefinitionSchema, skillDirectorySchema, skillManifestEntrySchema, toolActivationLevelSchema, toolDefinitionSchema, toolNameSchema, toolReferenceSchema, trustedSourceDefinitionSchema, trustedSourceNameSchema, trustedSourcePathSchema, trustedSourceReferenceSchema, trustedSourceSkillSummarySchema };
+export type { AgentyxConfig, AgentyxConfigInput, AgentyxConfigIssue, AgentyxIssue, AgentyxProject, CiFileSignals, CodexPluginManifest, ContainerFileSignals, DependencyField, HookActivationLevel, HookDefinition, HookDefinitionInput, HookEvent, HookManifestEntry, HookMetadata, HookReference, HookReferenceInput, HookRegistry, HookSource, InstallManifest, InstallManifestEntry, InstallManifestInput, McpCapabilityLevel, McpContextCost, McpEnvReference, McpManifestEntry, McpServerDefinition, McpServerDefinitionInput, McpServerMetadata, McpServerReference, McpServerReferenceInput, McpServerRegistry, McpServerSource, MonorepoSignal, PackCategory, PackDefinition, PackDefinitionInput, PackRegistry, PackageManagerDetection, PackageManagerName, ProjectContext, ProjectDetection, ProjectGraph, ProjectMetadata, ProjectPackageJsonDetection, ProjectRelation, ProjectSignals, Recommendation, RecommendationConfidence, RecommendationKind, RecommendationResult, RepositorySizeSignal, ResolvedAgentyxConfig, RustSignal, SkillDefinition, SkillDefinitionInput, SkillManifestEntry, SkillRegistry, SkillSource, TechnologyMatch, ToolActivationLevel, ToolDefinition, ToolDefinitionInput, ToolMetadata, ToolReference, ToolReferenceInput, ToolRegistry, ToolSource, TrustedSourceDefinition, TrustedSourceReference, TrustedSourceSkillSummary };
 //# sourceMappingURL=index.d.mts.map