@dexto/agent-management 1.6.0 → 1.6.2

package/dist/tool-factories/creator-tools/factory.js

@@ -0,0 +1,407 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { parse as yamlParse } from "yaml";
+import {
+  ToolError,
+  defineTool,
+  assertValidPromptName
+} from "@dexto/core";
+import { discoverStandaloneSkills, getSkillSearchPaths } from "../../plugins/discover-skills.js";
+import {
+  CREATOR_TOOL_NAMES,
+  CreatorToolsConfigSchema
+} from "./schemas.js";
+import { getDextoGlobalPath } from "../../utils/path.js";
+import { z } from "zod";
+const SkillCreateInputSchema = z.object({
+  id: z.string().min(1).describe("Skill id (kebab-case)."),
+  description: z.string().min(1).describe("Short description of what the skill does."),
+  content: z.string().min(1).describe("Skill body (markdown) without frontmatter."),
+  allowedTools: z.array(z.string().min(1)).optional().describe("Optional allowed-tools list for the skill frontmatter."),
+  toolkits: z.array(z.string().min(1)).optional().describe("Optional toolkits list for the skill frontmatter."),
+  scope: z.enum(["global", "workspace"]).optional(),
+  overwrite: z.boolean().optional()
+}).strict();
+const SkillUpdateInputSchema = z.object({
+  id: z.string().min(1),
+  content: z.string().min(1).describe("New SKILL.md body (markdown) without frontmatter."),
+  description: z.string().min(1).optional(),
+  allowedTools: z.array(z.string().min(1)).optional().describe("Optional allowed-tools list for the skill frontmatter."),
+  toolkits: z.array(z.string().min(1)).optional().describe("Optional toolkits list for the skill frontmatter."),
+  scope: z.enum(["global", "workspace"]).optional()
+}).strict();
+const SkillListInputSchema = z.object({
+  projectPath: z.string().optional(),
+  query: z.string().optional().describe("Optional search term to filter skills by name or path")
+}).strict();
+const SkillSearchInputSchema = z.object({
+  query: z.string().optional().describe("Optional search term to filter skills by name or description"),
+  limit: z.number().int().min(1).max(200).optional().describe(
+    "Maximum number of skills to return. If omitted, all matches are returned for queries; otherwise defaults to 50."
+  )
+}).strict();
+const ToolCatalogInputSchema = z.object({
+  query: z.string().optional().describe("Optional search term to filter tools by id or description"),
+  limit: z.number().int().min(1).max(500).optional().describe("Maximum number of tools to return (defaults to all)."),
+  includeDescriptions: z.boolean().optional().describe("Include tool descriptions (defaults to true).")
+}).strict();
+function normalizeSkillQuery(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function matchesSkillQuery(value, query) {
+  if (!value) return false;
+  const normalizedQuery = normalizeSkillQuery(query);
+  if (!normalizedQuery) return false;
+  return normalizeSkillQuery(value).includes(normalizedQuery);
+}
+function resolvePromptSkillName(info, id) {
+  return info.displayName || info.name || id;
+}
+function resolveWorkspaceBasePath(context) {
+  const workspacePath = context.workspace?.path;
+  const fallbackWorkingDir = context.services ? context.services.filesystemService?.getConfig().workingDirectory : void 0;
+  return workspacePath || fallbackWorkingDir || process.cwd();
+}
+function resolveWorkspaceSkillDirs(context) {
+  const base = resolveWorkspaceBasePath(context);
+  return {
+    primary: path.join(base, ".agents", "skills"),
+    legacy: path.join(base, ".dexto", "skills")
+  };
+}
+function resolveSkillBaseDirectory(scope, context) {
+  if (scope === "global") {
+    return { baseDir: getDextoGlobalPath("skills"), scope: "global" };
+  }
+  return { baseDir: resolveWorkspaceSkillDirs(context).primary, scope: "workspace" };
+}
+function resolveSkillDirectory(input, context) {
+  return resolveSkillBaseDirectory(input.scope, context);
+}
+async function pathExists(filePath) {
+  return await fs.stat(filePath).then(() => true).catch(() => false);
+}
+async function resolveSkillUpdateDirectory(input, context) {
+  if (input.scope === "global") {
+    return resolveSkillBaseDirectory("global", context);
+  }
+  const { primary, legacy } = resolveWorkspaceSkillDirs(context);
+  const skillId = input.id.trim();
+  const primaryFile = path.join(primary, skillId, "SKILL.md");
+  if (await pathExists(primaryFile)) {
+    return { baseDir: primary, scope: "workspace" };
+  }
+  const legacyFile = path.join(legacy, skillId, "SKILL.md");
+  if (await pathExists(legacyFile)) {
+    return { baseDir: legacy, scope: "workspace" };
+  }
+  return { baseDir: primary, scope: "workspace" };
+}
+function ensurePathWithinBase(baseDir, targetDir, toolId) {
+  const resolvedBase = path.resolve(baseDir);
+  const resolvedTarget = path.resolve(targetDir);
+  const rel = path.relative(resolvedBase, resolvedTarget);
+  if (rel.startsWith("..") || path.isAbsolute(rel)) {
+    throw ToolError.validationFailed(toolId, "invalid skill path");
+  }
+}
+function formatFrontmatterLine(key, value) {
+  if (typeof value === "string") {
+    return `${key}: ${JSON.stringify(value)}`;
+  }
+  return `${key}: ${value}`;
+}
+function titleizeSkillId(id) {
+  return id.split("-").filter(Boolean).map((segment) => segment[0]?.toUpperCase() + segment.slice(1)).join(" ");
+}
+function resolveSkillCreateInput(input) {
+  const id = input.id.trim();
+  const description = input.description.trim();
+  const content = input.content.trim();
+  return {
+    ...input,
+    id,
+    description,
+    content
+  };
+}
+function formatFrontmatterList(key, values) {
+  const normalized = values.map((value) => JSON.stringify(value.trim()));
+  return `${key}: [${normalized.join(", ")}]`;
+}
+function buildSkillMarkdownFromParts(options) {
+  const id = options.id.trim();
+  const title = titleizeSkillId(id) || id;
+  const lines = ["---"];
+  lines.push(formatFrontmatterLine("name", id));
+  lines.push(formatFrontmatterLine("description", options.description.trim()));
+  if (options.toolkits && options.toolkits.length > 0) {
+    lines.push(formatFrontmatterList("toolkits", options.toolkits));
+  }
+  if (options.allowedTools && options.allowedTools.length > 0) {
+    lines.push(formatFrontmatterList("allowed-tools", options.allowedTools));
+  }
+  lines.push("---", "", `# ${title}`, "", options.content.trim());
+  return lines.join("\n").replace(/\n{3,}/g, "\n\n");
+}
+function buildSkillMarkdown(input) {
+  return buildSkillMarkdownFromParts({
+    id: input.id,
+    description: input.description,
+    content: input.content,
+    allowedTools: input.allowedTools,
+    toolkits: input.toolkits
+  });
+}
+async function readSkillFrontmatter(skillFile) {
+  try {
+    const raw = await fs.readFile(skillFile, "utf-8");
+    const match = raw.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+    if (!match) return {};
+    const frontmatter = yamlParse(match[1] ?? "");
+    if (!frontmatter || typeof frontmatter !== "object") return {};
+    const name = typeof frontmatter.name === "string" ? frontmatter.name.trim() : void 0;
+    const description = typeof frontmatter.description === "string" ? frontmatter.description.trim() : void 0;
+    const allowedToolsRaw = frontmatter["allowed-tools"];
+    const toolkitsRaw = frontmatter.toolkits;
+    const allowedTools = Array.isArray(allowedToolsRaw) ? allowedToolsRaw.filter((item) => typeof item === "string").map((item) => item.trim()).filter((item) => item.length > 0) : void 0;
+    const toolkits = Array.isArray(toolkitsRaw) ? toolkitsRaw.filter((item) => typeof item === "string").map((item) => item.trim()).filter((item) => item.length > 0) : void 0;
+    const result = {};
+    if (name) result.name = name;
+    if (description) result.description = description;
+    if (allowedTools && allowedTools.length > 0) result.allowedTools = allowedTools;
+    if (toolkits && toolkits.length > 0) result.toolkits = toolkits;
+    return result;
+  } catch {
+    return {};
+  }
+}
+async function refreshAgentPrompts(context, skillFile) {
+  const agent = context.agent;
+  if (!agent) return false;
+  const effective = agent.getEffectiveConfig();
+  const existingPrompts = Array.isArray(effective.prompts) ? [...effective.prompts] : [];
+  const alreadyPresent = existingPrompts.some((prompt) => {
+    if (!prompt || typeof prompt !== "object") return false;
+    const record = prompt;
+    return record.type === "file" && record.file === skillFile;
+  });
+  const nextPrompts = alreadyPresent ? existingPrompts : [...existingPrompts, { type: "file", file: skillFile }];
+  await agent.refreshPrompts(nextPrompts);
+  return true;
+}
+const creatorToolsFactory = {
+  configSchema: CreatorToolsConfigSchema,
+  metadata: {
+    displayName: "Creator Tools",
+    description: "Create and manage standalone skills",
+    category: "agents"
+  },
+  create: (config) => {
+    const enabledTools = config.enabledTools ?? CREATOR_TOOL_NAMES;
+    const skillCreateTool = defineTool({
+      id: "skill_create",
+      description: "Create a standalone SKILL.md file and register it with the running agent. Provide id, description, content, and optional toolkits/allowedTools.",
+      inputSchema: SkillCreateInputSchema,
+      execute: async (input, context) => {
+        const resolvedInput = resolveSkillCreateInput(input);
+        const skillId = resolvedInput.id.trim();
+        assertValidPromptName(skillId, {
+          context: "skill_create",
+          hint: "Use kebab-case skill ids (e.g., release-notes)"
+        });
+        const { baseDir, scope } = resolveSkillDirectory(resolvedInput, context);
+        const skillDir = path.join(baseDir, skillId);
+        ensurePathWithinBase(baseDir, skillDir, "skill_create");
+        const skillFile = path.join(skillDir, "SKILL.md");
+        const exists = await pathExists(skillFile);
+        if (exists && !resolvedInput.overwrite) {
+          throw ToolError.validationFailed(
+            "skill_create",
+            `Skill already exists at ${skillFile}`
+          );
+        }
+        const markdown = buildSkillMarkdown(resolvedInput);
+        await fs.mkdir(skillDir, { recursive: true });
+        await fs.writeFile(skillFile, markdown, "utf-8");
+        const refreshed = await refreshAgentPrompts(context, skillFile);
+        const displayName = titleizeSkillId(skillId) || skillId;
+        return {
+          created: true,
+          id: skillId,
+          name: displayName,
+          description: resolvedInput.description.trim(),
+          scope,
+          path: skillFile,
+          promptsRefreshed: refreshed
+        };
+      }
+    });
+    const skillUpdateTool = defineTool({
+      id: "skill_update",
+      description: "Update an existing standalone SKILL.md file.",
+      inputSchema: SkillUpdateInputSchema,
+      execute: async (input, context) => {
+        const skillId = input.id.trim();
+        assertValidPromptName(skillId, {
+          context: "skill_update",
+          hint: "Use kebab-case skill ids (e.g., release-notes)"
+        });
+        const { baseDir, scope } = await resolveSkillUpdateDirectory(input, context);
+        const skillDir = path.join(baseDir, skillId);
+        ensurePathWithinBase(baseDir, skillDir, "skill_update");
+        const skillFile = path.join(skillDir, "SKILL.md");
+        const exists = await pathExists(skillFile);
+        if (!exists) {
+          throw ToolError.validationFailed(
+            "skill_update",
+            `Skill not found at ${skillFile}`
+          );
+        }
+        const existing = await readSkillFrontmatter(skillFile);
+        const description = input.description?.trim() || existing.description;
+        if (!description) {
+          throw ToolError.validationFailed(
+            "skill_update",
+            "description is required when the existing skill is missing one"
+          );
+        }
+        const allowedTools = input.allowedTools !== void 0 ? input.allowedTools : existing.allowedTools;
+        const toolkits = input.toolkits !== void 0 ? input.toolkits : existing.toolkits;
+        const markdown = buildSkillMarkdownFromParts({
+          id: skillId,
+          description,
+          content: input.content.trim(),
+          allowedTools,
+          toolkits
+        });
+        await fs.writeFile(skillFile, markdown, "utf-8");
+        const refreshed = await refreshAgentPrompts(context, skillFile);
+        return {
+          updated: true,
+          id: skillId,
+          description,
+          scope,
+          path: skillFile,
+          promptsRefreshed: refreshed
+        };
+      }
+    });
+    const skillSearchTool = defineTool({
+      id: "skill_search",
+      description: "Search loaded skills (supports query).",
+      inputSchema: SkillSearchInputSchema,
+      execute: async (input, context) => {
+        const query = input.query?.trim() ?? "";
+        const normalizedQuery = normalizeSkillQuery(query);
+        const hasQuery = normalizedQuery.length > 0;
+        const limit = input.limit ?? (hasQuery ? void 0 : 50);
+        const promptManager = context.services?.prompts;
+        if (!promptManager) {
+          throw ToolError.configInvalid(
+            "skill_search requires ToolExecutionContext.services.prompts"
+          );
+        }
+        const loaded = await promptManager.list();
+        let results = Object.entries(loaded).map(([id, info]) => ({
+          id,
+          name: resolvePromptSkillName(info, id),
+          ...info.displayName ? { displayName: info.displayName } : {},
+          ...info.commandName ? { commandName: info.commandName } : {},
+          ...info.description ? { description: info.description } : {},
+          ...info.context ? { context: info.context } : {},
+          ...info.agent ? { agent: info.agent } : {}
+        }));
+        if (hasQuery && normalizedQuery) {
+          results = results.filter((entry) => {
+            if (matchesSkillQuery(entry.id, normalizedQuery)) return true;
+            if (matchesSkillQuery(entry.name, normalizedQuery)) return true;
+            if (matchesSkillQuery(entry.displayName, normalizedQuery)) return true;
+            if (matchesSkillQuery(entry.commandName, normalizedQuery)) return true;
+            if (matchesSkillQuery(entry.description, normalizedQuery)) return true;
+            return false;
+          });
+        }
+        results.sort((a, b) => a.name.localeCompare(b.name));
+        const limited = typeof limit === "number" ? results.slice(0, limit) : results;
+        return {
+          query: input.query?.trim(),
+          count: limited.length,
+          total: results.length,
+          skills: limited,
+          _hint: limited.length > 0 ? "Use invoke_skill with the skill id or commandName for loaded skills." : "No skills matched the query."
+        };
+      }
+    });
+    const skillListTool = defineTool({
+      id: "skill_list",
+      description: "List discovered standalone skills and their search paths. Supports optional query filtering.",
+      inputSchema: SkillListInputSchema,
+      execute: async (input) => {
+        const query = input.query?.trim().toLowerCase();
+        const skills = discoverStandaloneSkills(input.projectPath);
+        const filtered = query ? skills.filter((skill) => {
+          if (skill.name.toLowerCase().includes(query)) return true;
+          if (skill.path.toLowerCase().includes(query)) return true;
+          if (skill.skillFile.toLowerCase().includes(query)) return true;
+          return false;
+        }) : skills;
+        return {
+          searchPaths: getSkillSearchPaths(),
+          skills: filtered
+        };
+      }
+    });
+    const toolCatalogTool = defineTool({
+      id: "tool_catalog",
+      description: "List available tools and configured toolkits for the current agent (from the loaded image/config).",
+      inputSchema: ToolCatalogInputSchema,
+      execute: async (input, context) => {
+        const agent = context.agent;
+        if (!agent) {
+          throw ToolError.configInvalid(
+            "tool_catalog requires ToolExecutionContext.agent"
+          );
+        }
+        const toolSet = await agent.getAllTools();
+        let tools = Object.entries(toolSet).map(([id, tool]) => ({
+          id,
+          description: tool.description || "No description provided",
+          source: id.startsWith("mcp--") ? "mcp" : "local"
+        }));
+        const query = input.query?.trim().toLowerCase();
+        if (query) {
+          tools = tools.filter((tool) => {
+            if (tool.id.toLowerCase().includes(query)) return true;
+            if ((tool.description ?? "").toLowerCase().includes(query)) return true;
+            return false;
+          });
+        }
+        tools.sort((a, b) => a.id.localeCompare(b.id));
+        const includeDescriptions = input.includeDescriptions !== false;
+        if (!includeDescriptions) {
+          tools = tools.map((tool) => ({ id: tool.id, source: tool.source }));
+        }
+        const limited = typeof input.limit === "number" ? tools.slice(0, input.limit) : tools;
+        return {
+          query: input.query?.trim(),
+          count: limited.length,
+          total: tools.length,
+          tools: limited,
+          _hint: limited.length > 0 ? "Use tool ids in allowed-tools. Use toolkits from the agent config or image defaults." : "No tools matched the query."
+        };
+      }
+    });
+    const toolCreators = {
+      skill_create: () => skillCreateTool,
+      skill_update: () => skillUpdateTool,
+      skill_search: () => skillSearchTool,
+      skill_list: () => skillListTool,
+      tool_catalog: () => toolCatalogTool
+    };
+    return enabledTools.map((toolName) => toolCreators[toolName]());
+  }
+};
+export {
+  creatorToolsFactory
+};

package/dist/tool-factories/creator-tools/index.cjs

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var creator_tools_exports = {};
+__export(creator_tools_exports, {
+  CREATOR_TOOL_NAMES: () => import_schemas.CREATOR_TOOL_NAMES,
+  CreatorToolsConfigSchema: () => import_schemas.CreatorToolsConfigSchema,
+  creatorToolsFactory: () => import_factory.creatorToolsFactory
+});
+module.exports = __toCommonJS(creator_tools_exports);
+var import_factory = require("./factory.js");
+var import_schemas = require("./schemas.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CREATOR_TOOL_NAMES,
+  CreatorToolsConfigSchema,
+  creatorToolsFactory
+});

