wave-agent-sdk 0.8.2 → 0.8.4

package/src/managers/permissionManager.ts

@@ -20,6 +20,7 @@ import {
   splitBashCommand,
   stripEnvVars,
   stripRedirections,
+  hasWriteRedirections,
   getSmartPrefix,
   DANGEROUS_COMMANDS,
 } from "../utils/bashParser.js";
@@ -29,7 +30,6 @@ import {
   EDIT_TOOL_NAME,
   WRITE_TOOL_NAME,
   READ_TOOL_NAME,
-  LS_TOOL_NAME,
 } from "../constants/tools.js";
 import { Container } from "../utils/container.js";
 import { ConfigurationService } from "../services/configurationService.js";
@@ -464,6 +464,9 @@ export class PermissionManager {
       const parts = splitBashCommand(command);
 
       const isDangerous = parts.some((part) => {
+        if (hasWriteRedirections(part)) {
+          return true;
+        }
         const processedPart = stripRedirections(stripEnvVars(part));
         const commandMatch = processedPart.match(/^(\w+)(\s+.*)?$/);
         if (commandMatch) {
@@ -523,7 +526,17 @@ export class PermissionManager {
     // Handle Bash command rules
     if (toolName === BASH_TOOL_NAME) {
       const command = String(context.toolInput?.command || "");
-      const processedPart = stripRedirections(stripEnvVars(command));
+      const hasWriteInPattern = hasWriteRedirections(pattern);
+      const hasWriteInCommand = hasWriteRedirections(command);
+
+      // If the command has write redirections, it must match a pattern that also has write redirections
+      if (hasWriteInCommand && !hasWriteInPattern) {
+        return false;
+      }
+
+      const processedPart = hasWriteInPattern
+        ? stripEnvVars(command)
+        : stripRedirections(stripEnvVars(command));
       // For Bash commands, we want '*' to match everything including slashes and spaces
       // minimatch's default behavior for '*' is to not match across directory separators
       // We use a regex to replace '*' with '.*' (match anything)
@@ -536,12 +549,7 @@ export class PermissionManager {
     }
 
     // Handle path-based rules (e.g., "Read(**/*.env)")
-    const pathTools = [
-      READ_TOOL_NAME,
-      WRITE_TOOL_NAME,
-      EDIT_TOOL_NAME,
-      LS_TOOL_NAME,
-    ];
+    const pathTools = [READ_TOOL_NAME, WRITE_TOOL_NAME, EDIT_TOOL_NAME];
     if (pathTools.includes(toolName)) {
       const targetPath = (context.toolInput?.file_path ||
         context.toolInput?.path) as string | undefined;
@@ -561,6 +569,7 @@ export class PermissionManager {
     const isAllowedByRuleList = (
       ctx: ToolPermissionContext,
       rules: string[],
+      isDefaultRules: boolean = false,
     ) => {
       if (ctx.toolName === BASH_TOOL_NAME && ctx.toolInput?.command) {
         const command = String(ctx.toolInput.command);
@@ -570,53 +579,60 @@ export class PermissionManager {
         const workdir = ctx.toolInput?.workdir as string | undefined;
 
         return parts.every((part) => {
+          const hasWrite = hasWriteRedirections(part);
           const processedPart = stripRedirections(stripEnvVars(part));
 
           // Check for safe commands
-          const commandMatch = processedPart.match(/^(\w+)(\s+.*)?$/);
-          if (commandMatch) {
-            const cmd = commandMatch[1];
-            const args = commandMatch[2]?.trim() || "";
-
-            if (SAFE_COMMANDS.includes(cmd)) {
-              if (cmd === "pwd" || cmd === "true" || cmd === "false") {
-                return true;
-              }
-
-              if (workdir) {
-                // For cd and ls, check paths
-                const pathArgs =
-                  (args.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || []).filter(
-                    (arg) => !arg.startsWith("-"),
-                  ) || [];
-
-                if (pathArgs.length === 0) {
-                  // cd or ls without arguments operates on current dir (workdir)
+          if (!hasWrite) {
+            const commandMatch = processedPart.match(/^(\w+)(\s+.*)?$/);
+            if (commandMatch) {
+              const cmd = commandMatch[1];
+              const args = commandMatch[2]?.trim() || "";
+
+              if (SAFE_COMMANDS.includes(cmd)) {
+                if (cmd === "pwd" || cmd === "true" || cmd === "false") {
                   return true;
                 }
 
-                const allPathsSafe = pathArgs.every((pathArg) => {
-                  // Remove quotes if present
-                  const cleanPath = pathArg.replace(/^['"](.*)['"]$/, "$1");
-                  const { isInside } = this.isInsideSafeZone(
-                    cleanPath,
-                    workdir,
-                  );
-                  return isInside;
-                });
-
-                if (allPathsSafe) {
-                  return true;
+                if (workdir) {
+                  // For cd and ls, check paths
+                  const pathArgs =
+                    (args.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) || []).filter(
+                      (arg) => !arg.startsWith("-"),
+                    ) || [];
+
+                  if (pathArgs.length === 0) {
+                    // cd or ls without arguments operates on current dir (workdir)
+                    return true;
+                  }
+
+                  const allPathsSafe = pathArgs.every((pathArg) => {
+                    // Remove quotes if present
+                    const cleanPath = pathArg.replace(/^['"](.*)['"]$/, "$1");
+                    const { isInside } = this.isInsideSafeZone(
+                      cleanPath,
+                      workdir,
+                    );
+                    return isInside;
+                  });
+
+                  if (allPathsSafe) {
+                    return true;
+                  }
                 }
               }
             }
           }
 
           // Check if this specific part is allowed by any rule
+          if (hasWrite && isDefaultRules) {
+            return false;
+          }
+
           // We create a temporary context with just this part of the command
           const partContext = {
             ...ctx,
-            toolInput: { ...ctx.toolInput, command: processedPart },
+            toolInput: { ...ctx.toolInput, command: part },
           };
           const allowedByRule = rules.some((rule) => {
             return this.matchesRule(partContext, rule);
@@ -643,7 +659,7 @@ export class PermissionManager {
     }
 
     // Check default allowed rules
-    return isAllowedByRuleList(context, DEFAULT_ALLOWED_RULES);
+    return isAllowedByRuleList(context, DEFAULT_ALLOWED_RULES, true);
   }
 
   /**
@@ -659,13 +675,14 @@ export class PermissionManager {
     const rules: string[] = [];
 
     for (const part of parts) {
+      const hasWrite = hasWriteRedirections(part);
       const processedPart = stripRedirections(stripEnvVars(part));
 
       // Check for safe commands
       const commandMatch = processedPart.match(/^(\w+)(\s+.*)?$/);
       let isSafe = false;
 
-      if (commandMatch) {
+      if (commandMatch && !hasWrite) {
         const cmd = commandMatch[1];
         const args = commandMatch[2]?.trim() || "";
 
@@ -724,11 +741,11 @@ export class PermissionManager {
           }
         }
 
-        const smartPrefix = getSmartPrefix(processedPart);
+        const smartPrefix = hasWrite ? null : getSmartPrefix(processedPart);
         if (smartPrefix) {
           rules.push(`Bash(${smartPrefix}*)`);
         } else {
-          rules.push(`Bash(${processedPart})`);
+          rules.push(`Bash(${hasWrite ? stripEnvVars(part) : processedPart})`);
         }
       }
     }

package/src/managers/pluginManager.ts

@@ -73,7 +73,45 @@ export class PluginManager {
       }
 
       const marketplaceService = new MarketplaceService();
-      const installedRegistry = await marketplaceService.getInstalledPlugins();
+      let installedRegistry = await marketplaceService.getInstalledPlugins();
+      const knownMarketplaces = await marketplaceService.listMarketplaces();
+
+      // Identify missing enabled plugins and auto-install them if marketplace is known
+      for (const pluginId of Object.keys(this.enabledPlugins)) {
+        if (this.enabledPlugins[pluginId] !== true) continue;
+
+        const [name, marketplaceName] = pluginId.split("@");
+        if (!name || !marketplaceName) continue;
+
+        const isInstalled = installedRegistry.plugins.some(
+          (p) => p.name === name && p.marketplace === marketplaceName,
+        );
+
+        if (!isInstalled) {
+          const isMarketplaceKnown = knownMarketplaces.some(
+            (m) => m.name === marketplaceName,
+          );
+
+          if (isMarketplaceKnown) {
+            logger?.info(`Auto-installing missing plugin: ${pluginId}`);
+            try {
+              await marketplaceService.installPlugin(pluginId);
+            } catch (installError) {
+              logger?.error(
+                `Failed to auto-install plugin ${pluginId}:`,
+                installError,
+              );
+            }
+          } else {
+            logger?.warn(
+              `Plugin ${pluginId} is enabled but marketplace ${marketplaceName} is unknown. Skipping auto-install.`,
+            );
+          }
+        }
+      }
+
+      // Refresh registry after potential auto-installs
+      installedRegistry = await marketplaceService.getInstalledPlugins();
 
       for (const p of installedRegistry.plugins) {
         const pluginId = `${p.name}@${p.marketplace}`;

package/src/managers/subagentManager.ts

@@ -9,6 +9,7 @@ import type {
 import { AIManager } from "./aiManager.js";
 import { MessageManager } from "./messageManager.js";
 import { ToolManager } from "./toolManager.js";
+import { AGENT_TOOL_NAME } from "../constants/tools.js";
 import {
   addConsolidatedAbortListener,
   createAbortPromise,
@@ -287,12 +288,12 @@ export class SubagentManager {
   }
 
   /**
-   * Execute task using subagent instance
+   * Execute agent using subagent instance
    *
-   * IMPORTANT: This method automatically filters out the Task tool from allowedTools
+   * IMPORTANT: This method automatically filters out the Agent tool from allowedTools
    * to prevent subagents from spawning other subagents (infinite recursion protection)
    */
-  async executeTask(
+  async executeAgent(
     instance: SubagentInstance,
     prompt: string,
     abortSignal?: AbortSignal,
@@ -301,7 +302,7 @@ export class SubagentManager {
     try {
       // Check if already aborted before starting
       if (abortSignal?.aborted) {
-        throw new Error("Task was aborted before execution started");
+        throw new Error("Agent was aborted before execution started");
       }
 
       // Set status to active and update parent
@@ -433,17 +434,17 @@ export class SubagentManager {
       // Add the user's prompt as a message
       instance.messageManager.addUserMessage({ content: prompt });
 
-      // Create enabled tools list - always exclude Task tool to prevent subagent recursion
+      // Create enabled tools list - always exclude Agent tool to prevent subagent recursion
       // Use instance.configuration.tools if provided, otherwise fallback to all tools
       let enabledTools = instance.configuration.tools;
 
-      // Always filter out the Task tool to prevent subagents from creating sub-subagents
+      // Always filter out the Agent tool to prevent subagents from creating sub-subagents
       if (enabledTools) {
-        enabledTools = enabledTools.filter((tool) => tool !== "Task");
+        enabledTools = enabledTools.filter((tool) => tool !== AGENT_TOOL_NAME);
       } else {
-        // If no tools specified, get all tools except Task
+        // If no tools specified, get all tools except Agent
         const allTools = instance.toolManager.list().map((tool) => tool.name);
-        enabledTools = allTools.filter((tool) => tool !== "Task");
+        enabledTools = allTools.filter((tool) => tool !== AGENT_TOOL_NAME);
       }
 
       // Execute the AI request with tool restrictions
@@ -476,7 +477,7 @@ export class SubagentManager {
       if (abortSignal && !instance.backgroundTaskId) {
         await Promise.race([
           executeAI,
-          createAbortPromise(abortSignal, "Task was aborted"),
+          createAbortPromise(abortSignal, "Agent was aborted"),
         ]);
       } else {
         await executeAI;
@@ -510,7 +511,7 @@ export class SubagentManager {
         const task = backgroundTaskManager.getTask(instance.backgroundTaskId);
         if (task) {
           task.status = "completed";
-          task.stdout = response || "Task completed with no text response";
+          task.stdout = response || "Agent completed with no text response";
           task.endTime = Date.now();
           if (task.startTime) {
             task.runtime = task.endTime - task.startTime;
@@ -518,7 +519,7 @@ export class SubagentManager {
         }
       }
 
-      return response || "Task completed with no text response";
+      return response || "Agent completed with no text response";
     } catch (error) {
       const backgroundTaskManager = this.container.has("BackgroundTaskManager")
         ? this.container.get<BackgroundTaskManager>("BackgroundTaskManager")

package/src/managers/toolManager.ts

@@ -9,10 +9,9 @@ import { askUserQuestionTool } from "../tools/askUserQuestion.js";
 // New tools
 import { globTool } from "../tools/globTool.js";
 import { grepTool } from "../tools/grepTool.js";
-import { lsTool } from "../tools/lsTool.js";
 import { readTool } from "../tools/readTool.js";
 import { lspTool } from "../tools/lspTool.js";
-import { taskTool } from "../tools/taskTool.js";
+import { agentTool } from "../tools/agentTool.js";
 import { skillTool } from "../tools/skillTool.js";
 import {
   taskCreateTool,
@@ -78,10 +77,10 @@ class ToolManager {
    *
    * This method can be called multiple times safely. When called without dependencies,
    * it registers basic tools (Bash, Read, Write, TaskCreate, etc.). When called with
-   * dependencies, it also registers tools that require managers (Task, Skill).
+   * dependencies, it also registers tools that require managers (Agent, Skill).
    *
    * @param deps Optional dependencies for advanced tools
-   * @param deps.subagentManager SubagentManager instance for Task tool
+   * @param deps.subagentManager SubagentManager instance for Agent tool
    * @param deps.skillManager SkillManager instance for Skill tool
    *
    * @example
@@ -107,10 +106,9 @@ class ToolManager {
       askUserQuestionTool,
       globTool,
       grepTool,
-      lsTool,
       readTool,
       lspTool,
-      taskTool,
+      agentTool,
       skillTool,
       taskCreateTool,
       taskGetTool,

package/src/prompts/index.ts

@@ -14,6 +14,7 @@ import {
   READ_TOOL_NAME,
   WRITE_TOOL_NAME,
   EXIT_PLAN_MODE_TOOL_NAME,
+  AGENT_TOOL_NAME,
 } from "../constants/tools.js";
 
 export const BASE_SYSTEM_PROMPT = `You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
@@ -61,7 +62,7 @@ You should build your plan incrementally by writing to or editing this file. NOT
 ## Plan Workflow
 
 ### Phase 1: Initial Understanding
-Goal: Gain a comprehensive understanding of the user's request by reading through code and asking them questions. Critical: In this phase you should only use the Task subagent type with subagent_type=${EXPLORE_SUBAGENT_TYPE}.
+Goal: Gain a comprehensive understanding of the user's request by reading through code and asking them questions. Critical: In this phase you should only use the ${AGENT_TOOL_NAME} tool with subagent_type=${EXPLORE_SUBAGENT_TYPE}.
 
 1. Focus on understanding the user's request and the code associated with their request. Actively search for existing functions, utilities, and patterns that can be reused — avoid proposing new code when suitable implementations already exist.
 
@@ -74,7 +75,7 @@ Goal: Gain a comprehensive understanding of the user's request by reading throug
 ### Phase 2: Design
 Goal: Design an implementation approach.
 
-Launch Task agent(s) with subagent_type=${PLAN_SUBAGENT_TYPE} to design the implementation based on the user's intent and your exploration results from Phase 1.
+Launch agent(s) with subagent_type=${PLAN_SUBAGENT_TYPE} to design the implementation based on the user's intent and your exploration results from Phase 1.
 
 You can launch up to 3 agent(s) in parallel.
 

package/src/tools/{taskTool.ts → agentTool.ts}

@@ -1,6 +1,6 @@
 import type { ToolPlugin, ToolResult, ToolContext } from "./types.js";
 import { EXPLORE_SUBAGENT_TYPE } from "../constants/subagents.js";
-import { TASK_TOOL_NAME } from "../constants/tools.js";
+import { AGENT_TOOL_NAME } from "../constants/tools.js";
 import type { SubagentConfiguration } from "../utils/subagentParser.js";
 import {
   countToolBlocks,
@@ -8,16 +8,16 @@ import {
 } from "../utils/messageOperations.js";
 
 /**
- * Task tool plugin for delegating tasks to specialized subagents
+ * Agent tool plugin for launching specialized agents to handle complex tasks
  */
-export const taskTool: ToolPlugin = {
-  name: TASK_TOOL_NAME,
+export const agentTool: ToolPlugin = {
+  name: AGENT_TOOL_NAME,
   config: {
     type: "function" as const,
     function: {
-      name: TASK_TOOL_NAME,
+      name: AGENT_TOOL_NAME,
       description:
-        "Delegate a task to a specialized subagent. Use this when you need specialized expertise or want to break down complex work into focused subtasks.",
+        "Launch a new agent to handle complex, multi-step tasks autonomously.",
       parameters: {
         type: "object",
         properties: {
@@ -47,19 +47,31 @@ export const taskTool: ToolPlugin = {
   prompt: (args?: { availableSubagents?: SubagentConfiguration[] }) => {
     const subagentList = args?.availableSubagents
       ? args.availableSubagents
-          .map((config) => `- ${config.name}: ${config.description}`)
+          .map((config) => {
+            let toolsStr = "";
+            if (config.tools && config.tools.length > 0) {
+              toolsStr = ` (Tools: ${config.tools.join(", ")})`;
+            } else {
+              toolsStr = " (Tools: *)";
+            }
+
+            return `- ${config.name}: ${config.description}${toolsStr}`;
+          })
           .join("\n")
       : "";
 
-    return `
-Delegate a task to a specialized subagent. Use this when you need specialized expertise or want to break down complex work into focused subtasks.
+    return `Launch a new agent to handle complex, multi-step tasks autonomously.
+
+The Agent tool launches specialized agents (subprocesses) that autonomously handle complex tasks. Each agent type has specific capabilities and tools available to it.
+
+Available agent types and the tools they have access to:
+${subagentList || "No agents configured"}
 
-Available subagents:
-${subagentList || "No subagents configured"}
+When using the Agent tool, you must specify a subagent_type parameter to select which agent type to use.
 
-- When doing file search, prefer to use the ${TASK_TOOL_NAME} tool in order to reduce context usage.
-- You should proactively use the ${TASK_TOOL_NAME} tool with specialized agents when the task at hand matches the agent's description.
-- VERY IMPORTANT: When exploring the codebase to gather context or to answer a question that is not a needle query for a specific file/class/function, it is CRITICAL that you use the ${TASK_TOOL_NAME} tool with subagent_type=${EXPLORE_SUBAGENT_TYPE} instead of running search commands directly.`;
+- When doing file search, prefer to use the ${AGENT_TOOL_NAME} tool in order to reduce context usage.
+- You should proactively use the ${AGENT_TOOL_NAME} tool with specialized agents when the task at hand matches the agent's description.
+- VERY IMPORTANT: When exploring the codebase to gather context or to answer a question that is not a needle query for a specific file/class/function, it is CRITICAL that you use the ${AGENT_TOOL_NAME} tool with subagent_type=${EXPLORE_SUBAGENT_TYPE} instead of running search commands directly.`;
   },
 
   execute: async (
@@ -72,7 +84,7 @@ ${subagentList || "No subagents configured"}
         success: false,
         content: "",
         error: "Subagent manager not available in tool context",
-        shortResult: "Task delegation failed",
+        shortResult: "Agent delegation failed",
       };
     }
 
@@ -87,7 +99,7 @@ ${subagentList || "No subagents configured"}
         success: false,
         content: "",
         error: "description parameter is required and must be a string",
-        shortResult: "Task delegation failed",
+        shortResult: "Agent delegation failed",
       };
     }
 
@@ -96,7 +108,7 @@ ${subagentList || "No subagents configured"}
         success: false,
         content: "",
         error: "prompt parameter is required and must be a string",
-        shortResult: "Task delegation failed",
+        shortResult: "Agent delegation failed",
       };
     }
 
@@ -105,7 +117,7 @@ ${subagentList || "No subagents configured"}
         success: false,
         content: "",
         error: "subagent_type parameter is required and must be a string",
-        shortResult: "Task delegation failed",
+        shortResult: "Agent delegation failed",
       };
     }
 
@@ -121,14 +133,14 @@ ${subagentList || "No subagents configured"}
         return {
           success: false,
           content: "",
-          error: `No subagent found matching "${subagent_type}". Available subagents: ${availableNames || "none"}`,
-          shortResult: "Subagent not found",
+          error: `No agent found matching "${subagent_type}". Available agents: ${availableNames || "none"}`,
+          shortResult: "Agent not found",
         };
       }
 
       let isBackgrounded = false;
 
-      // Create subagent instance and execute task
+      // Create subagent instance and execute agent
       const instance = await subagentManager.createInstance(
         configuration,
         {
@@ -173,8 +185,8 @@ ${subagentList || "No subagents configured"}
                 await subagentManager.backgroundInstance(instance.subagentId);
                 resolve({
                   success: true,
-                  content: "Task backgrounded",
-                  shortResult: "Task backgrounded",
+                  content: "Agent backgrounded",
+                  shortResult: "Agent backgrounded",
                   isManuallyBackgrounded: true,
                 });
               },
@@ -182,7 +194,7 @@ ${subagentList || "No subagents configured"}
           }
 
           try {
-            const result = await subagentManager.executeTask(
+            const result = await subagentManager.executeAgent(
               instance,
               prompt,
               context.abortSignal,
@@ -196,13 +208,13 @@ ${subagentList || "No subagents configured"}
             if (run_in_background) {
               resolve({
                 success: true,
-                content: `Task started in background with ID: ${result}`,
-                shortResult: `Task started in background: ${result}`,
+                content: `Agent started in background with ID: ${result}`,
+                shortResult: `Agent started in background: ${result}`,
               });
               return;
             }
 
-            // Cleanup subagent instance after task completion
+            // Cleanup subagent instance after agent completion
             subagentManager.cleanupInstance(instance.subagentId);
 
             const messages = instance.messageManager.getMessages();
@@ -213,14 +225,14 @@ ${subagentList || "No subagents configured"}
             resolve({
               success: true,
               content: result,
-              shortResult: `Task completed${summary ? ` ${summary}` : ""}`,
+              shortResult: `Agent completed${summary ? ` ${summary}` : ""}`,
             });
           } catch (error) {
             if (!isBackgrounded) {
               resolve({
                 success: false,
                 content: "",
-                error: `Task delegation failed: ${error instanceof Error ? error.message : String(error)}`,
+                error: `Agent delegation failed: ${error instanceof Error ? error.message : String(error)}`,
                 shortResult: "Delegation error",
               });
             }
@@ -237,7 +249,7 @@ ${subagentList || "No subagents configured"}
       return {
         success: false,
         content: "",
-        error: `Task delegation failed: ${error instanceof Error ? error.message : String(error)}`,
+        error: `Agent delegation failed: ${error instanceof Error ? error.message : String(error)}`,
         shortResult: "Delegation error",
       };
     }

package/src/tools/grepTool.ts

@@ -6,7 +6,7 @@ import { getDisplayPath } from "../utils/path.js";
 import {
   GREP_TOOL_NAME,
   BASH_TOOL_NAME,
-  TASK_TOOL_NAME,
+  AGENT_TOOL_NAME,
 } from "../constants/tools.js";
 
 /**
@@ -94,7 +94,7 @@ export const grepTool: ToolPlugin = {
   - Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")
   - Filter files with glob parameter (e.g., "*.js", "**/*.tsx") or type parameter (e.g., "js", "py", "rust")
   - Output modes: "content" shows matching lines, "files_with_matches" shows only file paths (default), "count" shows match counts
-  - Use ${TASK_TOOL_NAME} tool for open-ended searches requiring multiple rounds
+  - Use ${AGENT_TOOL_NAME} tool for open-ended searches requiring multiple rounds
   - Pattern syntax: Uses ripgrep (not grep) - literal braces need escaping (use \`interface\\{\\}\` to find \`interface{}\` in Go code)
   - Multiline matching: By default patterns match within single lines only. For cross-line patterns like \`struct \\{[\\s\\S]*?field\`, use \`multiline: true\`
 `,

package/src/tools/skillTool.ts

@@ -155,14 +155,14 @@ export const skillTool: ToolPlugin = {
         );
 
         try {
-          const result = await subagentManager.executeTask(
+          const result = await subagentManager.executeAgent(
             instance,
             skillResult.content,
             context.abortSignal,
             false,
           );
 
-          // Cleanup subagent instance after task completion
+          // Cleanup subagent instance after agent completion
           subagentManager.cleanupInstance(instance.subagentId);
 
           const messages = instance.messageManager.getMessages();

package/src/tools/types.ts

@@ -73,7 +73,7 @@ export interface ToolContext {
   foregroundTaskManager?: import("../types/processes.js").IForegroundTaskManager;
   /** Task manager instance for task management */
   taskManager: import("../services/taskManager.js").TaskManager;
-  /** Subagent manager instance for task delegation */
+  /** Subagent manager instance for agent delegation */
   subagentManager?: import("../managers/subagentManager.js").SubagentManager;
   /** Skill manager instance for skill invocation */
   skillManager?: import("../managers/skillManager.js").SkillManager;