@robota-sdk/agent-sdk 3.0.0-beta.31 → 3.0.0-beta.33

package/dist/node/index.cjs

@@ -31,26 +31,33 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AgentExecutor: () => AgentExecutor,
+  BUILT_IN_AGENTS: () => BUILT_IN_AGENTS,
   BundlePluginInstaller: () => BundlePluginInstaller,
   BundlePluginLoader: () => BundlePluginLoader,
   DEFAULT_TOOL_DESCRIPTIONS: () => DEFAULT_TOOL_DESCRIPTIONS,
-  FileSessionLogger: () => import_agent_sessions3.FileSessionLogger,
+  FileSessionLogger: () => import_agent_sessions5.FileSessionLogger,
   MarketplaceClient: () => MarketplaceClient,
   PluginSettingsStore: () => PluginSettingsStore,
   PromptExecutor: () => PromptExecutor,
-  Session: () => import_agent_sessions2.Session,
-  SessionStore: () => import_agent_sessions4.SessionStore,
-  SilentSessionLogger: () => import_agent_sessions3.SilentSessionLogger,
+  Session: () => import_agent_sessions4.Session,
+  SessionStore: () => import_agent_sessions6.SessionStore,
+  SilentSessionLogger: () => import_agent_sessions5.SilentSessionLogger,
   TRUST_TO_MODE: () => import_agent_core.TRUST_TO_MODE,
-  agentTool: () => agentTool,
+  assembleSubagentPrompt: () => assembleSubagentPrompt,
   bashTool: () => import_agent_tools3.bashTool,
   buildSystemPrompt: () => buildSystemPrompt,
+  createAgentTool: () => createAgentTool,
   createDefaultTools: () => createDefaultTools,
   createProvider: () => createProvider,
   createSession: () => createSession,
+  createSubagentLogger: () => createSubagentLogger,
+  createSubagentSession: () => createSubagentSession,
   detectProject: () => detectProject,
   editTool: () => import_agent_tools6.editTool,
   evaluatePermission: () => import_agent_core2.evaluatePermission,
+  getBuiltInAgent: () => getBuiltInAgent,
+  getForkWorkerSuffix: () => getForkWorkerSuffix,
+  getSubagentSuffix: () => getSubagentSuffix,
   globTool: () => import_agent_tools7.globTool,
   grepTool: () => import_agent_tools8.grepTool,
   loadConfig: () => loadConfig,
@@ -59,8 +66,10 @@ __export(index_exports, {
   promptForApproval: () => promptForApproval,
   query: () => query,
   readTool: () => import_agent_tools4.readTool,
+  resolveSubagentLogDir: () => resolveSubagentLogDir,
+  retrieveAgentToolDeps: () => retrieveAgentToolDeps,
   runHooks: () => import_agent_core3.runHooks,
-  setAgentToolDeps: () => setAgentToolDeps,
+  storeAgentToolDeps: () => storeAgentToolDeps,
   userPaths: () => userPaths,
   writeTool: () => import_agent_tools5.writeTool
 });