package/dist/tool-factories/creator-tools/index.d.ts

@@ -0,0 +1,3 @@
+export { creatorToolsFactory } from './factory.js';
+export { CreatorToolsConfigSchema, CREATOR_TOOL_NAMES, type CreatorToolsConfig, type CreatorToolName, } from './schemas.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/tool-factories/creator-tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tool-factories/creator-tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,EACH,wBAAwB,EACxB,kBAAkB,EAClB,KAAK,kBAAkB,EACvB,KAAK,eAAe,GACvB,MAAM,cAAc,CAAC"}

package/dist/tool-factories/creator-tools/index.js

@@ -0,0 +1,10 @@
+import { creatorToolsFactory } from "./factory.js";
+import {
+  CreatorToolsConfigSchema,
+  CREATOR_TOOL_NAMES
+} from "./schemas.js";
+export {
+  CREATOR_TOOL_NAMES,
+  CreatorToolsConfigSchema,
+  creatorToolsFactory
+};

package/dist/tool-factories/creator-tools/schemas.cjs

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schemas_exports = {};
+__export(schemas_exports, {
+  CREATOR_TOOL_NAMES: () => CREATOR_TOOL_NAMES,
+  CreatorToolsConfigSchema: () => CreatorToolsConfigSchema
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_zod = require("zod");
+const CREATOR_TOOL_NAMES = [
+  "skill_create",
+  "skill_update",
+  "skill_search",
+  "skill_list",
+  "tool_catalog"
+];
+const CreatorToolsConfigSchema = import_zod.z.object({
+  type: import_zod.z.literal("creator-tools"),
+  enabledTools: import_zod.z.array(import_zod.z.enum(CREATOR_TOOL_NAMES)).optional().describe("Subset of creator tools to enable")
+}).strict();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CREATOR_TOOL_NAMES,
+  CreatorToolsConfigSchema
+});

