@dexto/agent-management 1.5.8 → 1.6.1

package/dist/{tool-provider/runtime-service.js → tool-factories/agent-spawner/runtime.js}

@@ -1,13 +1,14 @@
+import { randomUUID } from "crypto";
 import { DextoRuntimeError, ErrorType } from "@dexto/core";
-import { AgentRuntime } from "../runtime/AgentRuntime.js";
-import { createDelegatingApprovalHandler } from "../runtime/approval-delegation.js";
-import { loadAgentConfig } from "../config/loader.js";
-import { getAgentRegistry } from "../registry/registry.js";
-import { deriveDisplayName } from "../registry/types.js";
-import { resolveBundledScript } from "../utils/path.js";
+import { AgentRuntime } from "../../runtime/AgentRuntime.js";
+import { createDelegatingApprovalHandler } from "../../runtime/approval-delegation.js";
+import { loadAgentConfig } from "../../config/loader.js";
+import { getAgentRegistry } from "../../registry/registry.js";
+import { deriveDisplayName } from "../../registry/types.js";
+import { getDextoPath, resolveBundledScript } from "../../utils/path.js";
 import * as path from "path";
 import { resolveSubAgentLLM } from "./llm-resolution.js";
-class RuntimeService {
+class AgentSpawnerRuntime {
   runtime;
   parentId;
   parentAgent;
@@ -57,7 +58,7 @@ class RuntimeService {
       logger
     });
     this.logger.debug(
-      `RuntimeService initialized for parent '${this.parentId}' (maxAgents: ${config.maxConcurrentAgents})`
+      `AgentSpawnerRuntime initialized for parent '${this.parentId}' (maxAgents: ${config.maxConcurrentAgents})`
     );
   }
   /**
@@ -131,23 +132,7 @@ class RuntimeService {
    * @param options.sessionId - Optional session ID for progress events
    */
   async fork(options) {
-    const spawnOptions = {
-      task: options.task,
-      instructions: options.instructions
-    };
-    if (options.agentId) {
-      spawnOptions.agentId = options.agentId;
-    }
-    if (options.autoApprove !== void 0) {
-      spawnOptions.autoApprove = options.autoApprove;
-    }
-    if (options.toolCallId) {
-      spawnOptions.toolCallId = options.toolCallId;
-    }
-    if (options.sessionId) {
-      spawnOptions.sessionId = options.sessionId;
-    }
-    return this.spawnAndExecute(spawnOptions);
+    return this.spawnAndExecute(options);
   }
   /**
    * Set up progress event emission for a sub-agent.
@@ -169,10 +154,12 @@ class RuntimeService {
     let toolCount = 0;
     const tokenUsage = { input: 0, output: 0, total: 0 };
     let currentTool = "";
-    const subAgentBus = subAgentHandle.agent.agentEventBus;
-    const parentBus = this.parentAgent.agentEventBus;
     const emitProgress = (tool, args) => {
-      parentBus.emit("service:event", {
+      const subAgentLogFilePath = this.getSubAgentLogFilePath({
+        runtimeAgentId: subAgentHandle.agentId,
+        sessionId
+      });
+      this.parentAgent.emit("service:event", {
         service: "agent-spawner",
         event: "progress",
         toolCallId,
@@ -180,6 +167,8 @@ class RuntimeService {
         data: {
           task: input.task,
           agentId: input.agentId ?? "default",
+          runtimeAgentId: subAgentHandle.agentId,
+          ...subAgentLogFilePath ? { subAgentLogFilePath } : {},
           toolsCalled: toolCount,
           currentTool: tool,
           currentArgs: args,
@@ -190,15 +179,10 @@ class RuntimeService {
     const toolCallHandler = (event) => {
       toolCount++;
       let displayToolName = event.toolName;
-      if (displayToolName.startsWith("internal--")) {
-        displayToolName = displayToolName.replace("internal--", "");
-      } else if (displayToolName.startsWith("custom--")) {
-        displayToolName = displayToolName.replace("custom--", "");
-      } else if (displayToolName.startsWith("mcp--")) {
-        const parts = displayToolName.split("--");
-        if (parts.length >= 3) {
-          displayToolName = parts.slice(2).join("--");
-        }
+      if (displayToolName.startsWith("mcp--")) {
+        const trimmed = displayToolName.substring("mcp--".length);
+        const parts = trimmed.split("--");
+        displayToolName = parts.length >= 2 ? parts.slice(1).join("--") : trimmed;
       }
       currentTool = displayToolName;
       this.logger.debug(
@@ -217,13 +201,51 @@ class RuntimeService {
         emitProgress(currentTool || "processing");
       }
     };
-    subAgentBus.on("llm:tool-call", toolCallHandler);
-    subAgentBus.on("llm:response", responseHandler);
+    subAgentHandle.agent.on("llm:tool-call", toolCallHandler);
+    subAgentHandle.agent.on("llm:response", responseHandler);
     return () => {
-      subAgentBus.off("llm:tool-call", toolCallHandler);
-      subAgentBus.off("llm:response", responseHandler);
+      subAgentHandle.agent.off("llm:tool-call", toolCallHandler);
+      subAgentHandle.agent.off("llm:response", responseHandler);
     };
   }
+  /**
+   * Ensure spawned agent inherits the parent's workspace context.
+   */
+  async applyParentWorkspace(agent) {
+    let parentWorkspace;
+    try {
+      parentWorkspace = await this.parentAgent.getWorkspace();
+    } catch (error) {
+      this.logger.warn(
+        `Failed to read parent workspace for sub-agent: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return;
+    }
+    if (!parentWorkspace?.path) {
+      return;
+    }
+    try {
+      await agent.setWorkspace({
+        path: parentWorkspace.path,
+        ...parentWorkspace.name ? { name: parentWorkspace.name } : {}
+      });
+    } catch (error) {
+      this.logger.warn(
+        `Failed to apply parent workspace to sub-agent: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  getSubAgentLogFilePath(options) {
+    const { runtimeAgentId, sessionId } = options;
+    if (!sessionId) {
+      return null;
+    }
+    const safeSessionId = sessionId.replace(/[^a-zA-Z0-9._-]/g, "_");
+    return getDextoPath(
+      "logs",
+      path.join(this.parentId, `${safeSessionId}.subagent.${runtimeAgentId}.log`)
+    );
+  }
   /**
    * Check if an error is LLM-related (API errors, credit issues, model not found, etc.)
    */
@@ -245,7 +267,10 @@ class RuntimeService {
     let llmMode = "subagent";
     let cleanupProgressTracking;
     try {
-      const buildOptions = {};
+      const buildOptions = {
+        // Pre-generate the runtime agentId so we can deterministically route logs.
+        runtimeAgentId: `agent-${randomUUID().slice(0, 8)}`
+      };
       if (input.agentId !== void 0) {
         buildOptions.agentId = input.agentId;
       }
@@ -256,6 +281,7 @@ class RuntimeService {
       let handle;
       try {
         handle = await this.runtime.spawnAgent({
+          agentId: buildOptions.runtimeAgentId,
           agentConfig: subAgentConfig,
           ephemeral: true,
           group: this.parentId,
@@ -270,6 +296,7 @@ class RuntimeService {
               const delegatingHandler = createDelegatingApprovalHandler(
                 this.parentAgent.services.approvalManager,
                 agent.config.agentId ?? "unknown",
+                sessionId,
                 this.logger
               );
               agent.setApprovalHandler(delegatingHandler);
@@ -277,6 +304,7 @@ class RuntimeService {
           }
         });
         spawnedAgentId = handle.agentId;
+        await this.applyParentWorkspace(handle.agent);
       } catch (spawnError) {
         const isLlmError = this.isLLMError(spawnError);
         if (isLlmError && input.agentId && llmMode === "subagent") {
@@ -288,6 +316,7 @@ class RuntimeService {
           buildOptions.inheritLlm = true;
           subAgentConfig = await this.buildSubAgentConfig(buildOptions, sessionId);
           handle = await this.runtime.spawnAgent({
+            agentId: buildOptions.runtimeAgentId,
             agentConfig: subAgentConfig,
             ephemeral: true,
             group: this.parentId,
@@ -304,6 +333,7 @@ class RuntimeService {
                 const delegatingHandler = createDelegatingApprovalHandler(
                   this.parentAgent.services.approvalManager,
                   agent.config.agentId ?? "unknown",
+                  sessionId,
                   this.logger
                 );
                 agent.setApprovalHandler(delegatingHandler);
@@ -311,6 +341,7 @@ class RuntimeService {
             }
           });
           spawnedAgentId = handle.agentId;
+          await this.applyParentWorkspace(handle.agent);
         } else {
           throw spawnError;
         }
@@ -318,6 +349,23 @@ class RuntimeService {
       this.logger.info(
         `Spawned sub-agent '${spawnedAgentId}' for task: ${input.task}${autoApprove ? " (auto-approve)" : ""}${llmMode === "parent" ? " (using parent LLM)" : ""}`
       );
+      const subAgentLogFilePath = this.getSubAgentLogFilePath(
+        sessionId ? { runtimeAgentId: buildOptions.runtimeAgentId, sessionId } : { runtimeAgentId: buildOptions.runtimeAgentId }
+      );
+      if (subAgentLogFilePath) {
+        this.logger.info(`Sub-agent logs: ${subAgentLogFilePath}`);
+      }
+      if (sessionId) {
+        const parentSession = await this.parentAgent.getSession(sessionId);
+        if (parentSession) {
+          parentSession.logger.info("Sub-agent spawned", {
+            runtimeAgentId: spawnedAgentId,
+            registryAgentId: input.agentId ?? "default",
+            task: input.task,
+            ...subAgentLogFilePath ? { subAgentLogFilePath } : {}
+          });
+        }
+      }
       cleanupProgressTracking = this.setupProgressTracking(
         handle,
         input,
@@ -351,6 +399,7 @@ class RuntimeService {
           buildOptions.inheritLlm = true;
           subAgentConfig = await this.buildSubAgentConfig(buildOptions, sessionId);
           handle = await this.runtime.spawnAgent({
+            agentId: buildOptions.runtimeAgentId,
             agentConfig: subAgentConfig,
             ephemeral: true,
             group: this.parentId,
@@ -367,6 +416,7 @@ class RuntimeService {
                 const delegatingHandler = createDelegatingApprovalHandler(
                   this.parentAgent.services.approvalManager,
                   agent.config.agentId ?? "unknown",
+                  sessionId,
                   this.logger
                 );
                 agent.setApprovalHandler(delegatingHandler);
@@ -374,6 +424,7 @@ class RuntimeService {
             }
           });
           spawnedAgentId = handle.agentId;
+          await this.applyParentWorkspace(handle.agent);
           this.logger.info(
             `Re-spawned sub-agent '${spawnedAgentId}' for task: ${input.task} (using parent LLM)`
           );
@@ -433,13 +484,49 @@ class RuntimeService {
    * @param sessionId - Optional session ID to get session-specific LLM config
    */
   async buildSubAgentConfig(options, sessionId) {
-    const { agentId, inheritLlm, autoApprove } = options;
-    const parentConfig = this.parentAgent.config;
+    const { agentId, inheritLlm, autoApprove, runtimeAgentId } = options;
+    const parentSettings = this.parentAgent.config;
     const currentParentLLM = this.parentAgent.getCurrentLLMConfig(sessionId);
     this.logger.debug(
-      `[RuntimeService] Building sub-agent config with LLM: ${currentParentLLM.provider}/${currentParentLLM.model}` + (sessionId ? ` (sessionId: ${sessionId})` : " (no sessionId)")
+      `[AgentSpawnerRuntime] Building sub-agent config with LLM: ${currentParentLLM.provider}/${currentParentLLM.model}` + (sessionId ? ` (sessionId: ${sessionId})` : " (no sessionId)")
     );
-    const toolConfirmationMode = autoApprove ? "auto-approve" : "manual";
+    const permissionsMode = autoApprove ? "auto-approve" : "manual";
+    const parentToolPolicies = parentSettings.permissions?.toolPolicies;
+    const mergeToolPolicies = (subAgentPolicies) => {
+      const alwaysAllow = [
+        ...parentToolPolicies?.alwaysAllow ?? [],
+        ...subAgentPolicies?.alwaysAllow ?? []
+      ];
+      const alwaysDeny = [
+        ...parentToolPolicies?.alwaysDeny ?? [],
+        ...subAgentPolicies?.alwaysDeny ?? []
+      ];
+      return {
+        alwaysAllow: Array.from(new Set(alwaysAllow)),
+        alwaysDeny: Array.from(new Set(alwaysDeny))
+      };
+    };
+    const inheritedLoggerConfig = await (async () => {
+      if (!sessionId) {
+        return void 0;
+      }
+      const session = await this.parentAgent.getSession(sessionId);
+      if (!session) {
+        return void 0;
+      }
+      const parentSessionLogPath = session.logger.getLogFilePath();
+      if (!parentSessionLogPath) {
+        return void 0;
+      }
+      const subAgentLogFilePath = this.getSubAgentLogFilePath({ runtimeAgentId, sessionId });
+      if (!subAgentLogFilePath) {
+        return void 0;
+      }
+      return {
+        level: session.logger.getLevel(),
+        transports: [{ type: "file", path: subAgentLogFilePath }]
+      };
+    })();
     if (agentId) {
       let configPath = null;
       try {
@@ -477,22 +564,15 @@ class RuntimeService {
           this.logger.debug(`Sub-agent LLM resolution: ${resolution.reason}`);
           llmConfig = resolution.llm;
         }
-        const filteredCustomTools = loadedConfig.customTools ? loadedConfig.customTools.filter(
-          (tool) => typeof tool === "object" && tool !== null && "type" in tool && tool.type !== "agent-spawner"
-        ) : void 0;
         return {
           ...loadedConfig,
           llm: llmConfig,
-          toolConfirmation: {
-            ...loadedConfig.toolConfirmation,
-            mode: toolConfirmationMode
+          permissions: {
+            ...loadedConfig.permissions,
+            mode: permissionsMode,
+            toolPolicies: mergeToolPolicies(loadedConfig.permissions?.toolPolicies)
           },
-          customTools: filteredCustomTools,
-          // Suppress sub-agent console logs entirely using silent transport
-          logger: {
-            level: "error",
-            transports: [{ type: "silent" }]
-          }
+          ...inheritedLoggerConfig !== void 0 && { logger: inheritedLoggerConfig }
         };
       }
       this.logger.warn(
@@ -503,27 +583,13 @@ class RuntimeService {
       llm: { ...currentParentLLM },
       // Default system prompt for sub-agents
       systemPrompt: "You are a helpful sub-agent. Complete the task given to you efficiently and concisely.",
-      toolConfirmation: {
-        mode: toolConfirmationMode
+      permissions: {
+        mode: permissionsMode,
+        toolPolicies: mergeToolPolicies(void 0)
       },
       // Inherit MCP servers from parent so subagent has tool access
-      mcpServers: parentConfig.mcpServers ? { ...parentConfig.mcpServers } : {},
-      // Inherit internal tools from parent, excluding tools that don't work in subagent context
-      // - ask_user: Subagents can't interact with the user directly
-      // - invoke_skill: Avoid nested skill invocations for simplicity
-      internalTools: parentConfig.internalTools ? parentConfig.internalTools.filter(
-        (tool) => tool !== "ask_user" && tool !== "invoke_skill"
-      ) : [],
-      // Inherit custom tools from parent, excluding agent-spawner to prevent nested spawning (depth=1 limit)
-      // - agent-spawner: Sub-agents should not spawn their own sub-agents
-      customTools: parentConfig.customTools ? parentConfig.customTools.filter(
-        (tool) => typeof tool === "object" && tool !== null && "type" in tool && tool.type !== "agent-spawner"
-      ) : [],
-      // Suppress sub-agent console logs entirely using silent transport
-      logger: {
-        level: "error",
-        transports: [{ type: "silent" }]
-      }
+      mcpServers: parentSettings.mcpServers ? { ...parentSettings.mcpServers } : {},
+      ...inheritedLoggerConfig !== void 0 && { logger: inheritedLoggerConfig }
     };
     return config;
   }
@@ -559,10 +625,10 @@ class RuntimeService {
    * Clean up all sub-agents (called when parent stops)
    */
   async cleanup() {
-    this.logger.debug(`Cleaning up RuntimeService for parent '${this.parentId}'`);
+    this.logger.debug(`Cleaning up AgentSpawnerRuntime for parent '${this.parentId}'`);
     await this.runtime.stopAll({ group: this.parentId });
   }
 }
 export {
-  RuntimeService
+  AgentSpawnerRuntime
 };

package/dist/{tool-provider → tool-factories/agent-spawner}/schemas.cjs

@@ -24,12 +24,12 @@ __export(schemas_exports, {
 module.exports = __toCommonJS(schemas_exports);
 var import_zod = require("zod");
 const AgentSpawnerConfigSchema = import_zod.z.object({
-  /** Type discriminator for the provider */
+  /** Type discriminator for the factory */
   type: import_zod.z.literal("agent-spawner"),
   /** Maximum concurrent sub-agents this parent can spawn (default: 5) */
   maxConcurrentAgents: import_zod.z.number().int().positive().default(5).describe("Maximum concurrent sub-agents"),
-  /** Default timeout for task execution in milliseconds (default: 300000 = 5 min) */
-  defaultTimeout: import_zod.z.number().int().positive().default(3e5).describe("Default task timeout in milliseconds"),
+  /** Default timeout for task execution in milliseconds (default: 3600000 = 1 hour) */
+  defaultTimeout: import_zod.z.number().int().nonnegative().default(36e5).describe("Default task timeout in milliseconds (0 = no timeout)"),
   /** Whether spawning is enabled (default: true) */
   allowSpawning: import_zod.z.boolean().default(true).describe("Whether agent spawning is enabled"),
   /**
@@ -57,7 +57,7 @@ const AgentSpawnerConfigSchema = import_zod.z.object({
    * ```
    */
   autoApproveAgents: import_zod.z.array(import_zod.z.string().min(1)).optional().describe("Agent IDs that should have tools auto-approved (read-only agents)")
-}).strict().describe("Configuration for the agent spawner tool provider");
+}).strict().describe("Configuration for the agent spawner tools factory");
 const SpawnAgentInputSchema = import_zod.z.object({
   /** Short task description (shown in UI/logs) */
   task: import_zod.z.string().min(1).describe("Short task description for UI/logs"),

package/dist/{tool-provider → tool-factories/agent-spawner}/schemas.d.ts

@@ -1,18 +1,18 @@
 /**
- * Agent Spawner Tool Provider Schemas
+ * Agent Spawner Tools Factory Schemas
  *
- * Zod schemas for the agent spawner tool provider configuration and inputs.
+ * Zod schemas for the agent spawner tools factory configuration and inputs.
  */
 import { z } from 'zod';
 /**
- * Configuration schema for the agent spawner tool provider
+ * Configuration schema for the agent spawner tools factory.
  */
 export declare const AgentSpawnerConfigSchema: z.ZodObject<{
-    /** Type discriminator for the provider */
+    /** Type discriminator for the factory */
     type: z.ZodLiteral<"agent-spawner">;
     /** Maximum concurrent sub-agents this parent can spawn (default: 5) */
     maxConcurrentAgents: z.ZodDefault<z.ZodNumber>;
-    /** Default timeout for task execution in milliseconds (default: 300000 = 5 min) */
+    /** Default timeout for task execution in milliseconds (default: 3600000 = 1 hour) */
     defaultTimeout: z.ZodDefault<z.ZodNumber>;
     /** Whether spawning is enabled (default: true) */
     allowSpawning: z.ZodDefault<z.ZodBoolean>;

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/tool-factories/agent-spawner/schemas.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB;;GAEG;AACH,eAAO,MAAM,wBAAwB;IAE7B,yCAAyC;;IAGzC,uEAAuE;;IAQvE,qFAAqF;;IAQrF,kDAAkD;;IAGlD;;;;;;;;;;OAUG;;IAMH;;;;;;;;;;;OAWG;;;;;;;;;;;;;;;;EAOuD,CAAC;AAEnE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAM3E;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB;IAE1B,gDAAgD;;IAGhD,8CAA8C;;IAM9C,qFAAqF;;;;;;;;;;EAGhF,CAAC;AAEd,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/{tool-provider → tool-factories/agent-spawner}/schemas.js

@@ -1,11 +1,11 @@
 import { z } from "zod";
 const AgentSpawnerConfigSchema = z.object({
-  /** Type discriminator for the provider */
+  /** Type discriminator for the factory */
   type: z.literal("agent-spawner"),
   /** Maximum concurrent sub-agents this parent can spawn (default: 5) */
   maxConcurrentAgents: z.number().int().positive().default(5).describe("Maximum concurrent sub-agents"),
-  /** Default timeout for task execution in milliseconds (default: 300000 = 5 min) */
-  defaultTimeout: z.number().int().positive().default(3e5).describe("Default task timeout in milliseconds"),
+  /** Default timeout for task execution in milliseconds (default: 3600000 = 1 hour) */
+  defaultTimeout: z.number().int().nonnegative().default(36e5).describe("Default task timeout in milliseconds (0 = no timeout)"),
   /** Whether spawning is enabled (default: true) */
   allowSpawning: z.boolean().default(true).describe("Whether agent spawning is enabled"),
   /**
@@ -33,7 +33,7 @@ const AgentSpawnerConfigSchema = z.object({
    * ```
    */
   autoApproveAgents: z.array(z.string().min(1)).optional().describe("Agent IDs that should have tools auto-approved (read-only agents)")
-}).strict().describe("Configuration for the agent spawner tool provider");
+}).strict().describe("Configuration for the agent spawner tools factory");
 const SpawnAgentInputSchema = z.object({
   /** Short task description (shown in UI/logs) */
   task: z.string().min(1).describe("Short task description for UI/logs"),

package/dist/{tool-provider → tool-factories/agent-spawner}/spawn-agent-tool.cjs

@@ -21,6 +21,7 @@ __export(spawn_agent_tool_exports, {
   createSpawnAgentTool: () => createSpawnAgentTool
 });
 module.exports = __toCommonJS(spawn_agent_tool_exports);
+var import_core = require("@dexto/core");
 var import_schemas = require("./schemas.js");
 function buildDescription(service) {
   const availableAgents = service.getAvailableAgents();
@@ -57,21 +58,30 @@ ${agentsList}
 function createSpawnAgentTool(service) {
   return {
     id: "spawn_agent",
+    aliases: ["task"],
     description: buildDescription(service),
+    presentation: {
+      describeHeader: (input) => {
+        const agentLabel = input.agentId ? input.agentId.replace(/-agent$/, "") : null;
+        const title = agentLabel ? agentLabel.charAt(0).toUpperCase() + agentLabel.slice(1) : "Agent";
+        const task = typeof input.task === "string" ? input.task : "";
+        const argsText = task ? (0, import_core.truncateForHeader)(task, 120) : void 0;
+        return (0, import_core.createLocalToolCallHeader)({ title, ...argsText ? { argsText } : {} });
+      }
+    },
     inputSchema: import_schemas.SpawnAgentInputSchema,
     execute: async (input, context) => {
-      const validatedInput = input;
       const options = {
-        task: validatedInput.task,
-        instructions: validatedInput.instructions
+        task: input.task,
+        instructions: input.instructions
       };
-      if (validatedInput.agentId !== void 0) {
-        options.agentId = validatedInput.agentId;
+      if (input.agentId !== void 0) {
+        options.agentId = input.agentId;
       }
-      if (context?.toolCallId !== void 0) {
+      if (context.toolCallId !== void 0) {
         options.toolCallId = context.toolCallId;
       }
-      if (context?.sessionId !== void 0) {
+      if (context.sessionId !== void 0) {
         options.sessionId = context.sessionId;
       }
       const result = await service.spawnAndExecute(options);

package/dist/tool-factories/agent-spawner/spawn-agent-tool.d.ts

@@ -0,0 +1,11 @@
+/**
+ * spawn_agent Tool
+ *
+ * Spawns a sub-agent to handle a specific task.
+ * The sub-agent will execute the task and return the result.
+ */
+import type { Tool } from '@dexto/core';
+import { SpawnAgentInputSchema } from './schemas.js';
+import type { AgentSpawnerRuntime } from './runtime.js';
+export declare function createSpawnAgentTool(service: AgentSpawnerRuntime): Tool<typeof SpawnAgentInputSchema>;
+//# sourceMappingURL=spawn-agent-tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"spawn-agent-tool.d.ts","sourceRoot":"","sources":["../../../src/tool-factories/agent-spawner/spawn-agent-tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AA4CxD,wBAAgB,oBAAoB,CAChC,OAAO,EAAE,mBAAmB,GAC7B,IAAI,CAAC,OAAO,qBAAqB,CAAC,CAuDpC"}

package/dist/{tool-provider → tool-factories/agent-spawner}/spawn-agent-tool.js

@@ -1,3 +1,4 @@
+import { createLocalToolCallHeader, truncateForHeader } from "@dexto/core";
 import { SpawnAgentInputSchema } from "./schemas.js";
 function buildDescription(service) {
   const availableAgents = service.getAvailableAgents();
@@ -34,21 +35,30 @@ ${agentsList}
 function createSpawnAgentTool(service) {
   return {
     id: "spawn_agent",
+    aliases: ["task"],
     description: buildDescription(service),
+    presentation: {
+      describeHeader: (input) => {
+        const agentLabel = input.agentId ? input.agentId.replace(/-agent$/, "") : null;
+        const title = agentLabel ? agentLabel.charAt(0).toUpperCase() + agentLabel.slice(1) : "Agent";
+        const task = typeof input.task === "string" ? input.task : "";
+        const argsText = task ? truncateForHeader(task, 120) : void 0;
+        return createLocalToolCallHeader({ title, ...argsText ? { argsText } : {} });
+      }
+    },
     inputSchema: SpawnAgentInputSchema,
     execute: async (input, context) => {
-      const validatedInput = input;
       const options = {
-        task: validatedInput.task,
-        instructions: validatedInput.instructions
+        task: input.task,
+        instructions: input.instructions
       };
-      if (validatedInput.agentId !== void 0) {
-        options.agentId = validatedInput.agentId;
+      if (input.agentId !== void 0) {
+        options.agentId = input.agentId;
       }
-      if (context?.toolCallId !== void 0) {
+      if (context.toolCallId !== void 0) {
         options.toolCallId = context.toolCallId;
       }
-      if (context?.sessionId !== void 0) {
+      if (context.sessionId !== void 0) {
         options.sessionId = context.sessionId;
       }
       const result = await service.spawnAndExecute(options);

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/tool-factories/agent-spawner/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC7B,8CAA8C;IAC9C,OAAO,EAAE,OAAO,CAAC;IAEjB,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,uCAAuC;IACvC,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB"}

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/dist/writer.d.ts

@@ -1,4 +1,5 @@
-import type { LLMProvider, AgentConfig } from '@dexto/core';
+import type { AgentConfig } from '@dexto/agent-config';
+import type { LLMProvider } from '@dexto/core';
 import { type GlobalPreferences } from './preferences/schemas.js';
 export interface LLMOverrides {
     provider?: LLMProvider;