@@ -177,7 +186,7 @@ Respond with JSON: { "ok": boolean, "reason"?: string }`;
 };
 
 // src/assembly/create-session.ts
-var import_agent_sessions = require("@robota-sdk/agent-sessions");
+var import_agent_sessions2 = require("@robota-sdk/agent-sessions");
 
 // src/context/system-prompt-builder.ts
 var TRUST_LEVEL_DESCRIPTIONS = {
@@ -310,11 +319,379 @@ function createProvider(config) {
   return new import_agent_provider_anthropic.AnthropicProvider({ apiKey });
 }
 
+// src/tools/agent-tool.ts
+var import_zod = require("zod");
+var import_agent_tools2 = require("@robota-sdk/agent-tools");
+
+// src/agents/built-in-agents.ts
+var GENERAL_PURPOSE_SYSTEM_PROMPT = `You are a general-purpose task execution agent. You have access to all tools available in the parent session and can perform any task delegated to you.
+
+Your role is to complete the assigned task thoroughly and accurately. Follow these guidelines:
+
+- Execute the task as described in the prompt. Do not expand scope beyond what is requested.
+- Use the most appropriate tools for each step. Prefer precise tools (Read, Grep, Glob) over broad ones (Bash) when possible.
+- Report your findings clearly and concisely when the task is complete.
+- If a task cannot be completed, explain why and what information is missing.
+- Maintain the same code quality standards as the parent session (strict types, no fallbacks, proper error handling).`;
+var EXPLORE_SYSTEM_PROMPT = `You are a codebase exploration and analysis agent. Your purpose is to search, read, and understand code without making any modifications.
+
+You operate in read-only mode. You must NEVER attempt to write or edit files. Your tools are restricted to read-only operations: reading files, searching with grep and glob, and running non-destructive bash commands.
+
+Your role is to answer questions about the codebase by:
+
+- Searching for relevant files, symbols, and patterns using Glob and Grep.
+- Reading source files, configuration, and documentation to understand structure and behavior.
+- Tracing code paths across modules to understand how components interact.
+- Summarizing findings in a clear, structured format with file paths and line references.
+- Identifying architectural patterns, dependencies, and potential issues.
+
+When exploring, prefer targeted searches over broad scans. Start with the most likely locations and narrow down. Always include absolute file paths in your responses so the caller can navigate directly to relevant code.`;
+var PLAN_SYSTEM_PROMPT = `You are a planning, research, and architecture agent. Your purpose is to analyze requirements, research approaches, and produce structured plans without making any code modifications.
+
+You operate in read-only mode. You must NEVER attempt to write or edit files. Your tools are restricted to read-only operations.
+
+Your role is to:
+
+- Analyze the current codebase state relevant to the task by reading specs, source code, and tests.
+- Research implementation approaches by examining existing patterns and architectural conventions in the repository.
+- Identify affected files, modules, and interfaces that a proposed change would touch.
+- Assess risks, dependencies, and potential breaking changes.
+- Produce a structured implementation plan with clear steps, file lists, and ordering.
+- Consider edge cases, error handling, and test coverage requirements.
+
+Output your plan in a structured format with numbered steps. For each step, specify which files are involved and what changes are needed. Flag any decisions that require human judgment or clarification.`;
+var BUILT_IN_AGENTS = [
+  {
+    name: "general-purpose",
+    description: "General-purpose task execution agent with full tool access.",
+    systemPrompt: GENERAL_PURPOSE_SYSTEM_PROMPT
+  },
+  {
+    name: "Explore",
+    description: "Read-only codebase exploration and analysis agent.",
+    systemPrompt: EXPLORE_SYSTEM_PROMPT,
+    model: "claude-haiku-4-5",
+    disallowedTools: ["Write", "Edit"]
+  },
+  {
+    name: "Plan",
+    description: "Read-only planning, research, and architecture agent.",
+    systemPrompt: PLAN_SYSTEM_PROMPT,
+    disallowedTools: ["Write", "Edit"]
+  }
+];
+function getBuiltInAgent(name) {
+  return BUILT_IN_AGENTS.find((agent) => agent.name === name);
+}
+
+// src/assembly/create-subagent-session.ts
+var import_agent_sessions = require("@robota-sdk/agent-sessions");
+
+// src/assembly/subagent-prompts.ts
+function getSubagentSuffix() {
+  return `When you complete the task, respond with a concise report covering what was done and any key findings \u2014 the caller will relay this to the user, so it only needs the essentials.
+
+In your final response, share file paths (always absolute, never relative) that are relevant to the task. Include code snippets only when the exact text is load-bearing \u2014 do not recap code you merely read.
+
+Do not use emojis.`;
+}
+function getForkWorkerSuffix() {
+  return `You are a worker subagent executing a specific task. Do NOT spawn sub-agents; execute directly. Keep your report under 500 words. Use this structure:
+- Scope: What was requested
+- Result: What was done
+- Key files: Relevant file paths (absolute)
+- Files changed: List of modifications
+- Issues: Any problems encountered`;
+}
+function assembleSubagentPrompt(options) {
+  const parts = [options.agentBody];
+  if (options.claudeMd) {
+    parts.push(options.claudeMd);
+  }
+  if (options.agentsMd) {
+    parts.push(options.agentsMd);
+  }
+  const suffix = options.isForkWorker ? getForkWorkerSuffix() : getSubagentSuffix();
+  parts.push(suffix);
+  return parts.join("\n\n");
+}
+
+// src/assembly/create-subagent-session.ts
+var MODEL_SHORTCUTS = {
+  sonnet: "claude-sonnet-4-6",
+  haiku: "claude-haiku-4-5",
+  opus: "claude-opus-4-6"
+};
+function resolveModelId(shortName, _parentModel) {
+  return MODEL_SHORTCUTS[shortName] ?? shortName;
+}
+function filterTools(parentTools, agentDefinition) {
+  let tools = [...parentTools];
+  if (agentDefinition.disallowedTools) {
+    const denySet = new Set(agentDefinition.disallowedTools);
+    tools = tools.filter((t) => !denySet.has(t.getName()));
+  }
+  if (agentDefinition.tools) {
+    const allowSet = new Set(agentDefinition.tools);
+    tools = tools.filter((t) => allowSet.has(t.getName()));
+  }
+  tools = tools.filter((t) => t.getName() !== "Agent");
+  return tools;
+}
+function createSubagentSession(options) {
+  const { agentDefinition, parentConfig, parentContext, parentTools, terminal } = options;
+  const tools = filterTools(parentTools, agentDefinition);
+  const model = agentDefinition.model ? resolveModelId(agentDefinition.model, parentConfig.provider.model) : parentConfig.provider.model;
+  const systemMessage = assembleSubagentPrompt({
+    agentBody: agentDefinition.systemPrompt,
+    claudeMd: parentContext.claudeMd,
+    agentsMd: parentContext.agentsMd,
+    isForkWorker: options.isForkWorker ?? false
+  });
+  const provider = createProvider(parentConfig);
+  return new import_agent_sessions.Session({
+    tools,
+    provider,
+    systemMessage,
+    terminal,
+    model,
+    maxTurns: agentDefinition.maxTurns,
+    permissions: parentConfig.permissions,
+    permissionMode: options.permissionMode,
+    defaultTrustLevel: parentConfig.defaultTrustLevel,
+    permissionHandler: options.permissionHandler,
+    hooks: options.hooks,
+    hookTypeExecutors: options.hookTypeExecutors,
+    onTextDelta: options.onTextDelta,
+    onToolExecution: options.onToolExecution
+  });
+}
+
+// src/tools/agent-tool.ts
+function asZodSchema(schema) {
+  return schema;
+}
+var AgentSchema = import_zod.z.object({
+  prompt: import_zod.z.string().describe("The task for the subagent to perform"),
+  subagent_type: import_zod.z.string().optional().describe('Agent type: "general-purpose", "Explore", "Plan", or a custom agent name'),
+  model: import_zod.z.string().optional().describe("Optional model override")
+});
+var sessionDepsStore = /* @__PURE__ */ new WeakMap();
+function storeAgentToolDeps(key, deps) {
+  sessionDepsStore.set(key, deps);
+}
+function retrieveAgentToolDeps(key) {
+  return sessionDepsStore.get(key);
+}
+function resolveAgentDefinition(agentType, customRegistry) {
+  const builtIn = getBuiltInAgent(agentType);
+  if (builtIn) return builtIn;
+  if (customRegistry) return customRegistry(agentType);
+  return void 0;
+}
+function generateAgentId() {
+  return `agent_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function createAgentTool(deps) {
+  async function runAgent(args) {
+    const agentType = args.subagent_type ?? "general-purpose";
+    const agentDef = resolveAgentDefinition(agentType, deps.customAgentRegistry);
+    if (!agentDef) {
+      return JSON.stringify({
+        success: false,
+        output: "",
+        error: `Unknown agent type: ${agentType}`
+      });
+    }
+    const effectiveDef = args.model ? { ...agentDef, model: args.model } : agentDef;
+    const session = createSubagentSession({
+      agentDefinition: effectiveDef,
+      parentConfig: deps.config,
+      parentContext: deps.context,
+      parentTools: deps.tools,
+      terminal: deps.terminal,
+      permissionMode: deps.permissionMode,
+      permissionHandler: deps.permissionHandler,
+      hooks: deps.hooks,
+      hookTypeExecutors: deps.hookTypeExecutors,
+      onTextDelta: deps.onTextDelta,
+      onToolExecution: deps.onToolExecution
+    });
+    const agentId = generateAgentId();
+    try {
+      const response = await session.run(args.prompt);
+      return JSON.stringify({
+        success: true,
+        output: response,
+        agentId
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return JSON.stringify({
+        success: false,
+        output: "",
+        error: `Sub-agent error: ${message}`,
+        agentId
+      });
+    }
+  }
+  return (0, import_agent_tools2.createZodFunctionTool)(
+    "Agent",
+    "Launch a subagent to handle a task in an isolated context. The subagent gets its own context window and returns a result when done. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.",
+    asZodSchema(AgentSchema),
+    async (params) => {
+      return runAgent(params);
+    }
+  );
+}
+
+// src/agents/agent-definition-loader.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var import_node_os = require("os");
+var LIST_KEYS = /* @__PURE__ */ new Set(["tools", "disallowedTools"]);
+var NUMBER_KEYS = /* @__PURE__ */ new Set(["maxTurns"]);
+function parseFrontmatter(content) {
+  const lines = content.split("\n");
+  if (lines[0]?.trim() !== "---") {
+    return { frontmatter: null, body: content };
+  }
+  let endIndex = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i]?.trim() === "---") {
+      endIndex = i;
+      break;
+    }
+  }
+  if (endIndex === -1) {
+    return { frontmatter: null, body: content };
+  }
+  const result = {};
+  for (let i = 1; i < endIndex; i++) {
+    const line = lines[i];
+    const match = line.match(/^([a-zA-Z][a-zA-Z0-9]*(?:[A-Z][a-z]*)*):\s*(.+)/);
+    if (!match) continue;
+    const key = match[1];
+    const rawValue = match[2].trim();
+    if (LIST_KEYS.has(key)) {
+      result[key] = rawValue.split(",").map((s) => s.trim());
+    } else if (NUMBER_KEYS.has(key)) {
+      result[key] = parseInt(rawValue, 10);
+    } else {
+      result[key] = rawValue;
+    }
+  }
+  const body = lines.slice(endIndex + 1).join("\n").trim();
+  return {
+    frontmatter: Object.keys(result).length > 0 ? result : null,
+    body
+  };
+}
+function scanAgentsDir(dir) {
+  if (!(0, import_node_fs.existsSync)(dir)) return [];
+  const agents = [];
+  let entries;
+  try {
+    entries = (0, import_node_fs.readdirSync)(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+    const filePath = (0, import_node_path.join)(dir, entry.name);
+    const content = (0, import_node_fs.readFileSync)(filePath, "utf-8");
+    const { frontmatter, body } = parseFrontmatter(content);
+    const fallbackName = (0, import_node_path.basename)(entry.name, ".md");
+    const agent = {
+      name: frontmatter?.name ?? fallbackName,
+      description: frontmatter?.description ?? "",
+      systemPrompt: body
+    };
+    if (frontmatter?.model !== void 0) agent.model = frontmatter.model;
+    if (frontmatter?.maxTurns !== void 0) agent.maxTurns = frontmatter.maxTurns;
+    if (frontmatter?.tools !== void 0) agent.tools = frontmatter.tools;
+    if (frontmatter?.disallowedTools !== void 0)
+      agent.disallowedTools = frontmatter.disallowedTools;
+    agents.push(agent);
+  }
+  return agents;
+}
+var AgentDefinitionLoader = class {
+  cwd;
+  home;
+  constructor(cwd, home) {
+    this.cwd = cwd;
+    this.home = home ?? (0, import_node_os.homedir)();
+  }
+  /** Load all agent definitions, merged with built-in agents. Custom overrides built-in on name collision. */
+  loadAll() {
+    const sources = [
+      scanAgentsDir((0, import_node_path.join)(this.cwd, ".claude", "agents")),
+      scanAgentsDir((0, import_node_path.join)(this.home, ".robota", "agents"))
+    ];
+    const seen = /* @__PURE__ */ new Set();
+    const customAgents = [];
+    for (const agents of sources) {
+      for (const agent of agents) {
+        if (!seen.has(agent.name)) {
+          seen.add(agent.name);
+          customAgents.push(agent);
+        }
+      }
+    }
+    const result = [...customAgents];
+    for (const builtIn of BUILT_IN_AGENTS) {
+      if (!seen.has(builtIn.name)) {
+        result.push(builtIn);
+      }
+    }
+    return result;
+  }
+  /** Get a specific agent by name (custom or built-in). */
+  getAgent(name) {
+    return this.loadAll().find((agent) => agent.name === name);
+  }
+};
+
 // src/assembly/create-session.ts
 function createSession(options) {
   const provider = options.provider ?? createProvider(options.config);
   const defaultTools = createDefaultTools();
   const tools = [...defaultTools, ...options.additionalTools ?? []];
+  const agentLoader = new AgentDefinitionLoader(process.cwd());
+  const hookTypeExecutors = [];
+  if (options.providerFactory) {
+    hookTypeExecutors.push(
+      new PromptExecutor({
+        providerFactory: options.providerFactory,
+        defaultModel: options.config.provider.model
+      })
+    );
+  }
+  if (options.sessionFactory) {
+    hookTypeExecutors.push(
+      new AgentExecutor({
+        sessionFactory: options.sessionFactory
+      })
+    );
+  }
+  if (options.additionalHookExecutors) {
+    hookTypeExecutors.push(...options.additionalHookExecutors);
+  }
+  const agentToolDeps = {
+    config: options.config,
+    context: options.context,
+    tools,
+    terminal: options.terminal,
+    permissionMode: options.permissionMode,
+    permissionHandler: options.permissionHandler,
+    hooks: options.config.hooks,
+    hookTypeExecutors: hookTypeExecutors.length > 0 ? hookTypeExecutors : void 0,
+    onTextDelta: options.onTextDelta,
+    onToolExecution: options.onToolExecution,
+    customAgentRegistry: (name) => agentLoader.getAgent(name)
+  };
+  tools.push(createAgentTool(agentToolDeps));
   const buildPrompt = options.systemPromptBuilder ?? buildSystemPrompt;
   const systemMessage = buildPrompt({
     agentsMd: options.context.agentsMd,
@@ -337,26 +714,7 @@ function createSession(options) {
     allow: [...defaultAllow, ...options.config.permissions.allow ?? []],
     deny: options.config.permissions.deny ?? []
   };
-  const hookTypeExecutors = [];
-  if (options.providerFactory) {
-    hookTypeExecutors.push(
-      new PromptExecutor({
-        providerFactory: options.providerFactory,
-        defaultModel: options.config.provider.model
-      })
-    );
-  }
-  if (options.sessionFactory) {
-    hookTypeExecutors.push(
-      new AgentExecutor({
-        sessionFactory: options.sessionFactory
-      })
-    );
-  }
-  if (options.additionalHookExecutors) {
-    hookTypeExecutors.push(...options.additionalHookExecutors);
-  }
-  return new import_agent_sessions.Session({
+  const session = new import_agent_sessions2.Session({
     tools,
     provider,
     systemMessage,
@@ -377,89 +735,104 @@ function createSession(options) {
     sessionLogger: options.sessionLogger,
     hookTypeExecutors: hookTypeExecutors.length > 0 ? hookTypeExecutors : void 0
   });
+  storeAgentToolDeps(session, agentToolDeps);
+  return session;
 }
 
-// src/index.ts
-var import_agent_sessions2 = require("@robota-sdk/agent-sessions");
+// src/assembly/subagent-logger.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
 var import_agent_sessions3 = require("@robota-sdk/agent-sessions");
+function createSubagentLogger(parentSessionId, _agentId, baseLogsDir) {
+  const subagentDir = (0, import_node_path2.join)(baseLogsDir, parentSessionId, "subagents");
+  (0, import_node_fs2.mkdirSync)(subagentDir, { recursive: true });
+  return new import_agent_sessions3.FileSessionLogger(subagentDir);
+}
+function resolveSubagentLogDir(parentSessionId, baseLogsDir) {
+  return (0, import_node_path2.join)(baseLogsDir, parentSessionId, "subagents");
+}
+
+// src/index.ts
 var import_agent_sessions4 = require("@robota-sdk/agent-sessions");
+var import_agent_sessions5 = require("@robota-sdk/agent-sessions");
+var import_agent_sessions6 = require("@robota-sdk/agent-sessions");
 
 // src/config/config-loader.ts
 var import_fs = require("fs");
 var import_path = require("path");
 
 // src/config/config-types.ts
-var import_zod = require("zod");
-var ProviderSchema = import_zod.z.object({
-  name: import_zod.z.string().optional(),
-  model: import_zod.z.string().optional(),
-  apiKey: import_zod.z.string().optional()
+var import_zod2 = require("zod");
+var ProviderSchema = import_zod2.z.object({
+  name: import_zod2.z.string().optional(),
+  model: import_zod2.z.string().optional(),
+  apiKey: import_zod2.z.string().optional()
 });
-var PermissionsSchema = import_zod.z.object({
+var PermissionsSchema = import_zod2.z.object({
   /** Patterns that are always approved without prompting */
-  allow: import_zod.z.array(import_zod.z.string()).optional(),
+  allow: import_zod2.z.array(import_zod2.z.string()).optional(),
   /** Patterns that are always denied */
-  deny: import_zod.z.array(import_zod.z.string()).optional()
+  deny: import_zod2.z.array(import_zod2.z.string()).optional()
 });
-var EnvSchema = import_zod.z.record(import_zod.z.string()).optional();
-var CommandHookDefinitionSchema = import_zod.z.object({
-  type: import_zod.z.literal("command"),
-  command: import_zod.z.string(),
-  timeout: import_zod.z.number().optional()
+var EnvSchema = import_zod2.z.record(import_zod2.z.string()).optional();
+var CommandHookDefinitionSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("command"),
+  command: import_zod2.z.string(),
+  timeout: import_zod2.z.number().optional()
 });
-var HttpHookDefinitionSchema = import_zod.z.object({
-  type: import_zod.z.literal("http"),
-  url: import_zod.z.string(),
-  headers: import_zod.z.record(import_zod.z.string()).optional(),
-  timeout: import_zod.z.number().optional()
+var HttpHookDefinitionSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("http"),
+  url: import_zod2.z.string(),
+  headers: import_zod2.z.record(import_zod2.z.string()).optional(),
+  timeout: import_zod2.z.number().optional()
 });
-var PromptHookDefinitionSchema = import_zod.z.object({
-  type: import_zod.z.literal("prompt"),
-  prompt: import_zod.z.string(),
-  model: import_zod.z.string().optional()
+var PromptHookDefinitionSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("prompt"),
+  prompt: import_zod2.z.string(),
+  model: import_zod2.z.string().optional()
 });
-var AgentHookDefinitionSchema = import_zod.z.object({
-  type: import_zod.z.literal("agent"),
-  agent: import_zod.z.string(),
-  maxTurns: import_zod.z.number().optional(),
-  timeout: import_zod.z.number().optional()
+var AgentHookDefinitionSchema = import_zod2.z.object({
+  type: import_zod2.z.literal("agent"),
+  agent: import_zod2.z.string(),
+  maxTurns: import_zod2.z.number().optional(),
+  timeout: import_zod2.z.number().optional()
 });
-var HookDefinitionSchema = import_zod.z.discriminatedUnion("type", [
+var HookDefinitionSchema = import_zod2.z.discriminatedUnion("type", [
   CommandHookDefinitionSchema,
   HttpHookDefinitionSchema,
   PromptHookDefinitionSchema,
   AgentHookDefinitionSchema
 ]);
-var HookGroupSchema = import_zod.z.object({
-  matcher: import_zod.z.string(),
-  hooks: import_zod.z.array(HookDefinitionSchema)
+var HookGroupSchema = import_zod2.z.object({
+  matcher: import_zod2.z.string(),
+  hooks: import_zod2.z.array(HookDefinitionSchema)
 });
-var HooksSchema = import_zod.z.object({
-  PreToolUse: import_zod.z.array(HookGroupSchema).optional(),
-  PostToolUse: import_zod.z.array(HookGroupSchema).optional(),
-  SessionStart: import_zod.z.array(HookGroupSchema).optional(),
-  Stop: import_zod.z.array(HookGroupSchema).optional(),
-  PreCompact: import_zod.z.array(HookGroupSchema).optional(),
-  PostCompact: import_zod.z.array(HookGroupSchema).optional(),
-  UserPromptSubmit: import_zod.z.array(HookGroupSchema).optional(),
-  Notification: import_zod.z.array(HookGroupSchema).optional()
+var HooksSchema = import_zod2.z.object({
+  PreToolUse: import_zod2.z.array(HookGroupSchema).optional(),
+  PostToolUse: import_zod2.z.array(HookGroupSchema).optional(),
+  SessionStart: import_zod2.z.array(HookGroupSchema).optional(),
+  Stop: import_zod2.z.array(HookGroupSchema).optional(),
+  PreCompact: import_zod2.z.array(HookGroupSchema).optional(),
+  PostCompact: import_zod2.z.array(HookGroupSchema).optional(),
+  UserPromptSubmit: import_zod2.z.array(HookGroupSchema).optional(),
+  Notification: import_zod2.z.array(HookGroupSchema).optional()
 }).optional();
-var EnabledPluginsSchema = import_zod.z.record(import_zod.z.boolean()).optional();
-var MarketplaceSourceSchema = import_zod.z.object({
-  source: import_zod.z.object({
-    type: import_zod.z.enum(["github", "git", "local", "url"]),
-    repo: import_zod.z.string().optional(),
-    url: import_zod.z.string().optional(),
-    path: import_zod.z.string().optional(),
-    ref: import_zod.z.string().optional()
+var EnabledPluginsSchema = import_zod2.z.record(import_zod2.z.boolean()).optional();
+var MarketplaceSourceSchema = import_zod2.z.object({
+  source: import_zod2.z.object({
+    type: import_zod2.z.enum(["github", "git", "local", "url"]),
+    repo: import_zod2.z.string().optional(),
+    url: import_zod2.z.string().optional(),
+    path: import_zod2.z.string().optional(),
+    ref: import_zod2.z.string().optional()
   })
 });
-var ExtraKnownMarketplacesSchema = import_zod.z.record(MarketplaceSourceSchema).optional();
-var SettingsSchema = import_zod.z.object({
+var ExtraKnownMarketplacesSchema = import_zod2.z.record(MarketplaceSourceSchema).optional();
+var SettingsSchema = import_zod2.z.object({
   /** Trust level used when no --permission-mode flag is given */
-  defaultTrustLevel: import_zod.z.enum(["safe", "moderate", "full"]).optional(),
+  defaultTrustLevel: import_zod2.z.enum(["safe", "moderate", "full"]).optional(),
   /** Response language (e.g., "ko", "en", "ja"). Injected into system prompt. */
-  language: import_zod.z.string().optional(),
+  language: import_zod2.z.string().optional(),
   provider: ProviderSchema.optional(),
   permissions: PermissionsSchema.optional(),
   env: EnvSchema,
@@ -781,28 +1154,28 @@ var import_agent_core2 = require("@robota-sdk/agent-core");
 var import_agent_core3 = require("@robota-sdk/agent-core");
 
 // src/paths.ts
-var import_node_path = require("path");
-var import_node_os = require("os");
+var import_node_path3 = require("path");
+var import_node_os2 = require("os");
 function projectPaths(cwd) {
-  const base = (0, import_node_path.join)(cwd, ".robota");
+  const base = (0, import_node_path3.join)(cwd, ".robota");
   return {
-    settings: (0, import_node_path.join)(base, "settings.json"),
-    settingsLocal: (0, import_node_path.join)(base, "settings.local.json"),
-    logs: (0, import_node_path.join)(base, "logs"),
-    sessions: (0, import_node_path.join)(base, "sessions")
+    settings: (0, import_node_path3.join)(base, "settings.json"),
+    settingsLocal: (0, import_node_path3.join)(base, "settings.local.json"),
+    logs: (0, import_node_path3.join)(base, "logs"),
+    sessions: (0, import_node_path3.join)(base, "sessions")
   };
 }
 function userPaths() {
-  const base = (0, import_node_path.join)((0, import_node_os.homedir)(), ".robota");
+  const base = (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".robota");
   return {
-    settings: (0, import_node_path.join)(base, "settings.json"),
-    sessions: (0, import_node_path.join)(base, "sessions")
+    settings: (0, import_node_path3.join)(base, "settings.json"),
+    sessions: (0, import_node_path3.join)(base, "sessions")
   };
 }
 
 // src/plugins/plugin-settings-store.ts
-var import_node_fs = require("fs");
-var import_node_path2 = require("path");
+var import_node_fs3 = require("fs");
+var import_node_path4 = require("path");
 var PluginSettingsStore = class {
   settingsPath;
   constructor(settingsPath) {
@@ -810,11 +1183,11 @@ var PluginSettingsStore = class {
   }
   /** Read the full settings file from disk. */
   readAll() {
-    if (!(0, import_node_fs.existsSync)(this.settingsPath)) {
+    if (!(0, import_node_fs3.existsSync)(this.settingsPath)) {
       return {};
     }
     try {
-      const raw = (0, import_node_fs.readFileSync)(this.settingsPath, "utf-8");
+      const raw = (0, import_node_fs3.readFileSync)(this.settingsPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data === "object" && data !== null) {
         return data;
@@ -826,11 +1199,11 @@ var PluginSettingsStore = class {
   }
   /** Write the full settings file to disk. */
   writeAll(settings) {
-    const dir = (0, import_node_path2.dirname)(this.settingsPath);
-    if (!(0, import_node_fs.existsSync)(dir)) {
-      (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_node_path4.dirname)(this.settingsPath);
+    if (!(0, import_node_fs3.existsSync)(dir)) {
+      (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
     }
-    (0, import_node_fs.writeFileSync)(this.settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+    (0, import_node_fs3.writeFileSync)(this.settingsPath, JSON.stringify(settings, null, 2), "utf-8");
   }
   // --- enabledPlugins ---
   /** Get the enabledPlugins map. */
@@ -902,8 +1275,8 @@ var PluginSettingsStore = class {
 };
 
 // src/plugins/bundle-plugin-loader.ts
-var import_node_fs2 = require("fs");
-var import_node_path3 = require("path");
+var import_node_fs4 = require("fs");
+var import_node_path5 = require("path");
 function parseSkillFrontmatter(raw) {
   const trimmed = raw.trimStart();
   if (!trimmed.startsWith("---")) {
@@ -952,9 +1325,9 @@ function validateManifest(data) {
   };
 }
 function getSortedSubdirs(dirPath) {
-  if (!(0, import_node_fs2.existsSync)(dirPath)) return [];
+  if (!(0, import_node_fs4.existsSync)(dirPath)) return [];
   try {
-    const entries = (0, import_node_fs2.readdirSync)(dirPath, { withFileTypes: true });
+    const entries = (0, import_node_fs4.readdirSync)(dirPath, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
   } catch {
     return [];
@@ -982,23 +1355,23 @@ var BundlePluginLoader = class {
    * For each marketplace/plugin pair, the latest version (lexicographically last) is loaded.
    */
   discoverAndLoad() {
-    const cacheDir = (0, import_node_path3.join)(this.pluginsDir, "cache");
-    if (!(0, import_node_fs2.existsSync)(cacheDir)) {
+    const cacheDir = (0, import_node_path5.join)(this.pluginsDir, "cache");
+    if (!(0, import_node_fs4.existsSync)(cacheDir)) {
       return [];
     }
     const results = [];
     const marketplaces = getSortedSubdirs(cacheDir);
     for (const marketplace of marketplaces) {
-      const marketplaceDir = (0, import_node_path3.join)(cacheDir, marketplace);
+      const marketplaceDir = (0, import_node_path5.join)(cacheDir, marketplace);
       const plugins = getSortedSubdirs(marketplaceDir);
       for (const pluginName of plugins) {
-        const pluginDir = (0, import_node_path3.join)(marketplaceDir, pluginName);
+        const pluginDir = (0, import_node_path5.join)(marketplaceDir, pluginName);
         const versions = getSortedSubdirs(pluginDir);
         if (versions.length === 0) continue;
         const latestVersion = versions[versions.length - 1];
-        const versionDir = (0, import_node_path3.join)(pluginDir, latestVersion);
-        const manifestPath = (0, import_node_path3.join)(versionDir, ".claude-plugin", "plugin.json");
-        if (!(0, import_node_fs2.existsSync)(manifestPath)) continue;
+        const versionDir = (0, import_node_path5.join)(pluginDir, latestVersion);
+        const manifestPath = (0, import_node_path5.join)(versionDir, ".claude-plugin", "plugin.json");
+        if (!(0, import_node_fs4.existsSync)(manifestPath)) continue;
         const manifest = this.readManifest(manifestPath);
         if (!manifest) continue;
         const pluginId = `${manifest.name}@${marketplace}`;
@@ -1012,7 +1385,7 @@ var BundlePluginLoader = class {
   /** Read and validate a plugin.json manifest. Returns null on failure. */
   readManifest(path) {
     try {
-      const raw = (0, import_node_fs2.readFileSync)(path, "utf-8");
+      const raw = (0, import_node_fs4.readFileSync)(path, "utf-8");
       const data = JSON.parse(raw);
       return validateManifest(data);
     } catch {
@@ -1047,15 +1420,15 @@ var BundlePluginLoader = class {
   }
   /** Load skills from the plugin's skills/ directory. */
   loadSkills(pluginDir, pluginName) {
-    const skillsDir = (0, import_node_path3.join)(pluginDir, "skills");
-    if (!(0, import_node_fs2.existsSync)(skillsDir)) return [];
-    const entries = (0, import_node_fs2.readdirSync)(skillsDir, { withFileTypes: true });
+    const skillsDir = (0, import_node_path5.join)(pluginDir, "skills");
+    if (!(0, import_node_fs4.existsSync)(skillsDir)) return [];
+    const entries = (0, import_node_fs4.readdirSync)(skillsDir, { withFileTypes: true });
     const skills = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const skillFile = (0, import_node_path3.join)(skillsDir, entry.name, "SKILL.md");
-      if (!(0, import_node_fs2.existsSync)(skillFile)) continue;
-      const raw = (0, import_node_fs2.readFileSync)(skillFile, "utf-8");
+      const skillFile = (0, import_node_path5.join)(skillsDir, entry.name, "SKILL.md");
+      if (!(0, import_node_fs4.existsSync)(skillFile)) continue;
+      const raw = (0, import_node_fs4.readFileSync)(skillFile, "utf-8");
       const { metadata, content } = parseSkillFrontmatter(raw);
       const description = typeof metadata.description === "string" ? metadata.description : "";
       const skill = {
@@ -1070,13 +1443,13 @@ var BundlePluginLoader = class {
   }
   /** Load commands from the plugin's commands/ directory (flat .md files). */
   loadCommands(pluginDir, pluginName) {
-    const commandsDir = (0, import_node_path3.join)(pluginDir, "commands");
-    if (!(0, import_node_fs2.existsSync)(commandsDir)) return [];
-    const entries = (0, import_node_fs2.readdirSync)(commandsDir, { withFileTypes: true });
+    const commandsDir = (0, import_node_path5.join)(pluginDir, "commands");
+    if (!(0, import_node_fs4.existsSync)(commandsDir)) return [];
+    const entries = (0, import_node_fs4.readdirSync)(commandsDir, { withFileTypes: true });
     const commands = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const raw = (0, import_node_fs2.readFileSync)((0, import_node_path3.join)(commandsDir, entry.name), "utf-8");
+      const raw = (0, import_node_fs4.readFileSync)((0, import_node_path5.join)(commandsDir, entry.name), "utf-8");
       const { metadata, content } = parseSkillFrontmatter(raw);
       const name = typeof metadata.name === "string" ? metadata.name : entry.name.replace(/\.md$/, "");
       const description = typeof metadata.description === "string" ? metadata.description : "";
@@ -1091,10 +1464,10 @@ var BundlePluginLoader = class {
   }
   /** Load hooks from hooks/hooks.json if present. */
   loadHooks(pluginDir) {
-    const hooksPath = (0, import_node_path3.join)(pluginDir, "hooks", "hooks.json");
-    if (!(0, import_node_fs2.existsSync)(hooksPath)) return {};
+    const hooksPath = (0, import_node_path5.join)(pluginDir, "hooks", "hooks.json");
+    if (!(0, import_node_fs4.existsSync)(hooksPath)) return {};
     try {
-      const raw = (0, import_node_fs2.readFileSync)(hooksPath, "utf-8");
+      const raw = (0, import_node_fs4.readFileSync)(hooksPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data === "object" && data !== null) {
         return data;
@@ -1106,12 +1479,12 @@ var BundlePluginLoader = class {
   }
   /** Load MCP server configuration if present. Checks `.mcp.json` at plugin root first. */
   loadMcpConfig(pluginDir) {
-    const primaryPath = (0, import_node_path3.join)(pluginDir, ".mcp.json");
-    const fallbackPath = (0, import_node_path3.join)(pluginDir, ".claude-plugin", "mcp.json");
-    const mcpPath = (0, import_node_fs2.existsSync)(primaryPath) ? primaryPath : fallbackPath;
-    if (!(0, import_node_fs2.existsSync)(mcpPath)) return void 0;
+    const primaryPath = (0, import_node_path5.join)(pluginDir, ".mcp.json");
+    const fallbackPath = (0, import_node_path5.join)(pluginDir, ".claude-plugin", "mcp.json");
+    const mcpPath = (0, import_node_fs4.existsSync)(primaryPath) ? primaryPath : fallbackPath;
+    if (!(0, import_node_fs4.existsSync)(mcpPath)) return void 0;
     try {
-      const raw = (0, import_node_fs2.readFileSync)(mcpPath, "utf-8");
+      const raw = (0, import_node_fs4.readFileSync)(mcpPath, "utf-8");
       return JSON.parse(raw);
     } catch {
       return void 0;
@@ -1119,10 +1492,10 @@ var BundlePluginLoader = class {
   }
   /** Load agent definitions from agents/ directory if present. */
   loadAgents(pluginDir) {
-    const agentsDir = (0, import_node_path3.join)(pluginDir, "agents");
-    if (!(0, import_node_fs2.existsSync)(agentsDir)) return [];
+    const agentsDir = (0, import_node_path5.join)(pluginDir, "agents");
+    if (!(0, import_node_fs4.existsSync)(agentsDir)) return [];
     try {
-      const entries = (0, import_node_fs2.readdirSync)(agentsDir, { withFileTypes: true });
+      const entries = (0, import_node_fs4.readdirSync)(agentsDir, { withFileTypes: true });
       return entries.filter((e) => e.isDirectory() || e.name.endsWith(".md")).map((e) => e.name.replace(/\.md$/, ""));
     } catch {
       return [];
@@ -1132,8 +1505,8 @@ var BundlePluginLoader = class {
 
 // src/plugins/bundle-plugin-installer.ts
 var import_node_child_process = require("child_process");
-var import_node_fs3 = require("fs");
-var import_node_path4 = require("path");
+var import_node_fs5 = require("fs");
+var import_node_path6 = require("path");
 var GIT_CLONE_TIMEOUT_MS = 6e4;
 var BundlePluginInstaller = class {
   pluginsDir;
@@ -1144,8 +1517,8 @@ var BundlePluginInstaller = class {
   exec;
   constructor(options) {
     this.pluginsDir = options.pluginsDir;
-    this.cacheDir = (0, import_node_path4.join)(this.pluginsDir, "cache");
-    this.registryPath = (0, import_node_path4.join)(this.pluginsDir, "installed_plugins.json");
+    this.cacheDir = (0, import_node_path6.join)(this.pluginsDir, "cache");
+    this.registryPath = (0, import_node_path6.join)(this.pluginsDir, "installed_plugins.json");
     this.settingsStore = options.settingsStore;
     this.marketplaceClient = options.marketplaceClient;
     this.exec = options.exec ?? this.defaultExec;
@@ -1165,8 +1538,8 @@ var BundlePluginInstaller = class {
       throw new Error(`Plugin "${pluginName}" not found in marketplace "${marketplaceName}"`);
     }
     const version = this.resolveVersion(entry, marketplaceName);
-    const targetDir = (0, import_node_path4.join)(this.cacheDir, marketplaceName, pluginName, version);
-    if ((0, import_node_fs3.existsSync)(targetDir)) {
+    const targetDir = (0, import_node_path6.join)(this.cacheDir, marketplaceName, pluginName, version);
+    if ((0, import_node_fs5.existsSync)(targetDir)) {
       throw new Error(
         `Plugin "${pluginName}" version "${version}" is already installed from "${marketplaceName}"`
       );
@@ -1193,8 +1566,8 @@ var BundlePluginInstaller = class {
     if (!record) {
       throw new Error(`Plugin "${pluginId}" is not installed`);
     }
-    if ((0, import_node_fs3.existsSync)(record.installPath)) {
-      (0, import_node_fs3.rmSync)(record.installPath, { recursive: true, force: true });
+    if ((0, import_node_fs5.existsSync)(record.installPath)) {
+      (0, import_node_fs5.rmSync)(record.installPath, { recursive: true, force: true });
     }
     delete registry[pluginId];
     this.writeRegistry(registry);
@@ -1240,18 +1613,18 @@ var BundlePluginInstaller = class {
   }
   /** Resolve the source and install the plugin. */
   resolveAndInstall(rawSource, marketplaceName, pluginName, targetDir) {
-    (0, import_node_fs3.mkdirSync)(targetDir, { recursive: true });
+    (0, import_node_fs5.mkdirSync)(targetDir, { recursive: true });
     const source = this.normalizeSource(rawSource);
     try {
       if (typeof source === "string") {
         const marketplaceDir = this.marketplaceClient.getMarketplaceDir(marketplaceName);
-        const sourcePath = (0, import_node_path4.join)(marketplaceDir, source);
-        if (!(0, import_node_fs3.existsSync)(sourcePath)) {
+        const sourcePath = (0, import_node_path6.join)(marketplaceDir, source);
+        if (!(0, import_node_fs5.existsSync)(sourcePath)) {
           throw new Error(
             `Plugin source path "${source}" not found in marketplace "${marketplaceName}"`
           );
         }
-        (0, import_node_fs3.cpSync)(sourcePath, targetDir, { recursive: true });
+        (0, import_node_fs5.cpSync)(sourcePath, targetDir, { recursive: true });
       } else if (source.type === "github") {
         const repoUrl = `https://github.com/${source.repo}.git`;
         this.cloneToDir(repoUrl, targetDir, pluginName);
@@ -1263,15 +1636,15 @@ var BundlePluginInstaller = class {
         throw new Error(`Unknown source type: ${JSON.stringify(source)}`);
       }
     } catch (err) {
-      if ((0, import_node_fs3.existsSync)(targetDir)) {
-        (0, import_node_fs3.rmSync)(targetDir, { recursive: true, force: true });
+      if ((0, import_node_fs5.existsSync)(targetDir)) {
+        (0, import_node_fs5.rmSync)(targetDir, { recursive: true, force: true });
       }
       throw err;
     }
   }
   /** Clone a git repository to the target directory. */
   cloneToDir(repoUrl, targetDir, pluginName) {
-    (0, import_node_fs3.rmSync)(targetDir, { recursive: true, force: true });
+    (0, import_node_fs5.rmSync)(targetDir, { recursive: true, force: true });
     const command = `git clone --depth 1 ${repoUrl} ${targetDir}`;
     try {
       this.exec(command, { timeout: GIT_CLONE_TIMEOUT_MS, stdio: "pipe" });
@@ -1282,11 +1655,11 @@ var BundlePluginInstaller = class {
   }
   /** Read the installed_plugins.json registry. */
   readRegistry() {
-    if (!(0, import_node_fs3.existsSync)(this.registryPath)) {
+    if (!(0, import_node_fs5.existsSync)(this.registryPath)) {
       return {};
     }
     try {
-      const raw = (0, import_node_fs3.readFileSync)(this.registryPath, "utf-8");
+      const raw = (0, import_node_fs5.readFileSync)(this.registryPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data === "object" && data !== null) {
         return data;
@@ -1298,11 +1671,11 @@ var BundlePluginInstaller = class {
   }
   /** Write the installed_plugins.json registry. */
   writeRegistry(registry) {
-    const dir = (0, import_node_path4.dirname)(this.registryPath);
-    if (!(0, import_node_fs3.existsSync)(dir)) {
-      (0, import_node_fs3.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_node_path6.dirname)(this.registryPath);
+    if (!(0, import_node_fs5.existsSync)(dir)) {
+      (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
     }
-    (0, import_node_fs3.writeFileSync)(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
+    (0, import_node_fs5.writeFileSync)(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
   }
   /** Default exec implementation using child_process. */
   defaultExec(command, options) {
@@ -1312,8 +1685,8 @@ var BundlePluginInstaller = class {
 
 // src/plugins/marketplace-client.ts
 var import_node_child_process2 = require("child_process");
-var import_node_fs4 = require("fs");
-var import_node_path5 = require("path");
+var import_node_fs6 = require("fs");
+var import_node_path7 = require("path");
 var GIT_TIMEOUT_MS = 6e4;
 var MarketplaceClient = class {
   pluginsDir;
@@ -1323,8 +1696,8 @@ var MarketplaceClient = class {
   constructor(options) {
     this.pluginsDir = options.pluginsDir;
     this.exec = options.exec ?? this.defaultExec;
-    this.marketplacesDir = (0, import_node_path5.join)(this.pluginsDir, "marketplaces");
-    this.registryPath = (0, import_node_path5.join)(this.pluginsDir, "known_marketplaces.json");
+    this.marketplacesDir = (0, import_node_path7.join)(this.pluginsDir, "marketplaces");
+    this.registryPath = (0, import_node_path7.join)(this.pluginsDir, "known_marketplaces.json");
   }
   /**
    * Add a marketplace by cloning its repository.
@@ -1338,13 +1711,13 @@ var MarketplaceClient = class {
    */
   addMarketplace(source) {
     const tempName = "temp-" + Date.now().toString(36);
-    const tempDir = (0, import_node_path5.join)(this.marketplacesDir, tempName);
-    (0, import_node_fs4.mkdirSync)(this.marketplacesDir, { recursive: true });
+    const tempDir = (0, import_node_path7.join)(this.marketplacesDir, tempName);
+    (0, import_node_fs6.mkdirSync)(this.marketplacesDir, { recursive: true });
     if (source.type === "local") {
-      if (!(0, import_node_fs4.existsSync)(source.path)) {
+      if (!(0, import_node_fs6.existsSync)(source.path)) {
         throw new Error(`Local marketplace path does not exist: ${source.path}`);
       }
-      (0, import_node_fs4.cpSync)(source.path, tempDir, { recursive: true });
+      (0, import_node_fs6.cpSync)(source.path, tempDir, { recursive: true });
     } else {
       const cloneUrl = this.resolveCloneUrl(source);
       const command = `git clone --depth 1 ${cloneUrl} ${tempDir}`;
@@ -1355,9 +1728,9 @@ var MarketplaceClient = class {
         throw new Error(`Failed to clone marketplace: ${message}`);
       }
     }
-    const manifestPath = (0, import_node_path5.join)(tempDir, ".claude-plugin", "marketplace.json");
-    if (!(0, import_node_fs4.existsSync)(manifestPath)) {
-      (0, import_node_fs4.rmSync)(tempDir, { recursive: true, force: true });
+    const manifestPath = (0, import_node_path7.join)(tempDir, ".claude-plugin", "marketplace.json");
+    if (!(0, import_node_fs6.existsSync)(manifestPath)) {
+      (0, import_node_fs6.rmSync)(tempDir, { recursive: true, force: true });
       throw new Error(
         source.type === "local" ? "Local directory does not contain .claude-plugin/marketplace.json" : "Cloned repository does not contain .claude-plugin/marketplace.json"
       );
@@ -1365,16 +1738,16 @@ var MarketplaceClient = class {
     const manifest = this.readManifestFromPath(manifestPath);
     const name = manifest.name;
     if (!name) {
-      (0, import_node_fs4.rmSync)(tempDir, { recursive: true, force: true });
+      (0, import_node_fs6.rmSync)(tempDir, { recursive: true, force: true });
       throw new Error('Marketplace manifest does not contain a "name" field');
     }
     const registry = this.readRegistry();
     if (registry[name]) {
-      (0, import_node_fs4.rmSync)(tempDir, { recursive: true, force: true });
+      (0, import_node_fs6.rmSync)(tempDir, { recursive: true, force: true });
       throw new Error(`Marketplace "${name}" already exists`);
     }
-    const finalDir = (0, import_node_path5.join)(this.marketplacesDir, name);
-    (0, import_node_fs4.renameSync)(tempDir, finalDir);
+    const finalDir = (0, import_node_path7.join)(this.marketplacesDir, name);
+    (0, import_node_fs6.renameSync)(tempDir, finalDir);
     registry[name] = {
       source,
       installLocation: finalDir,
@@ -1395,8 +1768,8 @@ var MarketplaceClient = class {
       throw new Error(`Marketplace "${name}" not found`);
     }
     this.removeInstalledPluginsForMarketplace(name);
-    if ((0, import_node_fs4.existsSync)(entry.installLocation)) {
-      (0, import_node_fs4.rmSync)(entry.installLocation, { recursive: true, force: true });
+    if ((0, import_node_fs6.existsSync)(entry.installLocation)) {
+      (0, import_node_fs6.rmSync)(entry.installLocation, { recursive: true, force: true });
     }
     delete registry[name];
     this.writeRegistry(registry);
@@ -1415,16 +1788,16 @@ var MarketplaceClient = class {
     if (!entry) {
       throw new Error(`Marketplace "${name}" not found`);
     }
-    if (!(0, import_node_fs4.existsSync)(entry.installLocation)) {
+    if (!(0, import_node_fs6.existsSync)(entry.installLocation)) {
       throw new Error(`Marketplace directory for "${name}" does not exist`);
     }
     if (entry.source.type === "local") {
       const localSource = entry.source;
-      if (!(0, import_node_fs4.existsSync)(localSource.path)) {
+      if (!(0, import_node_fs6.existsSync)(localSource.path)) {
         throw new Error(`Local marketplace path does not exist: ${localSource.path}`);
       }
-      (0, import_node_fs4.rmSync)(entry.installLocation, { recursive: true, force: true });
-      (0, import_node_fs4.cpSync)(localSource.path, entry.installLocation, { recursive: true });
+      (0, import_node_fs6.rmSync)(entry.installLocation, { recursive: true, force: true });
+      (0, import_node_fs6.cpSync)(localSource.path, entry.installLocation, { recursive: true });
     } else {
       const command = `git -C ${entry.installLocation} pull`;
       try {
@@ -1455,8 +1828,8 @@ var MarketplaceClient = class {
     if (!entry) {
       throw new Error(`Marketplace "${marketplaceName}" not found`);
     }
-    const manifestPath = (0, import_node_path5.join)(entry.installLocation, ".claude-plugin", "marketplace.json");
-    if (!(0, import_node_fs4.existsSync)(manifestPath)) {
+    const manifestPath = (0, import_node_path7.join)(entry.installLocation, ".claude-plugin", "marketplace.json");
+    if (!(0, import_node_fs6.existsSync)(manifestPath)) {
       throw new Error(
         `Marketplace "${marketplaceName}" does not contain .claude-plugin/marketplace.json`
       );
@@ -1523,11 +1896,11 @@ var MarketplaceClient = class {
    * and updates the registry.
    */
   removeInstalledPluginsForMarketplace(marketplaceName) {
-    const installedPath = (0, import_node_path5.join)(this.pluginsDir, "installed_plugins.json");
-    if (!(0, import_node_fs4.existsSync)(installedPath)) return;
+    const installedPath = (0, import_node_path7.join)(this.pluginsDir, "installed_plugins.json");
+    if (!(0, import_node_fs6.existsSync)(installedPath)) return;
     let registry;
     try {
-      const raw = (0, import_node_fs4.readFileSync)(installedPath, "utf-8");
+      const raw = (0, import_node_fs6.readFileSync)(installedPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data !== "object" || data === null) return;
       registry = data;
@@ -1537,24 +1910,24 @@ var MarketplaceClient = class {
     let changed = false;
     for (const [pluginId, record] of Object.entries(registry)) {
       if (record.marketplace === marketplaceName) {
-        if (record.installPath && (0, import_node_fs4.existsSync)(record.installPath)) {
-          (0, import_node_fs4.rmSync)(record.installPath, { recursive: true, force: true });
+        if (record.installPath && (0, import_node_fs6.existsSync)(record.installPath)) {
+          (0, import_node_fs6.rmSync)(record.installPath, { recursive: true, force: true });
         }
         delete registry[pluginId];
         changed = true;
       }
     }
     if (changed) {
-      const dir = (0, import_node_path5.dirname)(installedPath);
-      if (!(0, import_node_fs4.existsSync)(dir)) {
-        (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+      const dir = (0, import_node_path7.dirname)(installedPath);
+      if (!(0, import_node_fs6.existsSync)(dir)) {
+        (0, import_node_fs6.mkdirSync)(dir, { recursive: true });
       }
-      (0, import_node_fs4.writeFileSync)(installedPath, JSON.stringify(registry, null, 2), "utf-8");
+      (0, import_node_fs6.writeFileSync)(installedPath, JSON.stringify(registry, null, 2), "utf-8");
     }
   }
   /** Read and parse a marketplace.json from a file path. */
   readManifestFromPath(path) {
-    const raw = (0, import_node_fs4.readFileSync)(path, "utf-8");
+    const raw = (0, import_node_fs6.readFileSync)(path, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data !== "object" || data === null) {
       throw new Error("Invalid marketplace manifest: not an object");
@@ -1567,11 +1940,11 @@ var MarketplaceClient = class {
   }
   /** Read the known_marketplaces.json registry. */
   readRegistry() {
-    if (!(0, import_node_fs4.existsSync)(this.registryPath)) {
+    if (!(0, import_node_fs6.existsSync)(this.registryPath)) {
       return {};
     }
     try {
-      const raw = (0, import_node_fs4.readFileSync)(this.registryPath, "utf-8");
+      const raw = (0, import_node_fs6.readFileSync)(this.registryPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data === "object" && data !== null) {
         return data;
@@ -1583,11 +1956,11 @@ var MarketplaceClient = class {
   }
   /** Write the known_marketplaces.json registry. */
   writeRegistry(registry) {
-    const dir = (0, import_node_path5.dirname)(this.registryPath);
-    if (!(0, import_node_fs4.existsSync)(dir)) {
-      (0, import_node_fs4.mkdirSync)(dir, { recursive: true });
+    const dir = (0, import_node_path7.dirname)(this.registryPath);
+    if (!(0, import_node_fs6.existsSync)(dir)) {
+      (0, import_node_fs6.mkdirSync)(dir, { recursive: true });
     }
-    (0, import_node_fs4.writeFileSync)(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
+    (0, import_node_fs6.writeFileSync)(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
   }
   /** Default exec implementation using child_process. */
   defaultExec(command, options) {
@@ -1595,78 +1968,6 @@ var MarketplaceClient = class {
   }
 };
 
-// src/tools/agent-tool.ts
-var import_zod2 = require("zod");
-var import_agent_tools2 = require("@robota-sdk/agent-tools");
-function asZodSchema(schema) {
-  return schema;
-}
-var AgentSchema = import_zod2.z.object({
-  prompt: import_zod2.z.string().describe("Task description for the sub-agent"),
-  description: import_zod2.z.string().optional().describe("Short description of what the sub-agent will do (3-5 words)")
-});
-var agentToolDeps;
-function setAgentToolDeps(deps) {
-  agentToolDeps = deps;
-}
-async function runAgent(args) {
-  if (!agentToolDeps) {
-    const result = {
-      success: false,
-      output: "",
-      error: "Agent tool not initialized \u2014 missing dependencies"
-    };
-    return JSON.stringify(result);
-  }
-  const noopTerminal = {
-    write: () => {
-    },
-    writeLine: () => {
-    },
-    writeMarkdown: () => {
-    },
-    writeError: () => {
-    },
-    prompt: () => Promise.resolve(""),
-    select: () => Promise.resolve(0),
-    spinner: () => ({ stop: () => {
-    }, update: () => {
-    } })
-  };
-  const subSession = createSession({
-    config: agentToolDeps.config,
-    context: agentToolDeps.context,
-    projectInfo: agentToolDeps.projectInfo,
-    terminal: noopTerminal,
-    // Sub-agents bypass permissions — they inherit parent's trust
-    permissionMode: "bypassPermissions"
-  });
-  try {
-    const response = await subSession.run(args.prompt);
-    const result = {
-      success: true,
-      output: response
-    };
-    return JSON.stringify(result);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    const result = {
-      success: false,
-      output: "",
-      error: `Sub-agent error: ${message}`
-    };
-    return JSON.stringify(result);
-  }
-}
-var agentTool = (0, import_agent_tools2.createZodFunctionTool)(
-  "Agent",
-  "Spawn a sub-agent with isolated context to handle a task. The sub-agent has its own conversation history and can use all tools.",
-  asZodSchema(AgentSchema),
-  async (params) => {
-    return runAgent(params);
-  }
-);
-
 // src/index.ts
 var import_agent_tools3 = require("@robota-sdk/agent-tools");
 var import_agent_tools4 = require("@robota-sdk/agent-tools");
@@ -1677,6 +1978,7 @@ var import_agent_tools8 = require("@robota-sdk/agent-tools");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AgentExecutor,
+  BUILT_IN_AGENTS,
   BundlePluginInstaller,
   BundlePluginLoader,
   DEFAULT_TOOL_DESCRIPTIONS,
@@ -1688,15 +1990,21 @@ var import_agent_tools8 = require("@robota-sdk/agent-tools");
   SessionStore,
   SilentSessionLogger,
   TRUST_TO_MODE,
-  agentTool,
+  assembleSubagentPrompt,
   bashTool,
   buildSystemPrompt,
+  createAgentTool,
   createDefaultTools,
   createProvider,
   createSession,
+  createSubagentLogger,
+  createSubagentSession,
   detectProject,
   editTool,
   evaluatePermission,
+  getBuiltInAgent,
+  getForkWorkerSuffix,
+  getSubagentSuffix,
   globTool,
   grepTool,
   loadConfig,
@@ -1705,8 +2013,10 @@ var import_agent_tools8 = require("@robota-sdk/agent-tools");
   promptForApproval,
   query,
   readTool,
+  resolveSubagentLogDir,
+  retrieveAgentToolDeps,
   runHooks,
-  setAgentToolDeps,
+  storeAgentToolDeps,
   userPaths,
   writeTool
 });