package/dist/tool-factories/creator-tools/schemas.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare const CREATOR_TOOL_NAMES: readonly ["skill_create", "skill_update", "skill_search", "skill_list", "tool_catalog"];
+export type CreatorToolName = (typeof CREATOR_TOOL_NAMES)[number];
+export declare const CreatorToolsConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"creator-tools">;
+    enabledTools: z.ZodOptional<z.ZodArray<z.ZodEnum<["skill_create", "skill_update", "skill_search", "skill_list", "tool_catalog"]>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    type: "creator-tools";
+    enabledTools?: ("skill_create" | "skill_update" | "skill_search" | "skill_list" | "tool_catalog")[] | undefined;
+}, {
+    type: "creator-tools";
+    enabledTools?: ("skill_create" | "skill_update" | "skill_search" | "skill_list" | "tool_catalog")[] | undefined;
+}>;
+export type CreatorToolsConfig = z.output<typeof CreatorToolsConfigSchema>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/tool-factories/creator-tools/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/tool-factories/creator-tools/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB,yFAMrB,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC;AAElE,eAAO,MAAM,wBAAwB;;;;;;;;;EAQxB,CAAC;AAEd,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/tool-factories/creator-tools/schemas.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+const CREATOR_TOOL_NAMES = [
+  "skill_create",
+  "skill_update",
+  "skill_search",
+  "skill_list",
+  "tool_catalog"
+];
+const CreatorToolsConfigSchema = z.object({
+  type: z.literal("creator-tools"),
+  enabledTools: z.array(z.enum(CREATOR_TOOL_NAMES)).optional().describe("Subset of creator tools to enable")
+}).strict();
+export {
+  CREATOR_TOOL_NAMES,
+  CreatorToolsConfigSchema
+};

