@dexto/agent-management 1.6.13 → 1.6.15

package/dist/project-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-registry.d.ts","sourceRoot":"","sources":["../src/project-registry.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;EAU1B,CAAC;AAEd,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE/E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgC5B,CAAC;AAEP,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAErE,MAAM,MAAM,wBAAwB,GAC9B,0BAA0B,GAC1B,kCAAkC,GAClC,sCAAsC,CAAC;AAE7C,qBAAa,oBAAqB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC;IACxC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IACrC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;gBAE5B,OAAO,EAAE;QACjB,IAAI,EAAE,wBAAwB,CAAC;QAC/B,OAAO,EAAE,MAAM,CAAC;QAChB,YAAY,EAAE,MAAM,CAAC;QACrB,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAC7B,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAChC,KAAK,CAAC,EAAE,OAAO,CAAC;KACnB;IASD,MAAM,CAAC,eAAe,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO;IAS7E,MAAM,CAAC,mBAAmB,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;IASrE,MAAM,CAAC,iBAAiB,CAAC,OAAO,EAAE;QAC9B,YAAY,EAAE,MAAM,CAAC;QACrB,OAAO,EAAE,MAAM,CAAC;QAChB,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,EAAE,MAAM,CAAC;KAClB;CASJ;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,oBAAoB,CAEpF;AAOD,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAElE;AAED,wBAAgB,gCAAgC,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE,CAI9E;AAED,wBAAsB,uBAAuB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAkBzF;AAED,wBAAgB,2BAA2B,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAkB9E;AA+CD,wBAAsB,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAGxF;AAED,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,eAAe,CAE7E;AAED,wBAAsB,mBAAmB,CACrC,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,eAAe,CAAA;CAAE,GAAG,IAAI,CAAC,CAUrE;AAED,wBAAgB,uBAAuB,CACnC,WAAW,EAAE,MAAM,GACpB;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,eAAe,CAAA;CAAE,GAAG,IAAI,CAU5D;AAED,wBAAsB,2BAA2B,CAC7C,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GAChB,OAAO,CAAC;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,oBAAoB,CAAA;CAAE,GAAG,IAAI,CAAC,CAevE;AAED,wBAAgB,8BAA8B,CAC1C,QAAQ,EAAE,eAAe,EACzB,YAAY,EAAE,MAAM,GACrB,oBAAoB,GAAG,IAAI,CAc7B;AAgGD,wBAAsB,qCAAqC,CACvD,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,oBAAoB,GAC5B,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED,wBAAgB,yCAAyC,CACrD,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,oBAAoB,GAC5B,MAAM,CAER;AAED,wBAAsB,+BAA+B,CACjD,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GAChB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAWxB;AAED,wBAAsB,sCAAsC,CACxD,WAAW,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAYxB"}

package/dist/project-registry.js

