@dexto/agent-management 1.6.13 → 1.6.15

package/dist/index.js

@@ -25,6 +25,26 @@ import {
   writePreferencesToAgent
 } from "./writer.js";
 import { AgentManager } from "./AgentManager.js";
+import {
+  ProjectRegistryEntrySchema,
+  ProjectRegistrySchema,
+  getProjectRegistryPath,
+  getProjectRegistryCandidatePaths,
+  findProjectRegistryPath,
+  findProjectRegistryPathSync,
+  readProjectRegistry,
+  readProjectRegistrySync,
+  loadProjectRegistry,
+  loadProjectRegistrySync,
+  getDefaultProjectRegistryEntry,
+  resolveProjectRegistryEntryConfigPath,
+  resolveProjectRegistryEntryConfigPathSync,
+  resolveProjectRegistryEntry,
+  resolveProjectRegistryAgentPath,
+  resolveDefaultProjectRegistryAgentPath,
+  ProjectRegistryError,
+  isProjectRegistryError
+} from "./project-registry.js";
 import {
   installBundledAgent,
   installCustomAgent,
@@ -203,6 +223,9 @@ export {
   PluginManifestSchema,
   PreferenceError,
   PreferenceErrorCode,
+  ProjectRegistryEntrySchema,
+  ProjectRegistryError,
+  ProjectRegistrySchema,
   RegistryError,
   RegistryErrorCode,
   SHARED_API_KEY_PROVIDERS,
@@ -229,6 +252,8 @@ export {
   findDextoProjectRoot,
   findDextoSourceRoot,
   findPackageRoot,
+  findProjectRegistryPath,
+  findProjectRegistryPathSync,
   formatSize,
   getActiveModel,
   getActiveModelId,
@@ -238,6 +263,7 @@ export {
   getCustomModel,
   getCustomModelsPath,
   getDefaultImageStoreDir,
+  getDefaultProjectRegistryEntry,
   getDextoApiKeyFromAuth,
   getDextoEnvPath,
   getDextoGlobalPath,
@@ -262,6 +288,8 @@ export {
   getModelsDiskUsage,
   getPluginSearchPaths,
   getPrimaryApiKeyEnvVar,
+  getProjectRegistryCandidatePaths,
+  getProjectRegistryPath,
   getProviderKeyStatus,
   getTotalInstalledSize,
   getUninstalledDefaults,
@@ -277,6 +305,7 @@ export {
   isModelInstalled,
   isPath,
   isPluginInstalled,
+  isProjectRegistryError,
   listAllMarketplacePlugins,
   listInstalledAgents,
   listInstalledPlugins,
@@ -293,9 +322,13 @@ export {
   loadImageRegistry,
   loadModelPickerState,
   loadModelState,
+  loadProjectRegistry,
+  loadProjectRegistrySync,
   modelFileExists,
   parseImageSpecifier,
   pruneModelPickerState,
+  readProjectRegistry,
+  readProjectRegistrySync,
   recordRecentModel,
   registerManualModel,
   reloadAgentConfigFromFile,
@@ -308,9 +341,14 @@ export {
   resolveAgentPath,
   resolveApiKeyForProvider,
   resolveBundledScript,
+  resolveDefaultProjectRegistryAgentPath,
   resolveFileLikeImageSpecifierToFileUrl,
   resolveFileLikeImageSpecifierToPath,
   resolveImageEntryFileFromStore,
+  resolveProjectRegistryAgentPath,
+  resolveProjectRegistryEntry,
+  resolveProjectRegistryEntryConfigPath,
+  resolveProjectRegistryEntryConfigPathSync,
   saveAgentPreferences,
   saveCustomModel,
   saveDextoInstalledPlugins,

package/dist/plugins/discover-skills.cjs

@@ -68,6 +68,7 @@ function discoverStandaloneSkills(projectPath) {
     } catch {
     }
   };
+  scanSkillsDir(path.join(cwd, "skills"), "project");
   scanSkillsDir(path.join(cwd, ".agents", "skills"), "project");
   scanSkillsDir(path.join(cwd, ".dexto", "skills"), "project");
   if (homeDir) {
@@ -80,6 +81,7 @@ function getSkillSearchPaths() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || "";
   const cwd = process.cwd();
   return [
+    path.join(cwd, "skills"),
     path.join(cwd, ".agents", "skills"),
     path.join(cwd, ".dexto", "skills"),
     homeDir ? path.join(homeDir, ".agents", "skills") : "",

package/dist/plugins/discover-skills.d.ts

@@ -1,10 +1,11 @@
 /**
  * Standalone Skill Discovery
  *
- * Discovers standalone skills from ~/.agents/skills/ and ~/.dexto/skills/ directories.
+ * Discovers standalone skills from project-local and user-local skill directories.
  * These are different from plugin skills - they're just directories containing a SKILL.md file.
  *
  * Structure:
+ * skills/
  * ~/.agents/skills/
  * ~/.dexto/skills/
  * └── skill-name/
@@ -30,10 +31,11 @@ export interface DiscoveredSkill {
  * Discovers standalone skills from standard locations.
  *
  * Search Locations:
- * 1. <cwd>/.agents/skills/*   (project)
- * 2. <cwd>/.dexto/skills/*    (project)
- * 3. ~/.agents/skills/*       (user)
- * 4. ~/.dexto/skills/*        (user)
+ * 1. <projectRoot>/skills/*          (project)
+ * 2. <projectRoot>/.agents/skills/*  (project)
+ * 3. <projectRoot>/.dexto/skills/*   (project)
+ * 4. ~/.agents/skills/*              (user)
+ * 5. ~/.dexto/skills/*               (user)
  *
  * @param projectPath Optional project path (defaults to cwd)
  * @returns Array of discovered skills

package/dist/plugins/discover-skills.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discover-skills.d.ts","sourceRoot":"","sources":["../../src/plugins/discover-skills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,yCAAyC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,sBAAsB;IACtB,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,eAAe,EAAE,CAgEhF;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,EAAE,CAU9C"}
+{"version":3,"file":"discover-skills.d.ts","sourceRoot":"","sources":["../../src/plugins/discover-skills.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH;;GAEG;AACH,MAAM,WAAW,eAAe;IAC5B,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,yCAAyC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,sBAAsB;IACtB,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,eAAe,EAAE,CAkEhF;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,EAAE,CAW9C"}

package/dist/plugins/discover-skills.js

@@ -34,6 +34,7 @@ function discoverStandaloneSkills(projectPath) {
     } catch {
     }
   };
+  scanSkillsDir(path.join(cwd, "skills"), "project");
   scanSkillsDir(path.join(cwd, ".agents", "skills"), "project");
   scanSkillsDir(path.join(cwd, ".dexto", "skills"), "project");
   if (homeDir) {
@@ -46,6 +47,7 @@ function getSkillSearchPaths() {
   const homeDir = process.env.HOME || process.env.USERPROFILE || "";
   const cwd = process.cwd();
   return [
+    path.join(cwd, "skills"),
     path.join(cwd, ".agents", "skills"),
     path.join(cwd, ".dexto", "skills"),
     homeDir ? path.join(homeDir, ".agents", "skills") : "",

package/dist/project-registry.cjs

@@ -0,0 +1,380 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var project_registry_exports = {};
+__export(project_registry_exports, {
+  ProjectRegistryEntrySchema: () => ProjectRegistryEntrySchema,
+  ProjectRegistryError: () => ProjectRegistryError,
+  ProjectRegistrySchema: () => ProjectRegistrySchema,
+  findProjectRegistryPath: () => findProjectRegistryPath,
+  findProjectRegistryPathSync: () => findProjectRegistryPathSync,
+  getDefaultProjectRegistryEntry: () => getDefaultProjectRegistryEntry,
+  getProjectRegistryCandidatePaths: () => getProjectRegistryCandidatePaths,
+  getProjectRegistryPath: () => getProjectRegistryPath,
+  isProjectRegistryError: () => isProjectRegistryError,
+  loadProjectRegistry: () => loadProjectRegistry,
+  loadProjectRegistrySync: () => loadProjectRegistrySync,
+  readProjectRegistry: () => readProjectRegistry,
+  readProjectRegistrySync: () => readProjectRegistrySync,
+  resolveDefaultProjectRegistryAgentPath: () => resolveDefaultProjectRegistryAgentPath,
+  resolveProjectRegistryAgentPath: () => resolveProjectRegistryAgentPath,
+  resolveProjectRegistryEntry: () => resolveProjectRegistryEntry,
+  resolveProjectRegistryEntryConfigPath: () => resolveProjectRegistryEntryConfigPath,
+  resolveProjectRegistryEntryConfigPathSync: () => resolveProjectRegistryEntryConfigPathSync
+});
+module.exports = __toCommonJS(project_registry_exports);
+var import_fs = require("fs");
+var import_fs2 = require("fs");
+var import_path = __toESM(require("path"), 1);
+var import_zod = require("zod");
+const NonEmptyStringSchema = import_zod.z.string().trim().min(1);
+const ProjectRegistryEntrySchema = import_zod.z.object({
+  id: NonEmptyStringSchema,
+  name: NonEmptyStringSchema,
+  description: NonEmptyStringSchema,
+  configPath: NonEmptyStringSchema,
+  author: NonEmptyStringSchema.optional(),
+  tags: import_zod.z.array(NonEmptyStringSchema).optional(),
+  parentAgentId: NonEmptyStringSchema.optional()
+}).strict();
+const ProjectRegistrySchema = import_zod.z.object({
+  primaryAgent: NonEmptyStringSchema.optional(),
+  allowGlobalAgents: import_zod.z.boolean().default(false),
+  agents: import_zod.z.array(ProjectRegistryEntrySchema)
+}).strict().superRefine((registry, ctx) => {
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const [index, agent] of registry.agents.entries()) {
+    if (seenIds.has(agent.id)) {
+      ctx.addIssue({
+        code: import_zod.z.ZodIssueCode.custom,
+        path: ["agents", index, "id"],
+        message: `Duplicate agent id '${agent.id}'.`
+      });
+      continue;
+    }
+    seenIds.add(agent.id);
+  }
+  if (registry.primaryAgent && !registry.agents.some((agent) => agent.id === registry.primaryAgent)) {
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      path: ["primaryAgent"],
+      message: `Primary agent '${registry.primaryAgent}' must match an agent id in 'agents'.`
+    });
+  }
+});
+class ProjectRegistryError extends Error {
+  code;
+  registryPath;
+  agentId;
+  configPath;
+  constructor(options) {
+    super(options.message, options.cause ? { cause: options.cause } : void 0);
+    this.name = "ProjectRegistryError";
+    this.code = options.code;
+    this.registryPath = options.registryPath;
+    this.agentId = options.agentId;
+    this.configPath = options.configPath;
+  }
+  static invalidRegistry(registryPath, message, cause) {
+    return new ProjectRegistryError({
+      code: "PROJECT_REGISTRY_INVALID",
+      message,
+      registryPath,
+      cause
+    });
+  }
+  static invalidPrimaryAgent(registryPath, primaryAgent) {
+    return new ProjectRegistryError({
+      code: "PROJECT_REGISTRY_INVALID_PRIMARY",
+      message: `Primary agent '${primaryAgent}' not found in ${registryPath}.`,
+      registryPath,
+      agentId: primaryAgent
+    });
+  }
+  static invalidConfigPath(options) {
+    return new ProjectRegistryError({
+      code: "PROJECT_REGISTRY_INVALID_CONFIG_PATH",
+      message: `Agent '${options.agentId}' in ${options.registryPath} has invalid configPath '${options.configPath}': ${options.reason}.`,
+      registryPath: options.registryPath,
+      agentId: options.agentId,
+      configPath: options.configPath
+    });
+  }
+}
+function isProjectRegistryError(error) {
+  return error instanceof ProjectRegistryError;
+}
+const PROJECT_REGISTRY_RELATIVE_PATHS = [
+  import_path.default.join("agents", "registry.json"),
+  import_path.default.join("agents", "agent-registry.json")
+];
+function getProjectRegistryPath(projectRoot) {
+  return import_path.default.join(projectRoot, "agents", "registry.json");
+}
+function getProjectRegistryCandidatePaths(projectRoot) {
+  return PROJECT_REGISTRY_RELATIVE_PATHS.map(
+    (relativePath) => import_path.default.join(projectRoot, relativePath)
+  );
+}
+async function findProjectRegistryPath(projectRoot) {
+  for (const registryPath of getProjectRegistryCandidatePaths(projectRoot)) {
+    try {
+      if ((await import_fs2.promises.stat(registryPath)).isFile()) {
+        return registryPath;
+      }
+    } catch (error) {
+      if (error.code === "ENOENT" || error.code === "ENOTDIR") {
+        continue;
+      }
+      throw error;
+    }
+  }
+  return null;
+}
+function findProjectRegistryPathSync(projectRoot) {
+  for (const registryPath of getProjectRegistryCandidatePaths(projectRoot)) {
+    try {
+      if ((0, import_fs.existsSync)(registryPath) && (0, import_fs.statSync)(registryPath).isFile()) {
+        return registryPath;
+      }
+    } catch (error) {
+      if (error.code === "EISDIR" || error.code === "ENOTDIR") {
+        continue;
+      }
+      throw error;
+    }
+  }
+  return null;
+}
+function parseProjectRegistryContent(content, registryPath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw ProjectRegistryError.invalidRegistry(
+        registryPath,
+        `Invalid workspace registry at ${registryPath}: ${error.message}`,
+        error
+      );
+    }
+    throw error;
+  }
+  try {
+    return ProjectRegistrySchema.parse(parsed);
+  } catch (error) {
+    if (error instanceof import_zod.z.ZodError) {
+      const rawPrimaryAgent = parsed && typeof parsed === "object" && typeof parsed.primaryAgent === "string" ? parsed.primaryAgent : void 0;
+      const hasPrimaryAgentIssue = error.issues.some(
+        (issue) => issue.path[0] === "primaryAgent"
+      );
+      if (hasPrimaryAgentIssue && rawPrimaryAgent) {
+        throw ProjectRegistryError.invalidPrimaryAgent(registryPath, rawPrimaryAgent);
+      }
+      throw ProjectRegistryError.invalidRegistry(
+        registryPath,
+        `Invalid workspace registry at ${registryPath}: ${error.message}`,
+        error
+      );
+    }
+    throw error;
+  }
+}
+async function readProjectRegistry(registryPath) {
+  const content = await import_fs2.promises.readFile(registryPath, "utf-8");
+  return parseProjectRegistryContent(content, registryPath);
+}
+function readProjectRegistrySync(registryPath) {
+  return parseProjectRegistryContent((0, import_fs.readFileSync)(registryPath, "utf-8"), registryPath);
+}
+async function loadProjectRegistry(projectRoot) {
+  const registryPath = await findProjectRegistryPath(projectRoot);
+  if (!registryPath) {
+    return null;
+  }
+  return {
+    registryPath,
+    registry: await readProjectRegistry(registryPath)
+  };
+}
+function loadProjectRegistrySync(projectRoot) {
+  const registryPath = findProjectRegistryPathSync(projectRoot);
+  if (!registryPath) {
+    return null;
+  }
+  return {
+    registryPath,
+    registry: readProjectRegistrySync(registryPath)
+  };
+}
+async function resolveProjectRegistryEntry(projectRoot, agentId) {
+  const loaded = await loadProjectRegistry(projectRoot);
+  if (!loaded) {
+    return null;
+  }
+  const entry = loaded.registry.agents.find((agent) => agent.id === agentId);
+  if (!entry) {
+    return null;
+  }
+  return {
+    registryPath: loaded.registryPath,
+    entry
+  };
+}
+function getDefaultProjectRegistryEntry(registry, registryPath) {
+  if (registry.primaryAgent) {
+    const primaryEntry = registry.agents.find((agent) => agent.id === registry.primaryAgent);
+    if (!primaryEntry) {
+      throw ProjectRegistryError.invalidPrimaryAgent(registryPath, registry.primaryAgent);
+    }
+    return primaryEntry;
+  }
+  if (registry.agents.length === 1) {
+    return registry.agents[0] ?? null;
+  }
+  return null;
+}
+function assertProjectRegistryConfigPathSync(options) {
+  const absolutePath = import_path.default.resolve(import_path.default.dirname(options.registryPath), options.entry.configPath);
+  const relativeToProject = import_path.default.relative(options.projectRoot, absolutePath);
+  if (relativeToProject.startsWith("..") || import_path.default.isAbsolute(relativeToProject) || relativeToProject === "") {
+    throw ProjectRegistryError.invalidConfigPath({
+      registryPath: options.registryPath,
+      agentId: options.entry.id,
+      configPath: options.entry.configPath,
+      reason: "path must stay within the workspace root"
+    });
+  }
+  let stat;
+  try {
+    stat = (0, import_fs.statSync)(absolutePath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw ProjectRegistryError.invalidConfigPath({
+        registryPath: options.registryPath,
+        agentId: options.entry.id,
+        configPath: options.entry.configPath,
+        reason: "file does not exist"
+      });
+    }
+    throw error;
+  }
+  if (!stat.isFile()) {
+    throw ProjectRegistryError.invalidConfigPath({
+      registryPath: options.registryPath,
+      agentId: options.entry.id,
+      configPath: options.entry.configPath,
+      reason: "path must point to a file"
+    });
+  }
+  return absolutePath;
+}
+async function assertProjectRegistryConfigPath(options) {
+  const absolutePath = import_path.default.resolve(import_path.default.dirname(options.registryPath), options.entry.configPath);
+  const relativeToProject = import_path.default.relative(options.projectRoot, absolutePath);
+  if (relativeToProject.startsWith("..") || import_path.default.isAbsolute(relativeToProject) || relativeToProject === "") {
+    throw ProjectRegistryError.invalidConfigPath({
+      registryPath: options.registryPath,
+      agentId: options.entry.id,
+      configPath: options.entry.configPath,
+      reason: "path must stay within the workspace root"
+    });
+  }
+  let stat;
+  try {
+    stat = await import_fs2.promises.stat(absolutePath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw ProjectRegistryError.invalidConfigPath({
+        registryPath: options.registryPath,
+        agentId: options.entry.id,
+        configPath: options.entry.configPath,
+        reason: "file does not exist"
+      });
+    }
+    throw error;
+  }
+  if (!stat.isFile()) {
+    throw ProjectRegistryError.invalidConfigPath({
+      registryPath: options.registryPath,
+      agentId: options.entry.id,
+      configPath: options.entry.configPath,
+      reason: "path must point to a file"
+    });
+  }
+  return absolutePath;
+}
+async function resolveProjectRegistryEntryConfigPath(projectRoot, registryPath, entry) {
+  return await assertProjectRegistryConfigPath({ projectRoot, registryPath, entry });
+}
+function resolveProjectRegistryEntryConfigPathSync(projectRoot, registryPath, entry) {
+  return assertProjectRegistryConfigPathSync({ projectRoot, registryPath, entry });
+}
+async function resolveProjectRegistryAgentPath(projectRoot, agentId) {
+  const resolved = await resolveProjectRegistryEntry(projectRoot, agentId);
+  if (!resolved) {
+    return null;
+  }
+  return await resolveProjectRegistryEntryConfigPath(
+    projectRoot,
+    resolved.registryPath,
+    resolved.entry
+  );
+}
+async function resolveDefaultProjectRegistryAgentPath(projectRoot) {
+  const loaded = await loadProjectRegistry(projectRoot);
+  if (!loaded) {
+    return null;
+  }
+  const entry = getDefaultProjectRegistryEntry(loaded.registry, loaded.registryPath);
+  if (!entry) {
+    return null;
+  }
+  return await resolveProjectRegistryEntryConfigPath(projectRoot, loaded.registryPath, entry);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProjectRegistryEntrySchema,
+  ProjectRegistryError,
+  ProjectRegistrySchema,
+  findProjectRegistryPath,
+  findProjectRegistryPathSync,
+  getDefaultProjectRegistryEntry,
+  getProjectRegistryCandidatePaths,
+  getProjectRegistryPath,
+  isProjectRegistryError,
+  loadProjectRegistry,
+  loadProjectRegistrySync,
+  readProjectRegistry,
+  readProjectRegistrySync,
+  resolveDefaultProjectRegistryAgentPath,
+  resolveProjectRegistryAgentPath,
+  resolveProjectRegistryEntry,
+  resolveProjectRegistryEntryConfigPath,
+  resolveProjectRegistryEntryConfigPathSync
+});

package/dist/project-registry.d.ts

@@ -0,0 +1,153 @@
+import { z } from 'zod';
+export declare const ProjectRegistryEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    configPath: z.ZodString;
+    author: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    parentAgentId: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    description: string;
+    configPath: string;
+    author?: string | undefined;
+    tags?: string[] | undefined;
+    parentAgentId?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    description: string;
+    configPath: string;
+    author?: string | undefined;
+    tags?: string[] | undefined;
+    parentAgentId?: string | undefined;
+}>;
+export type ProjectRegistryEntry = z.output<typeof ProjectRegistryEntrySchema>;
+export declare const ProjectRegistrySchema: z.ZodEffects<z.ZodObject<{
+    primaryAgent: z.ZodOptional<z.ZodString>;
+    allowGlobalAgents: z.ZodDefault<z.ZodBoolean>;
+    agents: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        configPath: z.ZodString;
+        author: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        parentAgentId: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        id: string;
+        name: string;
+        description: string;
+        configPath: string;
+        author?: string | undefined;
+        tags?: string[] | undefined;
+        parentAgentId?: string | undefined;
+    }, {
+        id: string;
+        name: string;
+        description: string;
+        configPath: string;
+        author?: string | undefined;
+        tags?: string[] | undefined;
+        parentAgentId?: string | undefined;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    agents: {
+        id: string;
+        name: string;
+        description: string;
+        configPath: string;
+        author?: string | undefined;
+        tags?: string[] | undefined;
+        parentAgentId?: string | undefined;
+    }[];
+    allowGlobalAgents: boolean;
+    primaryAgent?: string | undefined;
+}, {
+    agents: {
+        id: string;
+        name: string;
+        description: string;
+        configPath: string;
+        author?: string | undefined;
+        tags?: string[] | undefined;
+        parentAgentId?: string | undefined;
+    }[];
+    primaryAgent?: string | undefined;
+    allowGlobalAgents?: boolean | undefined;
+}>, {
+    agents: {
+        id: string;
+        name: string;
+        description: string;
+        configPath: string;
+        author?: string | undefined;
+        tags?: string[] | undefined;
+        parentAgentId?: string | undefined;
+    }[];
+    allowGlobalAgents: boolean;
+    primaryAgent?: string | undefined;
+}, {
+    agents: {
+        id: string;
+        name: string;
+        description: string;
+        configPath: string;
+        author?: string | undefined;
+        tags?: string[] | undefined;
+        parentAgentId?: string | undefined;
+    }[];
+    primaryAgent?: string | undefined;
+    allowGlobalAgents?: boolean | undefined;
+}>;
+export type ProjectRegistry = z.output<typeof ProjectRegistrySchema>;
+export type ProjectRegistryErrorCode = 'PROJECT_REGISTRY_INVALID' | 'PROJECT_REGISTRY_INVALID_PRIMARY' | 'PROJECT_REGISTRY_INVALID_CONFIG_PATH';
+export declare class ProjectRegistryError extends Error {
+    readonly code: ProjectRegistryErrorCode;
+    readonly registryPath: string;
+    readonly agentId: string | undefined;
+    readonly configPath: string | undefined;
+    constructor(options: {
+        code: ProjectRegistryErrorCode;
+        message: string;
+        registryPath: string;
+        agentId?: string | undefined;
+        configPath?: string | undefined;
+        cause?: unknown;
+    });
+    static invalidRegistry(registryPath: string, message: string, cause?: unknown): ProjectRegistryError;
+    static invalidPrimaryAgent(registryPath: string, primaryAgent: string): ProjectRegistryError;
+    static invalidConfigPath(options: {
+        registryPath: string;
+        agentId: string;
+        configPath: string;
+        reason: string;
+    }): ProjectRegistryError;
+}
+export declare function isProjectRegistryError(error: unknown): error is ProjectRegistryError;
+export declare function getProjectRegistryPath(projectRoot: string): string;
+export declare function getProjectRegistryCandidatePaths(projectRoot: string): string[];
+export declare function findProjectRegistryPath(projectRoot: string): Promise<string | null>;
+export declare function findProjectRegistryPathSync(projectRoot: string): string | null;
+export declare function readProjectRegistry(registryPath: string): Promise<ProjectRegistry>;
+export declare function readProjectRegistrySync(registryPath: string): ProjectRegistry;
+export declare function loadProjectRegistry(projectRoot: string): Promise<{
+    registryPath: string;
+    registry: ProjectRegistry;
+} | null>;
+export declare function loadProjectRegistrySync(projectRoot: string): {
+    registryPath: string;
+    registry: ProjectRegistry;
+} | null;
+export declare function resolveProjectRegistryEntry(projectRoot: string, agentId: string): Promise<{
+    registryPath: string;
+    entry: ProjectRegistryEntry;
+} | null>;
+export declare function getDefaultProjectRegistryEntry(registry: ProjectRegistry, registryPath: string): ProjectRegistryEntry | null;
+export declare function resolveProjectRegistryEntryConfigPath(projectRoot: string, registryPath: string, entry: ProjectRegistryEntry): Promise<string>;
+export declare function resolveProjectRegistryEntryConfigPathSync(projectRoot: string, registryPath: string, entry: ProjectRegistryEntry): string;
+export declare function resolveProjectRegistryAgentPath(projectRoot: string, agentId: string): Promise<string | null>;
+export declare function resolveDefaultProjectRegistryAgentPath(projectRoot: string): Promise<string | null>;
+//# sourceMappingURL=project-registry.d.ts.map