package/dist/utils/path.cjs

@@ -83,6 +83,15 @@ function getDextoPath(type, filename, startPath) {
   return filename ? path.join(basePath, filename) : basePath;
 }
 function getDextoGlobalPath(type, filename) {
+  const isDevMode = process.env.DEXTO_DEV_MODE === "true";
+  if (isDevMode && (0, import_execution_context.getExecutionContext)() === "dexto-source") {
+    const sourceRoot = (0, import_execution_context.findDextoSourceRoot)();
+    if (!sourceRoot) {
+      throw new Error("Not in dexto source context");
+    }
+    const devBasePath = path.join(sourceRoot, ".dexto", type);
+    return filename ? path.join(devBasePath, filename) : devBasePath;
+  }
   const basePath = path.join((0, import_os.homedir)(), ".dexto", type);
   return filename ? path.join(basePath, filename) : basePath;
 }
@@ -151,7 +160,7 @@ function resolveBundledScript(scriptPath) {
   );
 }
 async function ensureDextoGlobalDirectory() {
-  const dextoDir = path.join((0, import_os.homedir)(), ".dexto");
+  const dextoDir = getDextoGlobalPath("");
   try {
     await import_fs2.promises.mkdir(dextoDir, { recursive: true });
   } catch (error) {

package/dist/utils/path.d.ts

@@ -12,8 +12,11 @@
  */
 export declare function getDextoPath(type: string, filename?: string, startPath?: string): string;
 /**
- * Global path resolver that ALWAYS returns paths in the user's home directory
- * Used for agent registry and other global-only resources that should not be project-relative
+ * Global path resolver for user-global resources that should not be project-relative.
+ *
+ * Dev mode support:
+ * - dexto-source + DEXTO_DEV_MODE=true: Use repo-local `.dexto` (isolated testing)
+ * - otherwise: Use global `~/.dexto` (user experience)
  * @param type Path type (agents, cache, etc.)
  * @param filename Optional filename to append
  * @returns Absolute path to the global location (~/.dexto/...)

package/dist/utils/path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/utils/path.ts"],"names":[],"mappings":"AAgBA;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAuCxF;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAI1E;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAe5E;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAW3C;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,SAAS,GAAE,MAAsB,GAAG,MAAM,GAAG,IAAI,CAKhF;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAwD/D;AAED;;GAEG;AACH,wBAAsB,0BAA0B,IAAI,OAAO,CAAC,IAAI,CAAC,CAUhE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,SAAS,GAAE,MAAsB,GAAG,MAAM,CAkCzE"}
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/utils/path.ts"],"names":[],"mappings":"AAgBA;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAuCxF;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAc1E;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAe5E;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAW3C;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,SAAS,GAAE,MAAsB,GAAG,MAAM,GAAG,IAAI,CAKhF;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAwD/D;AAED;;GAEG;AACH,wBAAsB,0BAA0B,IAAI,OAAO,CAAC,IAAI,CAAC,CAUhE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,SAAS,GAAE,MAAsB,GAAG,MAAM,CAkCzE"}

package/dist/utils/path.js

@@ -46,6 +46,15 @@ function getDextoPath(type, filename, startPath) {
   return filename ? path.join(basePath, filename) : basePath;
 }
 function getDextoGlobalPath(type, filename) {
+  const isDevMode = process.env.DEXTO_DEV_MODE === "true";
+  if (isDevMode && getExecutionContext() === "dexto-source") {
+    const sourceRoot = findDextoSourceRoot();
+    if (!sourceRoot) {
+      throw new Error("Not in dexto source context");
+    }
+    const devBasePath = path.join(sourceRoot, ".dexto", type);
+    return filename ? path.join(devBasePath, filename) : devBasePath;
+  }
   const basePath = path.join(homedir(), ".dexto", type);
   return filename ? path.join(basePath, filename) : basePath;
 }
@@ -114,7 +123,7 @@ function resolveBundledScript(scriptPath) {
   );
 }
 async function ensureDextoGlobalDirectory() {
-  const dextoDir = path.join(homedir(), ".dexto");
+  const dextoDir = getDextoGlobalPath("");
   try {
     await fs.mkdir(dextoDir, { recursive: true });
   } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexto/agent-management",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",
@@ -16,10 +16,10 @@
   "dependencies": {
     "yaml": "^2.7.1",
     "zod": "^3.25.0",
-    "@dexto/agent-config": "1.6.0",
-    "@dexto/core": "1.6.0",
-    "@dexto/orchestration": "1.6.0",
-    "@dexto/tools-builtins": "1.6.0"
+    "@dexto/agent-config": "1.6.2",
+    "@dexto/core": "1.6.2",
+    "@dexto/orchestration": "1.6.2",
+    "@dexto/tools-builtins": "1.6.2"
   },
   "devDependencies": {
     "@types/node": "^22.13.5"
@@ -36,7 +36,7 @@
   },
   "sideEffects": false,
   "scripts": {
-    "build": "cross-env NODE_OPTIONS='--max-old-space-size=4096' tsup && cross-env NODE_OPTIONS='--max-old-space-size=4096' tsc -b tsconfig.json --force --emitDeclarationOnly && node scripts/fix-dist-aliases.mjs",
+    "build": "cross-env NODE_OPTIONS='--max-old-space-size=4096' tsup && node ../../scripts/clean-tsbuildinfo.mjs && cross-env NODE_OPTIONS='--max-old-space-size=4096' tsc -b tsconfig.json --emitDeclarationOnly && node scripts/fix-dist-aliases.mjs",
     "dev": "tsup --watch",
     "typecheck": "tsc -p tsconfig.typecheck.json --noEmit",
     "lint": "eslint . --ext .ts"