@@ -0,0 +1,329 @@
+import { existsSync, readFileSync, statSync } from "fs";
+import { promises as fs } from "fs";
+import path from "path";
+import { z } from "zod";
+const NonEmptyStringSchema = z.string().trim().min(1);
+const ProjectRegistryEntrySchema = z.object({
+  id: NonEmptyStringSchema,
+  name: NonEmptyStringSchema,
+  description: NonEmptyStringSchema,
+  configPath: NonEmptyStringSchema,
+  author: NonEmptyStringSchema.optional(),
+  tags: z.array(NonEmptyStringSchema).optional(),
+  parentAgentId: NonEmptyStringSchema.optional()
+}).strict();
+const ProjectRegistrySchema = z.object({
+  primaryAgent: NonEmptyStringSchema.optional(),
+  allowGlobalAgents: z.boolean().default(false),
+  agents: 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: 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: 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 = [
+  path.join("agents", "registry.json"),
+  path.join("agents", "agent-registry.json")
+];
+function getProjectRegistryPath(projectRoot) {
+  return path.join(projectRoot, "agents", "registry.json");
+}
+function getProjectRegistryCandidatePaths(projectRoot) {
+  return PROJECT_REGISTRY_RELATIVE_PATHS.map(
+    (relativePath) => path.join(projectRoot, relativePath)
+  );
+}
+async function findProjectRegistryPath(projectRoot) {
+  for (const registryPath of getProjectRegistryCandidatePaths(projectRoot)) {
+    try {
+      if ((await fs.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 (existsSync(registryPath) && 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 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 fs.readFile(registryPath, "utf-8");
+  return parseProjectRegistryContent(content, registryPath);
+}
+function readProjectRegistrySync(registryPath) {
+  return parseProjectRegistryContent(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 = path.resolve(path.dirname(options.registryPath), options.entry.configPath);
+  const relativeToProject = path.relative(options.projectRoot, absolutePath);
+  if (relativeToProject.startsWith("..") || path.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 = 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 = path.resolve(path.dirname(options.registryPath), options.entry.configPath);
+  const relativeToProject = path.relative(options.projectRoot, absolutePath);
+  if (relativeToProject.startsWith("..") || path.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 fs.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);
+}
+export {
+  ProjectRegistryEntrySchema,
+  ProjectRegistryError,
+  ProjectRegistrySchema,
+  findProjectRegistryPath,
+  findProjectRegistryPathSync,
+  getDefaultProjectRegistryEntry,
+  getProjectRegistryCandidatePaths,
+  getProjectRegistryPath,
+  isProjectRegistryError,
+  loadProjectRegistry,
+  loadProjectRegistrySync,
+  readProjectRegistry,
+  readProjectRegistrySync,
+  resolveDefaultProjectRegistryAgentPath,
+  resolveProjectRegistryAgentPath,
+  resolveProjectRegistryEntry,
+  resolveProjectRegistryEntryConfigPath,
+  resolveProjectRegistryEntryConfigPathSync
+};

package/dist/resolver.cjs

@@ -42,6 +42,7 @@ var import_config = require("./config/index.js");
 var import_errors = require("./registry/errors.js");
 var import_AgentManager = require("./AgentManager.js");
 var import_installation = require("./installation.js");
+var import_project_registry = require("./project-registry.js");
 async function resolveAgentPath(nameOrPath, autoInstall = true) {
   if (nameOrPath && (0, import_path2.isPath)(nameOrPath)) {
     const resolved = import_path.default.resolve(nameOrPath);
@@ -153,10 +154,30 @@ async function resolveDefaultAgentForDextoProject(autoInstall = true) {
   if (!projectRoot) {
     throw import_config.ConfigError.unknownContext("dexto-project: project root not found");
   }
+  try {
+    const projectRegistryAgentPath = await (0, import_project_registry.resolveDefaultProjectRegistryAgentPath)(projectRoot);
+    if (projectRegistryAgentPath) {
+      return projectRegistryAgentPath;
+    }
+  } catch (error) {
+    if ((0, import_project_registry.isProjectRegistryError)(error) && error.code === "PROJECT_REGISTRY_INVALID_PRIMARY") {
+      throw import_config.ConfigError.invalidProjectPrimary(
+        error.registryPath,
+        error.agentId ?? "",
+        error.message
+      );
+    }
+    throw error;
+  }
   const candidatePaths = [
+    import_path.default.join(projectRoot, "agents", "coding-agent", "coding-agent.yml"),
+    import_path.default.join(projectRoot, "agents", "coding-agent", "coding-agent.yaml"),
     import_path.default.join(projectRoot, "coding-agent.yml"),
+    import_path.default.join(projectRoot, "coding-agent.yaml"),
     import_path.default.join(projectRoot, "agents", "coding-agent.yml"),
-    import_path.default.join(projectRoot, "src", "dexto", "agents", "coding-agent.yml")
+    import_path.default.join(projectRoot, "agents", "coding-agent.yaml"),
+    import_path.default.join(projectRoot, "src", "dexto", "agents", "coding-agent.yml"),
+    import_path.default.join(projectRoot, "src", "dexto", "agents", "coding-agent.yaml")
   ];
   for (const p of candidatePaths) {
     try {
@@ -165,7 +186,7 @@ async function resolveDefaultAgentForDextoProject(autoInstall = true) {
     } catch {
     }
   }
-  import_core.logger.debug(`No project-local coding-agent.yml found in ${projectRoot}`);
+  import_core.logger.debug(`No project-local coding-agent found in ${projectRoot}`);
   if (!(0, import_loader.globalPreferencesExist)()) {
     throw import_config.ConfigError.noProjectDefault(projectRoot);
   }

package/dist/resolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../src/resolver.ts"],"names":[],"mappings":"AAoCA;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAClC,UAAU,CAAC,EAAE,MAAM,EACnB,WAAW,GAAE,OAAc,GAC5B,OAAO,CAAC,MAAM,CAAC,CAuBjB;AAiMD;;;;GAIG;AACH,wBAAsB,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA+BnF"}
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../src/resolver.ts"],"names":[],"mappings":"AAwCA;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAClC,UAAU,CAAC,EAAE,MAAM,EACnB,WAAW,GAAE,OAAc,GAC5B,OAAO,CAAC,MAAM,CAAC,CAuBjB;AAuND;;;;GAIG;AACH,wBAAsB,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA+BnF"}

package/dist/resolver.js

@@ -12,6 +12,10 @@ import { ConfigError } from "./config/index.js";
 import { RegistryError } from "./registry/errors.js";
 import { AgentManager } from "./AgentManager.js";
 import { installBundledAgent } from "./installation.js";
+import {
+  isProjectRegistryError,
+  resolveDefaultProjectRegistryAgentPath
+} from "./project-registry.js";
 async function resolveAgentPath(nameOrPath, autoInstall = true) {
   if (nameOrPath && isPath(nameOrPath)) {
     const resolved = path.resolve(nameOrPath);
@@ -123,10 +127,30 @@ async function resolveDefaultAgentForDextoProject(autoInstall = true) {
   if (!projectRoot) {
     throw ConfigError.unknownContext("dexto-project: project root not found");
   }
+  try {
+    const projectRegistryAgentPath = await resolveDefaultProjectRegistryAgentPath(projectRoot);
+    if (projectRegistryAgentPath) {
+      return projectRegistryAgentPath;
+    }
+  } catch (error) {
+    if (isProjectRegistryError(error) && error.code === "PROJECT_REGISTRY_INVALID_PRIMARY") {
+      throw ConfigError.invalidProjectPrimary(
+        error.registryPath,
+        error.agentId ?? "",
+        error.message
+      );
+    }
+    throw error;
+  }
   const candidatePaths = [
+    path.join(projectRoot, "agents", "coding-agent", "coding-agent.yml"),
+    path.join(projectRoot, "agents", "coding-agent", "coding-agent.yaml"),
     path.join(projectRoot, "coding-agent.yml"),
+    path.join(projectRoot, "coding-agent.yaml"),
     path.join(projectRoot, "agents", "coding-agent.yml"),
-    path.join(projectRoot, "src", "dexto", "agents", "coding-agent.yml")
+    path.join(projectRoot, "agents", "coding-agent.yaml"),
+    path.join(projectRoot, "src", "dexto", "agents", "coding-agent.yml"),
+    path.join(projectRoot, "src", "dexto", "agents", "coding-agent.yaml")
   ];
   for (const p of candidatePaths) {
     try {
@@ -135,7 +159,7 @@ async function resolveDefaultAgentForDextoProject(autoInstall = true) {
     } catch {
     }
   }
-  logger.debug(`No project-local coding-agent.yml found in ${projectRoot}`);
+  logger.debug(`No project-local coding-agent found in ${projectRoot}`);
   if (!globalPreferencesExist()) {
     throw ConfigError.noProjectDefault(projectRoot);
   }

package/dist/tool-factories/agent-spawner/factory.cjs

@@ -54,9 +54,13 @@ const agentSpawnerToolsFactory = {
         );
       }
     };
+    const updateWorkspaceRootHint = (runtime, context) => {
+      runtime.setWorkspaceRootHint(context.workspace?.path);
+    };
     const ensureToolsInitialized = (context) => {
       const { agent, logger, toolServices } = requireAgentContext(context);
       if (state && state.agent === agent && !state.abortController.signal.aborted) {
+        updateWorkspaceRootHint(state.runtime, context);
         attachTaskForker({ toolServices, taskForker: state.runtime, logger });
         return state.tools;
       }
@@ -71,6 +75,7 @@ const agentSpawnerToolsFactory = {
       const taskRegistry = new import_orchestration.TaskRegistry(signalBus);
       const conditionEngine = new import_orchestration.ConditionEngine(taskRegistry, signalBus, logger);
       const spawnerRuntime = new import_runtime.AgentSpawnerRuntime(agent, config, logger);
+      updateWorkspaceRootHint(spawnerRuntime, context);
       attachTaskForker({ toolServices, taskForker: spawnerRuntime, logger });
       const taskSessions = /* @__PURE__ */ new Map();
       const emitTasksUpdate = (sessionId) => {
@@ -229,6 +234,13 @@ const agentSpawnerToolsFactory = {
       {
         id: "spawn_agent",
         description: "Spawn a sub-agent to handle a task and return its result.",
+        getDescription: async (context) => {
+          const tool = ensureToolsInitialized(context).spawnAgent;
+          if (tool.getDescription) {
+            return await tool.getDescription(context);
+          }
+          return tool.description;
+        },
         inputSchema: import_schemas.SpawnAgentInputSchema,
         execute: (input, context) => ensureToolsInitialized(context).spawnAgent.execute(input, context),
         presentation: {

package/dist/tool-factories/agent-spawner/factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/tool-factories/agent-spawner/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAiBvD,OAAO,EAGH,KAAK,kBAAkB,EAC1B,MAAM,cAAc,CAAC;AAqCtB,eAAO,MAAM,wBAAwB,EAAE,WAAW,CAAC,kBAAkB,CA8VpE,CAAC"}
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../../src/tool-factories/agent-spawner/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAiBvD,OAAO,EAGH,KAAK,kBAAkB,EAC1B,MAAM,cAAc,CAAC;AAqCtB,eAAO,MAAM,wBAAwB,EAAE,WAAW,CAAC,kBAAkB,CA8WpE,CAAC"}

package/dist/tool-factories/agent-spawner/factory.js

@@ -44,9 +44,13 @@ const agentSpawnerToolsFactory = {
         );
       }
     };
+    const updateWorkspaceRootHint = (runtime, context) => {
+      runtime.setWorkspaceRootHint(context.workspace?.path);
+    };
     const ensureToolsInitialized = (context) => {
       const { agent, logger, toolServices } = requireAgentContext(context);
       if (state && state.agent === agent && !state.abortController.signal.aborted) {
+        updateWorkspaceRootHint(state.runtime, context);
         attachTaskForker({ toolServices, taskForker: state.runtime, logger });
         return state.tools;
       }
@@ -61,6 +65,7 @@ const agentSpawnerToolsFactory = {
       const taskRegistry = new TaskRegistry(signalBus);
       const conditionEngine = new ConditionEngine(taskRegistry, signalBus, logger);
       const spawnerRuntime = new AgentSpawnerRuntime(agent, config, logger);
+      updateWorkspaceRootHint(spawnerRuntime, context);
       attachTaskForker({ toolServices, taskForker: spawnerRuntime, logger });
       const taskSessions = /* @__PURE__ */ new Map();
       const emitTasksUpdate = (sessionId) => {
@@ -219,6 +224,13 @@ const agentSpawnerToolsFactory = {
       {
         id: "spawn_agent",
         description: "Spawn a sub-agent to handle a task and return its result.",
+        getDescription: async (context) => {
+          const tool = ensureToolsInitialized(context).spawnAgent;
+          if (tool.getDescription) {
+            return await tool.getDescription(context);
+          }
+          return tool.description;
+        },
         inputSchema: SpawnAgentInputSchema,
         execute: (input, context) => ensureToolsInitialized(context).spawnAgent.execute(input, context),
         presentation: {