@iinm/plain-agent 1.8.3 → 1.8.5

package/README.md

@@ -504,8 +504,8 @@ The agent can use the following tools to assist with tasks:
 - **tmux_command**: Run a tmux command.
 - **ask_web**: Use the web search to answer questions that need up-to-date information or supporting sources. (requires Google API key or Vertex AI configuration).
 - **ask_url**: Use one or more provided URLs to answer a question. Include the URLs in your question. (requires Google API key or Vertex AI configuration).
-- **delegate_to_subagent**: Delegate a subtask to a subagent. The agent switches to a subagent role within the same conversation, focusing on the specified goal.
-- **report_as_subagent**: Report completion and return to the main agent. Used by subagents to communicate results and restore the main agent role. After reporting, the subagent's conversation history is removed from the context.
+- **switch_to_subagent**: Switch to a subagent role within the same conversation, focusing on the specified goal.
+- **switch_to_main_agent**: Switch back to the main agent role and report the result. After reporting, the subagent's conversation history is removed from the context.
 - **compact_context**: Compact the conversation context by discarding prior messages and reloading task state from a memory file. Use when the context has grown large but the task is not yet complete. Can also be invoked via the `/compact` slash command.
 
 ## Prompts

package/config/config.predefined.json

@@ -34,7 +34,7 @@
         "action": "ask"
       },
       {
-        "toolName": { "$regex": "^(delegate_to_subagent|report_as_subagent)$" },
+        "toolName": { "$regex": "^(switch_to_subagent|switch_to_main_agent)$" },
         "action": "allow"
       },
       {

package/config/prompts.predefined/shortcuts/configure.md

@@ -43,7 +43,7 @@ Ask what the user wants to configure. Common topics:
 
 If the request is vague, ask a focused clarifying question before proceeding.
 
-**If the user wants to configure Sandbox**: immediately delegate to the `sandbox-configurator` agent and do not proceed further yourself.
+**If the user wants to configure Sandbox**: immediately switch to the `sandbox-configurator` subagent and do not proceed further yourself.
 
 ## Step 4: Apply Changes
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iinm/plain-agent",
-  "version": "1.8.3",
+  "version": "1.8.5",
   "description": "A lightweight CLI-based coding agent",
   "license": "MIT",
   "type": "module",

package/sandbox/bin/plain-sandbox

@@ -731,6 +731,14 @@ setup_container_firewall() {
   # allow established connections
   iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
   iptables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
+
+  # allow localhost on IPv6
+  ip6tables -A INPUT -i lo -j ACCEPT
+  ip6tables -A OUTPUT -o lo -j ACCEPT
+
+  # allow established connections on IPv6
+  ip6tables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
+  ip6tables -A OUTPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
   
   # allow given addresses
   for address in "${addresses[@]}"; do
@@ -750,6 +758,11 @@ setup_container_firewall() {
     fi
   done
   iptables -A OUTPUT -p tcp -m set --match-set allow_list dst,dst -j ACCEPT
+
+  # Reject unauthorized TCP connections immediately with RST
+  # instead of silently dropping and causing timeout
+  iptables -A OUTPUT -p tcp -j REJECT --reject-with tcp-reset
+  ip6tables -A OUTPUT -p tcp -j REJECT --reject-with tcp-reset
 }
 
 setup_container_user() {

package/src/agent.mjs

@@ -2,8 +2,8 @@
  * @import { Agent, AgentConfig, AgentEventEmitter, UserEventEmitter } from "./agent"
  * @import { Tool, ToolDefinition } from "./tool"
  * @import { CompactContextInput } from "./tools/compactContext"
- * @import { DelegateToSubagentInput } from "./tools/delegateToSubagent"
- * @import { ReportAsSubagentInput } from "./tools/reportAsSubagent"
+ * @import { SwitchToSubagentInput } from "./tools/switchToSubagent"
+ * @import { SwitchToMainAgentInput } from "./tools/switchToMainAgent"
  */
 
 import { EventEmitter } from "node:events";
@@ -18,8 +18,8 @@ import {
   compactContextToolName,
   readMemoryForCompaction,
 } from "./tools/compactContext.mjs";
-import { delegateToSubagentToolName } from "./tools/delegateToSubagent.mjs";
-import { reportAsSubagentToolName } from "./tools/reportAsSubagent.mjs";
+import { switchToMainAgentToolName } from "./tools/switchToMainAgent.mjs";
+import { switchToSubagentToolName } from "./tools/switchToSubagent.mjs";
 
 /**
  * @param {AgentConfig} config
@@ -69,10 +69,10 @@ export function createAgent({
   });
 
   /**
-   * @param {DelegateToSubagentInput} input
+   * @param {SwitchToSubagentInput} input
    */
-  const delegateToSubagentImpl = async (input) => {
-    const result = subagentManager.delegateToSubagent(
+  const switchToSubagentImpl = async (input) => {
+    const result = subagentManager.switchToSubagent(
       input.name,
       input.goal,
       stateManager.getMessages().length - 1,
@@ -84,10 +84,10 @@ export function createAgent({
   };
 
   /**
-   * @param {ReportAsSubagentInput} input
+   * @param {SwitchToMainAgentInput} input
    */
-  const reportAsSubagentImpl = async (input) => {
-    const result = await subagentManager.reportAsSubagent(input.memoryPath);
+  const switchToMainAgentImpl = async (input) => {
+    const result = await subagentManager.switchToMainAgent(input.memoryPath);
     if (!result.success) {
       return new Error(result.error);
     }
@@ -101,7 +101,7 @@ export function createAgent({
     if (subagentManager.isSubagentActive()) {
       return new Error(
         "compact_context cannot be used while running as a subagent. " +
-          "Call report_as_subagent to return to the main agent first.",
+          "Call switch_to_main_agent to return to the main agent first.",
       );
     }
     const input = /** @type {CompactContextInput} */ (rawInput);
@@ -111,11 +111,11 @@ export function createAgent({
   /** @type {Map<string, Tool>} */
   const toolByName = new Map();
   for (const tool of tools) {
-    if (tool.def.name === delegateToSubagentToolName && tool.injectImpl) {
-      tool.injectImpl(delegateToSubagentImpl);
+    if (tool.def.name === switchToSubagentToolName && tool.injectImpl) {
+      tool.injectImpl(switchToSubagentImpl);
     }
-    if (tool.def.name === reportAsSubagentToolName && tool.injectImpl) {
-      tool.injectImpl(reportAsSubagentImpl);
+    if (tool.def.name === switchToMainAgentToolName && tool.injectImpl) {
+      tool.injectImpl(switchToMainAgentImpl);
     }
     if (tool.def.name === compactContextToolName && tool.injectImpl) {
       tool.injectImpl(compactContextImpl);
@@ -127,7 +127,7 @@ export function createAgent({
   const toolDefs = tools.map(({ def }) => def);
 
   const toolExecutor = createToolExecutor(toolByName, {
-    exclusiveToolNames: [delegateToSubagentToolName, reportAsSubagentToolName],
+    exclusiveToolNames: [switchToSubagentToolName, switchToMainAgentToolName],
   });
 
   async function dumpMessages() {

package/src/cliCommands.mjs

@@ -54,7 +54,7 @@ export function createCommandHandler({
     const goalText =
       goalTextContent?.type === "text" ? goalTextContent.text : goal;
 
-    const messageText = `Delegate to "${name}" agent with goal: ${goalText}`;
+    const messageText = `Switch to "${name}" subagent with goal: ${goalText}`;
     userEventEmitter.emit("userInput", [
       { type: "text", text: messageText },
       ...goalImages,

package/src/cliFormatter.mjs

@@ -5,7 +5,7 @@
  * @import { PatchFileInput } from "./tools/patchFile"
  * @import { WriteFileInput } from "./tools/writeFile"
  * @import { TmuxCommandInput } from "./tools/tmuxCommand"
- * @import { DelegateToSubagentInput } from "./tools/delegateToSubagent"
+ * @import { SwitchToSubagentInput } from "./tools/switchToSubagent"
  */
 
 import { styleText } from "node:util";
@@ -129,13 +129,13 @@ export function formatToolUse(toolUse) {
     ].join("\n");
   }
 
-  if (toolName === "delegate_to_subagent") {
-    /** @type {Partial<DelegateToSubagentInput>} */
-    const delegateInput = input;
+  if (toolName === "switch_to_subagent") {
+    /** @type {Partial<SwitchToSubagentInput>} */
+    const switchToSubagentInput = input;
     return [
       `tool: ${toolName}`,
-      `name: ${delegateInput.name}`,
-      `goal: ${delegateInput.goal}`,
+      `name: ${switchToSubagentInput.name}`,
+      `goal: ${switchToSubagentInput.goal}`,
     ].join("\n");
   }
 
@@ -149,12 +149,12 @@ export function formatToolUse(toolUse) {
     ].join("\n");
   }
 
-  if (toolName === "report_as_subagent") {
-    /** @type {Partial<import("./tools/reportAsSubagent").ReportAsSubagentInput>} */
-    const reportAsSubagentInput = input;
+  if (toolName === "switch_to_main_agent") {
+    /** @type {Partial<import("./tools/switchToMainAgent").SwitchToMainAgentInput>} */
+    const switchToMainAgentInput = input;
     return [
       `tool: ${toolName}`,
-      `memoryPath: ${reportAsSubagentInput.memoryPath}`,
+      `memoryPath: ${switchToMainAgentInput.memoryPath}`,
     ].join("\n");
   }
 

package/src/context/loadAgentRoles.mjs

@@ -52,41 +52,52 @@ export async function loadAgentRoles(claudeCodePlugins) {
     }
   }
 
-  /** @type {Map<string, AgentRole>} */
-  const roles = new Map();
-
-  for (const { dir, idPrefix, only } of agentDirs) {
-    const files = await getMarkdownFiles(dir).catch((err) => {
-      if (err.code !== "ENOENT") {
-        console.warn(`Failed to list agent roles in ${dir}:`, err);
-      }
-      return [];
-    });
-
-    for (const file of files) {
-      const fullPath = path.join(dir, file);
-      const content = await fs.readFile(fullPath, "utf-8").catch((err) => {
-        console.warn(`Failed to read agent role file ${fullPath}:`, err);
-        return null;
-      });
-
-      if (content === null) continue;
-
-      // Filter by only pattern if specified
-      if (only && !only.test(file)) {
-        continue;
-      }
-
-      let role = parseAgentRole(file, content, fullPath, idPrefix);
-      if (role.import) {
-        role = await mergeRemoteRole(role, file, fullPath);
-      }
-
-      roles.set(role.id, role);
-    }
-  }
+  const files = (
+    await Promise.all(
+      agentDirs.map(async ({ dir, idPrefix, only }) => {
+        const files = await getMarkdownFiles(dir).catch((err) => {
+          if (err.code !== "ENOENT") {
+            console.warn(`Failed to list agent roles in ${dir}:`, err);
+          }
+          return /** @type {string[]} */ ([]);
+        });
+        return files.map((file) => ({ dir, file, idPrefix, only }));
+      }),
+    )
+  )
+    .flat()
+    // Filter by only pattern if specified
+    .filter(({ file, only }) => !(only && !only.test(file)));
+
+  const roles = /** @type {AgentRole[]} */ (
+    (
+      await Promise.all(
+        files.map(async ({ dir, file, idPrefix }) => {
+          const fullPath = path.join(dir, file);
+          const content = await fs.readFile(fullPath, "utf-8").catch((err) => {
+            console.warn(`Failed to read agent role file ${fullPath}:`, err);
+            return null;
+          });
+
+          if (content === null) return null;
+
+          let role = parseAgentRole(file, content, fullPath, idPrefix);
+          if (role.import) {
+            try {
+              role = await mergeRemoteRole(role, file, fullPath);
+            } catch (err) {
+              console.warn(`Failed to import remote role ${role.id}:`, err);
+              return null;
+            }
+          }
+
+          return role;
+        }),
+      )
+    ).filter((role) => role)
+  );
 
-  return roles;
+  return new Map(roles.map((role) => [role.id, role]));
 }
 
 /**

package/src/context/loadPrompts.mjs

@@ -68,50 +68,63 @@ export async function loadPrompts(claudeCodePlugins) {
     }
   }
 
-  /** @type {Map<string, Prompt>} */
-  const prompts = new Map();
-
-  for (const { dir, idPrefix, only } of promptDirs) {
-    const files = await getMarkdownFiles(dir).catch((err) => {
-      if (err.code !== "ENOENT") {
-        console.warn(`Failed to list prompts in ${dir}:`, err);
-      }
-      return [];
-    });
-
-    for (const file of files) {
-      const fullPath = path.join(dir, file);
-      const content = await fs.readFile(fullPath, "utf-8").catch((err) => {
-        console.warn(`Failed to read prompt file ${fullPath}:`, err);
-        return null;
-      });
-
-      if (content === null) continue;
-
-      // Filter by only pattern if specified
-      if (only && !only.test(file)) {
-        continue;
-      }
-
-      //  Ignore all files in the skills/ directory except for SKILL.md.
-      if (fullPath.match(/\/skills\//) && !file.endsWith("/SKILL.md")) {
-        continue;
-      }
-
-      let prompt = parsePrompt(file, content, fullPath, idPrefix);
-      if (prompt.import) {
-        prompt = await mergeRemotePrompt(prompt, file, fullPath);
-      }
-
-      if (prompt.userInvocable === false) {
-        continue;
-      }
+  const files = (
+    await Promise.all(
+      promptDirs.map(async ({ dir, idPrefix, only }) => {
+        const files = await getMarkdownFiles(dir).catch((err) => {
+          if (err.code !== "ENOENT") {
+            console.warn(`Failed to list prompts in ${dir}:`, err);
+          }
+          return /** @type {string[]} */ ([]);
+        });
+        return files.map((file) => ({ dir, file, idPrefix, only }));
+      }),
+    )
+  )
+    .flat()
+    // Filter by only pattern if specified
+    .filter(({ file, only }) => !(only && !only.test(file)))
+    // Ignore all files in the skills/ directory except for SKILL.md.
+    .filter(
+      ({ file, dir }) =>
+        !(
+          path.join(dir, file).includes("/skills/") &&
+          !file.endsWith("/SKILL.md")
+        ),
+    );
 
-      prompts.set(prompt.id, prompt);
-    }
-  }
+  const prompts = /** @type {Prompt[]} */ (
+    (
+      await Promise.all(
+        files.map(async ({ dir, file, idPrefix }) => {
+          const fullPath = path.join(dir, file);
+          const content = await fs.readFile(fullPath, "utf-8").catch((err) => {
+            console.warn(`Failed to read prompt file ${fullPath}:`, err);
+            return null;
+          });
+
+          if (content === null) return null;
+
+          let prompt = parsePrompt(file, content, fullPath, idPrefix);
+          if (prompt.import) {
+            try {
+              prompt = await mergeRemotePrompt(prompt, file, fullPath);
+            } catch (err) {
+              console.warn(`Failed to import remote prompt ${prompt.id}:`, err);
+              return null;
+            }
+          }
+
+          if (prompt.userInvocable === false) {
+            return null;
+          }
+          return prompt;
+        }),
+      )
+    ).filter((prompt) => prompt)
+  );
 
-  return prompts;
+  return new Map(prompts.map((prompt) => [prompt.id, prompt]));
 }
 
 /**

package/src/main.mjs

@@ -22,10 +22,10 @@ import { createPrompt } from "./prompt.mjs";
 import { createAskURLTool } from "./tools/askURL.mjs";
 import { createAskWebTool } from "./tools/askWeb.mjs";
 import { createCompactContextTool } from "./tools/compactContext.mjs";
-import { createDelegateToSubagentTool } from "./tools/delegateToSubagent.mjs";
 import { createExecCommandTool } from "./tools/execCommand.mjs";
 import { createPatchFileTool } from "./tools/patchFile.mjs";
-import { createReportAsSubagentTool } from "./tools/reportAsSubagent.mjs";
+import { createSwitchToMainAgentTool } from "./tools/switchToMainAgent.mjs";
+import { createSwitchToSubagentTool } from "./tools/switchToSubagent.mjs";
 import { createTmuxCommandTool } from "./tools/tmuxCommand.mjs";
 import { writeFileTool } from "./tools/writeFile.mjs";
 import { createToolUseApprover } from "./toolUseApprover.mjs";
@@ -158,8 +158,10 @@ if (cliArgs.subcommand.type === "cost") {
   const modelNameWithVariant = modelFromArgs || modelFromConfig;
 
   const pluginPaths = resolvePluginPaths(appConfig.claudeCodePlugins ?? []);
-  const agentRoles = await loadAgentRoles(pluginPaths);
-  const prompts = await loadPrompts(pluginPaths);
+  const [prompts, agentRoles] = await Promise.all([
+    loadPrompts(pluginPaths),
+    loadAgentRoles(pluginPaths),
+  ]);
 
   const prompt = createPrompt({
     username: USER_NAME,
@@ -179,8 +181,8 @@ if (cliArgs.subcommand.type === "cost") {
     createPatchFileTool(),
     createTmuxCommandTool({ sandbox: appConfig.sandbox }),
     createCompactContextTool(),
-    createDelegateToSubagentTool(),
-    createReportAsSubagentTool(),
+    createSwitchToSubagentTool(),
+    createSwitchToMainAgentTool(),
   ];
 
   if (appConfig.tools?.askWeb) {

package/src/prompt.mjs

@@ -133,6 +133,6 @@ ${agentRoleDescriptions}
 export const CLAUDE_CODE_COMPATIBILITY_NOTES = `# Environment Constraints
 
 - Use memory file to manage todo list.
-- Subagents cannot run in parallel. Delegate to them one at a time.
+- Subagents cannot run in parallel. Switch to them one at a time.
 - Use AGENTS.md instead when CLAUDE.md is absent.
 - If instructed to use "haiku agent", "sonnet agent", or "opus agent", use "worker" instead.`;

package/src/subagent.mjs

@@ -1,6 +1,6 @@
 /**
  * @import { Message, MessageContentToolResult, MessageContentToolUse } from "./model"
- * @import { ReportAsSubagentInput } from "./tools/reportAsSubagent"
+ * @import { SwitchToMainAgentInput } from "./tools/switchToMainAgent"
  * @import { AgentRole } from "./context/loadAgentRoles.mjs"
  */
 
@@ -8,7 +8,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { AGENT_PROJECT_METADATA_DIR } from "./env.mjs";
 import { CLAUDE_CODE_COMPATIBILITY_NOTES } from "./prompt.mjs";
-import { reportAsSubagentToolName } from "./tools/reportAsSubagent.mjs";
+import { switchToMainAgentToolName } from "./tools/switchToMainAgent.mjs";
 
 /** @typedef {ReturnType<typeof createSubagentManager>} SubagentManager */
 
@@ -23,39 +23,39 @@ import { reportAsSubagentToolName } from "./tools/reportAsSubagent.mjs";
  * @param {SubagentStateEventHandlers} handlers
  */
 export function createSubagentManager(agentRoles, handlers) {
-  /** @type {{name: string; goal: string; delegationMessageIndex: number}[]} */
+  /** @type {{name: string; goal: string; switchMessageIndex: number}[]} */
   const subagents = [];
   let subagentCount = 0;
 
   /**
-   * @typedef {DelegateSuccess | DelegateFailure} DelegateResult
+   * @typedef {SwitchToSubagentSuccess | SwitchToSubagentFailure} SwitchToSubagentResult
    */
 
   /**
-   * @typedef {Object} DelegateSuccess
+   * @typedef {Object} SwitchToSubagentSuccess
    * @property {true} success
    * @property {string} value
    */
 
   /**
-   * @typedef {Object} DelegateFailure
+   * @typedef {Object} SwitchToSubagentFailure
    * @property {false} success
    * @property {string} error
    */
 
   /**
-   * Delegate a task to a subagent.
+   * Switch to a subagent role.
    * @param {string} name
    * @param {string} goal
-   * @param {number} delegationMessageIndex
-   * @returns {DelegateResult}
+   * @param {number} switchMessageIndex
+   * @returns {SwitchToSubagentResult}
    */
-  function delegateToSubagent(name, goal, delegationMessageIndex) {
+  function switchToSubagent(name, goal, switchMessageIndex) {
     if (subagents.length > 0) {
       return {
         success: false,
         error:
-          "Cannot call delegate_to_subagent while already acting as a subagent.",
+          "Cannot call switch_to_subagent while already acting as a subagent.",
       };
     }
 
@@ -86,7 +86,7 @@ export function createSubagentManager(agentRoles, handlers) {
     subagents.push({
       name: actualName,
       goal,
-      delegationMessageIndex,
+      switchMessageIndex,
     });
     handlers.onSubagentSwitched({ name: actualName });
 
@@ -99,37 +99,37 @@ export function createSubagentManager(agentRoles, handlers) {
           : `Role: ${actualName}`,
         `Your goal: ${goal}`,
         `Memory file path format: ${AGENT_PROJECT_METADATA_DIR}/memory/<session-id>--${sequenceNumber}--${actualName.replace("/", "-")}--<kebab-case-title>.md (Replace <kebab-case-title> with a short title describing your own goal)`,
-        `When finished, call "report_as_subagent" with the memory file path. Start executing your goal now.`,
+        `When finished, call "switch_to_main_agent" with the memory file path. Start executing your goal now.`,
       ].join("\n\n"),
     };
   }
 
   /**
-   * @typedef {ReportSuccess | ReportFailure} ReportResult
+   * @typedef {SwitchToMainAgentSuccess | SwitchToMainAgentFailure} SwitchToMainAgentResult
    */
 
   /**
-   * @typedef {Object} ReportSuccess
+   * @typedef {Object} SwitchToMainAgentSuccess
    * @property {true} success
    * @property {string} memoryContent
    */
 
   /**
-   * @typedef {Object} ReportFailure
+   * @typedef {Object} SwitchToMainAgentFailure
    * @property {false} success
    * @property {string} error
    */
 
   /**
-   * Report as a subagent and read the memory file.
+   * Switch back to the main agent role and read the memory file.
    * @param {string} memoryPath
-   * @returns {Promise<ReportResult>}
+   * @returns {Promise<SwitchToMainAgentResult>}
    */
-  async function reportAsSubagent(memoryPath) {
+  async function switchToMainAgent(memoryPath) {
     if (subagents.length === 0) {
       return {
         success: false,
-        error: "Cannot call report_as_subagent from the main agent.",
+        error: "Cannot call switch_to_main_agent from the main agent.",
       };
     }
 
@@ -171,7 +171,7 @@ export function createSubagentManager(agentRoles, handlers) {
    */
   function processToolResults(toolUseParts, toolResults, messages) {
     const reportSubagentToolUse = toolUseParts.find(
-      (toolUse) => toolUse.toolName === reportAsSubagentToolName,
+      (toolUse) => toolUse.toolName === switchToMainAgentToolName,
     );
 
     if (reportSubagentToolUse) {
@@ -193,7 +193,7 @@ export function createSubagentManager(agentRoles, handlers) {
 
   /**
    * Handle the result of a subagent reporting back.
-   * On success, truncates conversation history back to the delegation point
+   * On success, truncates conversation history back to the switch point
    * and converts the report into a standard user message.
    * @param {MessageContentToolUse} reportToolUse
    * @param {MessageContentToolResult} reportResult
@@ -214,10 +214,10 @@ export function createSubagentManager(agentRoles, handlers) {
 
     handlers.onSubagentSwitched(subagents.at(-1) ?? null);
 
-    // Truncate history back to the delegation point
+    // Truncate history back to the switch point
     const truncatedMessages = messages.slice(
       0,
-      currentSubagent.delegationMessageIndex,
+      currentSubagent.switchMessageIndex,
     );
 
     // Convert the tool result into a standard user message
@@ -225,7 +225,7 @@ export function createSubagentManager(agentRoles, handlers) {
       .map((c) => (c.type === "text" ? c.text : ""))
       .join("\n\n");
 
-    const reportInput = /** @type {ReportAsSubagentInput} */ (
+    const reportInput = /** @type {SwitchToMainAgentInput} */ (
       reportToolUse.input
     );
 
@@ -257,8 +257,8 @@ export function createSubagentManager(agentRoles, handlers) {
   }
 
   return {
-    delegateToSubagent,
-    reportAsSubagent,
+    switchToSubagent,
+    switchToMainAgent,
     processToolResults,
     isSubagentActive,
   };

package/src/tools/switchToMainAgent.d.ts

@@ -0,0 +1,3 @@
+export type SwitchToMainAgentInput = {
+  memoryPath: string;
+};

package/src/tools/{reportAsSubagent.mjs → switchToMainAgent.mjs}

@@ -2,10 +2,10 @@
  * @import { Tool, ToolImplementation } from '../tool'
  */
 
-export const reportAsSubagentToolName = "report_as_subagent";
+export const switchToMainAgentToolName = "switch_to_main_agent";
 
 /** @returns {Tool} */
-export function createReportAsSubagentTool() {
+export function createSwitchToMainAgentTool() {
   /** @type {ToolImplementation} */
   let impl = async () => {
     throw new Error("Not implemented");
@@ -14,9 +14,8 @@ export function createReportAsSubagentTool() {
   /** @type {Tool} */
   const tool = {
     def: {
-      name: reportAsSubagentToolName,
-      description:
-        "End the subagent role and report the result to the main agent.",
+      name: switchToMainAgentToolName,
+      description: "Switch back to the main agent role and report the result.",
       inputSchema: {
         type: "object",
         properties: {

package/src/tools/switchToSubagent.d.ts

@@ -0,0 +1,4 @@
+export type SwitchToSubagentInput = {
+  name: string;
+  goal: string;
+};

package/src/tools/{delegateToSubagent.mjs → switchToSubagent.mjs}

@@ -2,10 +2,10 @@
  * @import { Tool, ToolImplementation } from '../tool'
  */
 
-export const delegateToSubagentToolName = "delegate_to_subagent";
+export const switchToSubagentToolName = "switch_to_subagent";
 
 /** @returns {Tool} */
-export function createDelegateToSubagentTool() {
+export function createSwitchToSubagentTool() {
   /** @type {ToolImplementation} */
   let impl = async () => {
     throw new Error("Not implemented");
@@ -14,9 +14,9 @@ export function createDelegateToSubagentTool() {
   /** @type {Tool} */
   const tool = {
     def: {
-      name: delegateToSubagentToolName,
+      name: switchToSubagentToolName,
       description:
-        "Delegate a subtask to a subagent. You inherit the current context and work on the delegated goal.",
+        "Switch to a subagent role within the same conversation, focusing on the specified goal. You inherit the current context.",
       inputSchema: {
         type: "object",
         properties: {
@@ -42,6 +42,17 @@ export function createDelegateToSubagentTool() {
     injectImpl(fn) {
       impl = fn;
     },
+
+    /**
+     * @param {Record<string, unknown>} input
+     * @returns {Record<string, unknown>}
+     */
+    maskApprovalInput: (input) => {
+      const { name } = /** @type {{name: string}} */ (input);
+      return {
+        name,
+      };
+    },
   };
 
   return tool;

package/src/tools/delegateToSubagent.d.ts

@@ -1,4 +0,0 @@
-export type DelegateToSubagentInput = {
-  name: string;
-  goal: string;
-};

package/src/tools/reportAsSubagent.d.ts

@@ -1,3 +0,0 @@
-export type ReportAsSubagentInput = {
-  memoryPath: string;
-};