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

package/dist/node/index.js

@@ -109,7 +109,7 @@ Respond with JSON: { "ok": boolean, "reason"?: string }`;
 };
 
 // src/assembly/create-session.ts
-import { Session } from "@robota-sdk/agent-sessions";
+import { Session as Session2 } from "@robota-sdk/agent-sessions";
 
 // src/context/system-prompt-builder.ts
 var TRUST_LEVEL_DESCRIPTIONS = {
@@ -251,11 +251,379 @@ function createProvider(config) {
   return new AnthropicProvider({ apiKey });
 }
 
+// src/tools/agent-tool.ts
+import { z } from "zod";
+import { createZodFunctionTool } from "@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
+import { Session } from "@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 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 = z.object({
+  prompt: z.string().describe("The task for the subagent to perform"),
+  subagent_type: z.string().optional().describe('Agent type: "general-purpose", "Explore", "Plan", or a custom agent name'),
+  model: 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 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
+import { readdirSync, readFileSync, existsSync } from "fs";
+import { join, basename } from "path";
+import { homedir } from "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 (!existsSync(dir)) return [];
+  const agents = [];
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+    const filePath = join(dir, entry.name);
+    const content = readFileSync(filePath, "utf-8");
+    const { frontmatter, body } = parseFrontmatter(content);
+    const fallbackName = 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 ?? homedir();
+  }
+  /** Load all agent definitions, merged with built-in agents. Custom overrides built-in on name collision. */
+  loadAll() {
+    const sources = [
+      scanAgentsDir(join(this.cwd, ".claude", "agents")),
+      scanAgentsDir(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,
@@ -278,26 +646,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 Session({
+  const session = new Session2({
     tools,
     provider,
     systemMessage,
@@ -318,89 +667,104 @@ function createSession(options) {
     sessionLogger: options.sessionLogger,
     hookTypeExecutors: hookTypeExecutors.length > 0 ? hookTypeExecutors : void 0
   });
+  storeAgentToolDeps(session, agentToolDeps);
+  return session;
+}
+
+// src/assembly/subagent-logger.ts
+import { mkdirSync } from "fs";
+import { join as join2 } from "path";
+import { FileSessionLogger } from "@robota-sdk/agent-sessions";
+function createSubagentLogger(parentSessionId, _agentId, baseLogsDir) {
+  const subagentDir = join2(baseLogsDir, parentSessionId, "subagents");
+  mkdirSync(subagentDir, { recursive: true });
+  return new FileSessionLogger(subagentDir);
+}
+function resolveSubagentLogDir(parentSessionId, baseLogsDir) {
+  return join2(baseLogsDir, parentSessionId, "subagents");
 }
 
 // src/index.ts
-import { Session as Session2 } from "@robota-sdk/agent-sessions";
-import { FileSessionLogger, SilentSessionLogger } from "@robota-sdk/agent-sessions";
+import { Session as Session3 } from "@robota-sdk/agent-sessions";
+import { FileSessionLogger as FileSessionLogger2, SilentSessionLogger } from "@robota-sdk/agent-sessions";
 import { SessionStore } from "@robota-sdk/agent-sessions";
 
 // src/config/config-loader.ts
-import { readFileSync, existsSync } from "fs";
-import { join } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join3 } from "path";
 
 // src/config/config-types.ts
-import { z } from "zod";
-var ProviderSchema = z.object({
-  name: z.string().optional(),
-  model: z.string().optional(),
-  apiKey: z.string().optional()
+import { z as z2 } from "zod";
+var ProviderSchema = z2.object({
+  name: z2.string().optional(),
+  model: z2.string().optional(),
+  apiKey: z2.string().optional()
 });
-var PermissionsSchema = z.object({
+var PermissionsSchema = z2.object({
   /** Patterns that are always approved without prompting */
-  allow: z.array(z.string()).optional(),
+  allow: z2.array(z2.string()).optional(),
   /** Patterns that are always denied */
-  deny: z.array(z.string()).optional()
+  deny: z2.array(z2.string()).optional()
 });
-var EnvSchema = z.record(z.string()).optional();
-var CommandHookDefinitionSchema = z.object({
-  type: z.literal("command"),
-  command: z.string(),
-  timeout: z.number().optional()
+var EnvSchema = z2.record(z2.string()).optional();
+var CommandHookDefinitionSchema = z2.object({
+  type: z2.literal("command"),
+  command: z2.string(),
+  timeout: z2.number().optional()
 });
-var HttpHookDefinitionSchema = z.object({
-  type: z.literal("http"),
-  url: z.string(),
-  headers: z.record(z.string()).optional(),
-  timeout: z.number().optional()
+var HttpHookDefinitionSchema = z2.object({
+  type: z2.literal("http"),
+  url: z2.string(),
+  headers: z2.record(z2.string()).optional(),
+  timeout: z2.number().optional()
 });
-var PromptHookDefinitionSchema = z.object({
-  type: z.literal("prompt"),
-  prompt: z.string(),
-  model: z.string().optional()
+var PromptHookDefinitionSchema = z2.object({
+  type: z2.literal("prompt"),
+  prompt: z2.string(),
+  model: z2.string().optional()
 });
-var AgentHookDefinitionSchema = z.object({
-  type: z.literal("agent"),
-  agent: z.string(),
-  maxTurns: z.number().optional(),
-  timeout: z.number().optional()
+var AgentHookDefinitionSchema = z2.object({
+  type: z2.literal("agent"),
+  agent: z2.string(),
+  maxTurns: z2.number().optional(),
+  timeout: z2.number().optional()
 });
-var HookDefinitionSchema = z.discriminatedUnion("type", [
+var HookDefinitionSchema = z2.discriminatedUnion("type", [
   CommandHookDefinitionSchema,
   HttpHookDefinitionSchema,
   PromptHookDefinitionSchema,
   AgentHookDefinitionSchema
 ]);
-var HookGroupSchema = z.object({
-  matcher: z.string(),
-  hooks: z.array(HookDefinitionSchema)
+var HookGroupSchema = z2.object({
+  matcher: z2.string(),
+  hooks: z2.array(HookDefinitionSchema)
 });
-var HooksSchema = z.object({
-  PreToolUse: z.array(HookGroupSchema).optional(),
-  PostToolUse: z.array(HookGroupSchema).optional(),
-  SessionStart: z.array(HookGroupSchema).optional(),
-  Stop: z.array(HookGroupSchema).optional(),
-  PreCompact: z.array(HookGroupSchema).optional(),
-  PostCompact: z.array(HookGroupSchema).optional(),
-  UserPromptSubmit: z.array(HookGroupSchema).optional(),
-  Notification: z.array(HookGroupSchema).optional()
+var HooksSchema = z2.object({
+  PreToolUse: z2.array(HookGroupSchema).optional(),
+  PostToolUse: z2.array(HookGroupSchema).optional(),
+  SessionStart: z2.array(HookGroupSchema).optional(),
+  Stop: z2.array(HookGroupSchema).optional(),
+  PreCompact: z2.array(HookGroupSchema).optional(),
+  PostCompact: z2.array(HookGroupSchema).optional(),
+  UserPromptSubmit: z2.array(HookGroupSchema).optional(),
+  Notification: z2.array(HookGroupSchema).optional()
 }).optional();
-var EnabledPluginsSchema = z.record(z.boolean()).optional();
-var MarketplaceSourceSchema = z.object({
-  source: z.object({
-    type: z.enum(["github", "git", "local", "url"]),
-    repo: z.string().optional(),
-    url: z.string().optional(),
-    path: z.string().optional(),
-    ref: z.string().optional()
+var EnabledPluginsSchema = z2.record(z2.boolean()).optional();
+var MarketplaceSourceSchema = z2.object({
+  source: z2.object({
+    type: z2.enum(["github", "git", "local", "url"]),
+    repo: z2.string().optional(),
+    url: z2.string().optional(),
+    path: z2.string().optional(),
+    ref: z2.string().optional()
   })
 });
-var ExtraKnownMarketplacesSchema = z.record(MarketplaceSourceSchema).optional();
-var SettingsSchema = z.object({
+var ExtraKnownMarketplacesSchema = z2.record(MarketplaceSourceSchema).optional();
+var SettingsSchema = z2.object({
   /** Trust level used when no --permission-mode flag is given */
-  defaultTrustLevel: z.enum(["safe", "moderate", "full"]).optional(),
+  defaultTrustLevel: z2.enum(["safe", "moderate", "full"]).optional(),
   /** Response language (e.g., "ko", "en", "ja"). Injected into system prompt. */
-  language: z.string().optional(),
+  language: z2.string().optional(),
   provider: ProviderSchema.optional(),
   permissions: PermissionsSchema.optional(),
   env: EnvSchema,
@@ -429,10 +793,10 @@ var DEFAULTS = {
   env: {}
 };
 function readJsonFile(filePath) {
-  if (!existsSync(filePath)) {
+  if (!existsSync2(filePath)) {
     return void 0;
   }
-  const raw = readFileSync(filePath, "utf-8").trim();
+  const raw = readFileSync2(filePath, "utf-8").trim();
   if (raw.length === 0) {
     return void 0;
   }
@@ -503,15 +867,15 @@ function toResolvedConfig(merged) {
 function getSettingsPaths(cwd) {
   const home = getHomeDir();
   return [
-    join(home, ".robota", "settings.json"),
+    join3(home, ".robota", "settings.json"),
     // 1. user (lowest)
-    join(cwd, ".robota", "settings.json"),
+    join3(cwd, ".robota", "settings.json"),
     // 2. project
-    join(cwd, ".robota", "settings.local.json"),
+    join3(cwd, ".robota", "settings.local.json"),
     // 3. project-local
-    join(cwd, ".claude", "settings.json"),
+    join3(cwd, ".claude", "settings.json"),
     // 4. project, Claude Code compat
-    join(cwd, ".claude", "settings.local.json")
+    join3(cwd, ".claude", "settings.local.json")
     // 5. project-local (highest)
   ];
 }
@@ -536,8 +900,8 @@ async function loadConfig(cwd) {
 }
 
 // src/context/context-loader.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { join as join2, dirname, resolve } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join4, dirname, resolve } from "path";
 var AGENTS_FILENAME = "AGENTS.md";
 var CLAUDE_FILENAME = "CLAUDE.md";
 function collectFilesWalkingUp(startDir, filename) {
@@ -545,8 +909,8 @@ function collectFilesWalkingUp(startDir, filename) {
   let current = resolve(startDir);
   let atRoot = false;
   while (!atRoot) {
-    const candidate = join2(current, filename);
-    if (existsSync2(candidate)) {
+    const candidate = join4(current, filename);
+    if (existsSync3(candidate)) {
       found.push(candidate);
     }
     const parent = dirname(current);
@@ -584,47 +948,47 @@ function extractCompactInstructions(content) {
 async function loadContext(cwd) {
   const agentsPaths = collectFilesWalkingUp(cwd, AGENTS_FILENAME);
   const claudePaths = collectFilesWalkingUp(cwd, CLAUDE_FILENAME);
-  const agentsMd = agentsPaths.map((p) => readFileSync2(p, "utf-8")).join("\n\n");
-  const claudeMd = claudePaths.map((p) => readFileSync2(p, "utf-8")).join("\n\n");
+  const agentsMd = agentsPaths.map((p) => readFileSync3(p, "utf-8")).join("\n\n");
+  const claudeMd = claudePaths.map((p) => readFileSync3(p, "utf-8")).join("\n\n");
   const compactInstructions = extractCompactInstructions(claudeMd);
   return { agentsMd, claudeMd, compactInstructions };
 }
 
 // src/context/project-detector.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { join as join5 } from "path";
 function tryReadJson(filePath) {
-  if (!existsSync3(filePath)) return void 0;
+  if (!existsSync4(filePath)) return void 0;
   try {
-    return JSON.parse(readFileSync3(filePath, "utf-8"));
+    return JSON.parse(readFileSync4(filePath, "utf-8"));
   } catch {
     return void 0;
   }
 }
 function detectPackageManager(cwd) {
-  if (existsSync3(join3(cwd, "pnpm-workspace.yaml")) || existsSync3(join3(cwd, "pnpm-lock.yaml"))) {
+  if (existsSync4(join5(cwd, "pnpm-workspace.yaml")) || existsSync4(join5(cwd, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (existsSync3(join3(cwd, "yarn.lock"))) {
+  if (existsSync4(join5(cwd, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync3(join3(cwd, "bun.lockb"))) {
+  if (existsSync4(join5(cwd, "bun.lockb"))) {
     return "bun";
   }
-  if (existsSync3(join3(cwd, "package-lock.json"))) {
+  if (existsSync4(join5(cwd, "package-lock.json"))) {
     return "npm";
   }
   return void 0;
 }
 async function detectProject(cwd) {
-  const pkgJsonPath = join3(cwd, "package.json");
-  const tsconfigPath = join3(cwd, "tsconfig.json");
-  const pyprojectPath = join3(cwd, "pyproject.toml");
-  const cargoPath = join3(cwd, "Cargo.toml");
-  const goModPath = join3(cwd, "go.mod");
-  if (existsSync3(pkgJsonPath)) {
+  const pkgJsonPath = join5(cwd, "package.json");
+  const tsconfigPath = join5(cwd, "tsconfig.json");
+  const pyprojectPath = join5(cwd, "pyproject.toml");
+  const cargoPath = join5(cwd, "Cargo.toml");
+  const goModPath = join5(cwd, "go.mod");
+  if (existsSync4(pkgJsonPath)) {
     const pkgJson = tryReadJson(pkgJsonPath);
-    const language = existsSync3(tsconfigPath) ? "typescript" : "javascript";
+    const language = existsSync4(tsconfigPath) ? "typescript" : "javascript";
     const packageManager = detectPackageManager(cwd);
     return {
       type: "node",
@@ -633,19 +997,19 @@ async function detectProject(cwd) {
       language
     };
   }
-  if (existsSync3(pyprojectPath) || existsSync3(join3(cwd, "setup.py"))) {
+  if (existsSync4(pyprojectPath) || existsSync4(join5(cwd, "setup.py"))) {
     return {
       type: "python",
       language: "python"
     };
   }
-  if (existsSync3(cargoPath)) {
+  if (existsSync4(cargoPath)) {
     return {
       type: "rust",
       language: "rust"
     };
   }
-  if (existsSync3(goModPath)) {
+  if (existsSync4(goModPath)) {
     return {
       type: "go",
       language: "go"
@@ -722,27 +1086,27 @@ import { evaluatePermission } from "@robota-sdk/agent-core";
 import { runHooks } from "@robota-sdk/agent-core";
 
 // src/paths.ts
-import { join as join4 } from "path";
-import { homedir } from "os";
+import { join as join6 } from "path";
+import { homedir as homedir2 } from "os";
 function projectPaths(cwd) {
-  const base = join4(cwd, ".robota");
+  const base = join6(cwd, ".robota");
   return {
-    settings: join4(base, "settings.json"),
-    settingsLocal: join4(base, "settings.local.json"),
-    logs: join4(base, "logs"),
-    sessions: join4(base, "sessions")
+    settings: join6(base, "settings.json"),
+    settingsLocal: join6(base, "settings.local.json"),
+    logs: join6(base, "logs"),
+    sessions: join6(base, "sessions")
   };
 }
 function userPaths() {
-  const base = join4(homedir(), ".robota");
+  const base = join6(homedir2(), ".robota");
   return {
-    settings: join4(base, "settings.json"),
-    sessions: join4(base, "sessions")
+    settings: join6(base, "settings.json"),
+    sessions: join6(base, "sessions")
   };
 }
 
 // src/plugins/plugin-settings-store.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync, mkdirSync } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
 import { dirname as dirname2 } from "path";
 var PluginSettingsStore = class {
   settingsPath;
@@ -751,11 +1115,11 @@ var PluginSettingsStore = class {
   }
   /** Read the full settings file from disk. */
   readAll() {
-    if (!existsSync4(this.settingsPath)) {
+    if (!existsSync5(this.settingsPath)) {
       return {};
     }
     try {
-      const raw = readFileSync4(this.settingsPath, "utf-8");
+      const raw = readFileSync5(this.settingsPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data === "object" && data !== null) {
         return data;
@@ -768,8 +1132,8 @@ var PluginSettingsStore = class {
   /** Write the full settings file to disk. */
   writeAll(settings) {
     const dir = dirname2(this.settingsPath);
-    if (!existsSync4(dir)) {
-      mkdirSync(dir, { recursive: true });
+    if (!existsSync5(dir)) {
+      mkdirSync2(dir, { recursive: true });
     }
     writeFileSync(this.settingsPath, JSON.stringify(settings, null, 2), "utf-8");
   }
@@ -843,8 +1207,8 @@ var PluginSettingsStore = class {
 };
 
 // src/plugins/bundle-plugin-loader.ts
-import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync5 } from "fs";
-import { join as join5 } from "path";
+import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
+import { join as join7 } from "path";
 function parseSkillFrontmatter(raw) {
   const trimmed = raw.trimStart();
   if (!trimmed.startsWith("---")) {
@@ -893,9 +1257,9 @@ function validateManifest(data) {
   };
 }
 function getSortedSubdirs(dirPath) {
-  if (!existsSync5(dirPath)) return [];
+  if (!existsSync6(dirPath)) return [];
   try {
-    const entries = readdirSync(dirPath, { withFileTypes: true });
+    const entries = readdirSync2(dirPath, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
   } catch {
     return [];
@@ -923,23 +1287,23 @@ var BundlePluginLoader = class {
    * For each marketplace/plugin pair, the latest version (lexicographically last) is loaded.
    */
   discoverAndLoad() {
-    const cacheDir = join5(this.pluginsDir, "cache");
-    if (!existsSync5(cacheDir)) {
+    const cacheDir = join7(this.pluginsDir, "cache");
+    if (!existsSync6(cacheDir)) {
       return [];
     }
     const results = [];
     const marketplaces = getSortedSubdirs(cacheDir);
     for (const marketplace of marketplaces) {
-      const marketplaceDir = join5(cacheDir, marketplace);
+      const marketplaceDir = join7(cacheDir, marketplace);
       const plugins = getSortedSubdirs(marketplaceDir);
       for (const pluginName of plugins) {
-        const pluginDir = join5(marketplaceDir, pluginName);
+        const pluginDir = join7(marketplaceDir, pluginName);
         const versions = getSortedSubdirs(pluginDir);
         if (versions.length === 0) continue;
         const latestVersion = versions[versions.length - 1];
-        const versionDir = join5(pluginDir, latestVersion);
-        const manifestPath = join5(versionDir, ".claude-plugin", "plugin.json");
-        if (!existsSync5(manifestPath)) continue;
+        const versionDir = join7(pluginDir, latestVersion);
+        const manifestPath = join7(versionDir, ".claude-plugin", "plugin.json");
+        if (!existsSync6(manifestPath)) continue;
         const manifest = this.readManifest(manifestPath);
         if (!manifest) continue;
         const pluginId = `${manifest.name}@${marketplace}`;
@@ -953,7 +1317,7 @@ var BundlePluginLoader = class {
   /** Read and validate a plugin.json manifest. Returns null on failure. */
   readManifest(path) {
     try {
-      const raw = readFileSync5(path, "utf-8");
+      const raw = readFileSync6(path, "utf-8");
       const data = JSON.parse(raw);
       return validateManifest(data);
     } catch {
@@ -988,15 +1352,15 @@ var BundlePluginLoader = class {
   }
   /** Load skills from the plugin's skills/ directory. */
   loadSkills(pluginDir, pluginName) {
-    const skillsDir = join5(pluginDir, "skills");
-    if (!existsSync5(skillsDir)) return [];
-    const entries = readdirSync(skillsDir, { withFileTypes: true });
+    const skillsDir = join7(pluginDir, "skills");
+    if (!existsSync6(skillsDir)) return [];
+    const entries = readdirSync2(skillsDir, { withFileTypes: true });
     const skills = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const skillFile = join5(skillsDir, entry.name, "SKILL.md");
-      if (!existsSync5(skillFile)) continue;
-      const raw = readFileSync5(skillFile, "utf-8");
+      const skillFile = join7(skillsDir, entry.name, "SKILL.md");
+      if (!existsSync6(skillFile)) continue;
+      const raw = readFileSync6(skillFile, "utf-8");
       const { metadata, content } = parseSkillFrontmatter(raw);
       const description = typeof metadata.description === "string" ? metadata.description : "";
       const skill = {
@@ -1011,13 +1375,13 @@ var BundlePluginLoader = class {
   }
   /** Load commands from the plugin's commands/ directory (flat .md files). */
   loadCommands(pluginDir, pluginName) {
-    const commandsDir = join5(pluginDir, "commands");
-    if (!existsSync5(commandsDir)) return [];
-    const entries = readdirSync(commandsDir, { withFileTypes: true });
+    const commandsDir = join7(pluginDir, "commands");
+    if (!existsSync6(commandsDir)) return [];
+    const entries = readdirSync2(commandsDir, { withFileTypes: true });
     const commands = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const raw = readFileSync5(join5(commandsDir, entry.name), "utf-8");
+      const raw = readFileSync6(join7(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 : "";
@@ -1032,10 +1396,10 @@ var BundlePluginLoader = class {
   }
   /** Load hooks from hooks/hooks.json if present. */
   loadHooks(pluginDir) {
-    const hooksPath = join5(pluginDir, "hooks", "hooks.json");
-    if (!existsSync5(hooksPath)) return {};
+    const hooksPath = join7(pluginDir, "hooks", "hooks.json");
+    if (!existsSync6(hooksPath)) return {};
     try {
-      const raw = readFileSync5(hooksPath, "utf-8");
+      const raw = readFileSync6(hooksPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data === "object" && data !== null) {
         return data;
@@ -1047,12 +1411,12 @@ var BundlePluginLoader = class {
   }
   /** Load MCP server configuration if present. Checks `.mcp.json` at plugin root first. */
   loadMcpConfig(pluginDir) {
-    const primaryPath = join5(pluginDir, ".mcp.json");
-    const fallbackPath = join5(pluginDir, ".claude-plugin", "mcp.json");
-    const mcpPath = existsSync5(primaryPath) ? primaryPath : fallbackPath;
-    if (!existsSync5(mcpPath)) return void 0;
+    const primaryPath = join7(pluginDir, ".mcp.json");
+    const fallbackPath = join7(pluginDir, ".claude-plugin", "mcp.json");
+    const mcpPath = existsSync6(primaryPath) ? primaryPath : fallbackPath;
+    if (!existsSync6(mcpPath)) return void 0;
     try {
-      const raw = readFileSync5(mcpPath, "utf-8");
+      const raw = readFileSync6(mcpPath, "utf-8");
       return JSON.parse(raw);
     } catch {
       return void 0;
@@ -1060,10 +1424,10 @@ var BundlePluginLoader = class {
   }
   /** Load agent definitions from agents/ directory if present. */
   loadAgents(pluginDir) {
-    const agentsDir = join5(pluginDir, "agents");
-    if (!existsSync5(agentsDir)) return [];
+    const agentsDir = join7(pluginDir, "agents");
+    if (!existsSync6(agentsDir)) return [];
     try {
-      const entries = readdirSync(agentsDir, { withFileTypes: true });
+      const entries = readdirSync2(agentsDir, { withFileTypes: true });
       return entries.filter((e) => e.isDirectory() || e.name.endsWith(".md")).map((e) => e.name.replace(/\.md$/, ""));
     } catch {
       return [];
@@ -1073,8 +1437,8 @@ var BundlePluginLoader = class {
 
 // src/plugins/bundle-plugin-installer.ts
 import { execSync } from "child_process";
-import { cpSync, existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync6, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join6, dirname as dirname3 } from "path";
+import { cpSync, existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync7, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join8, dirname as dirname3 } from "path";
 var GIT_CLONE_TIMEOUT_MS = 6e4;
 var BundlePluginInstaller = class {
   pluginsDir;
@@ -1085,8 +1449,8 @@ var BundlePluginInstaller = class {
   exec;
   constructor(options) {
     this.pluginsDir = options.pluginsDir;
-    this.cacheDir = join6(this.pluginsDir, "cache");
-    this.registryPath = join6(this.pluginsDir, "installed_plugins.json");
+    this.cacheDir = join8(this.pluginsDir, "cache");
+    this.registryPath = join8(this.pluginsDir, "installed_plugins.json");
     this.settingsStore = options.settingsStore;
     this.marketplaceClient = options.marketplaceClient;
     this.exec = options.exec ?? this.defaultExec;
@@ -1106,8 +1470,8 @@ var BundlePluginInstaller = class {
       throw new Error(`Plugin "${pluginName}" not found in marketplace "${marketplaceName}"`);
     }
     const version = this.resolveVersion(entry, marketplaceName);
-    const targetDir = join6(this.cacheDir, marketplaceName, pluginName, version);
-    if (existsSync6(targetDir)) {
+    const targetDir = join8(this.cacheDir, marketplaceName, pluginName, version);
+    if (existsSync7(targetDir)) {
       throw new Error(
         `Plugin "${pluginName}" version "${version}" is already installed from "${marketplaceName}"`
       );
@@ -1134,7 +1498,7 @@ var BundlePluginInstaller = class {
     if (!record) {
       throw new Error(`Plugin "${pluginId}" is not installed`);
     }
-    if (existsSync6(record.installPath)) {
+    if (existsSync7(record.installPath)) {
       rmSync(record.installPath, { recursive: true, force: true });
     }
     delete registry[pluginId];
@@ -1181,13 +1545,13 @@ var BundlePluginInstaller = class {
   }
   /** Resolve the source and install the plugin. */
   resolveAndInstall(rawSource, marketplaceName, pluginName, targetDir) {
-    mkdirSync2(targetDir, { recursive: true });
+    mkdirSync3(targetDir, { recursive: true });
     const source = this.normalizeSource(rawSource);
     try {
       if (typeof source === "string") {
         const marketplaceDir = this.marketplaceClient.getMarketplaceDir(marketplaceName);
-        const sourcePath = join6(marketplaceDir, source);
-        if (!existsSync6(sourcePath)) {
+        const sourcePath = join8(marketplaceDir, source);
+        if (!existsSync7(sourcePath)) {
           throw new Error(
             `Plugin source path "${source}" not found in marketplace "${marketplaceName}"`
           );
@@ -1204,7 +1568,7 @@ var BundlePluginInstaller = class {
         throw new Error(`Unknown source type: ${JSON.stringify(source)}`);
       }
     } catch (err) {
-      if (existsSync6(targetDir)) {
+      if (existsSync7(targetDir)) {
         rmSync(targetDir, { recursive: true, force: true });
       }
       throw err;
@@ -1223,11 +1587,11 @@ var BundlePluginInstaller = class {
   }
   /** Read the installed_plugins.json registry. */
   readRegistry() {
-    if (!existsSync6(this.registryPath)) {
+    if (!existsSync7(this.registryPath)) {
       return {};
     }
     try {
-      const raw = readFileSync6(this.registryPath, "utf-8");
+      const raw = readFileSync7(this.registryPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data === "object" && data !== null) {
         return data;
@@ -1240,8 +1604,8 @@ var BundlePluginInstaller = class {
   /** Write the installed_plugins.json registry. */
   writeRegistry(registry) {
     const dir = dirname3(this.registryPath);
-    if (!existsSync6(dir)) {
-      mkdirSync2(dir, { recursive: true });
+    if (!existsSync7(dir)) {
+      mkdirSync3(dir, { recursive: true });
     }
     writeFileSync2(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
   }
@@ -1255,14 +1619,14 @@ var BundlePluginInstaller = class {
 import { execSync as execSync2 } from "child_process";
 import {
   cpSync as cpSync2,
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync7,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync8,
   renameSync,
   rmSync as rmSync2,
   writeFileSync as writeFileSync3
 } from "fs";
-import { join as join7, dirname as dirname4 } from "path";
+import { join as join9, dirname as dirname4 } from "path";
 var GIT_TIMEOUT_MS = 6e4;
 var MarketplaceClient = class {
   pluginsDir;
@@ -1272,8 +1636,8 @@ var MarketplaceClient = class {
   constructor(options) {
     this.pluginsDir = options.pluginsDir;
     this.exec = options.exec ?? this.defaultExec;
-    this.marketplacesDir = join7(this.pluginsDir, "marketplaces");
-    this.registryPath = join7(this.pluginsDir, "known_marketplaces.json");
+    this.marketplacesDir = join9(this.pluginsDir, "marketplaces");
+    this.registryPath = join9(this.pluginsDir, "known_marketplaces.json");
   }
   /**
    * Add a marketplace by cloning its repository.
@@ -1287,10 +1651,10 @@ var MarketplaceClient = class {
    */
   addMarketplace(source) {
     const tempName = "temp-" + Date.now().toString(36);
-    const tempDir = join7(this.marketplacesDir, tempName);
-    mkdirSync3(this.marketplacesDir, { recursive: true });
+    const tempDir = join9(this.marketplacesDir, tempName);
+    mkdirSync4(this.marketplacesDir, { recursive: true });
     if (source.type === "local") {
-      if (!existsSync7(source.path)) {
+      if (!existsSync8(source.path)) {
         throw new Error(`Local marketplace path does not exist: ${source.path}`);
       }
       cpSync2(source.path, tempDir, { recursive: true });
@@ -1304,8 +1668,8 @@ var MarketplaceClient = class {
         throw new Error(`Failed to clone marketplace: ${message}`);
       }
     }
-    const manifestPath = join7(tempDir, ".claude-plugin", "marketplace.json");
-    if (!existsSync7(manifestPath)) {
+    const manifestPath = join9(tempDir, ".claude-plugin", "marketplace.json");
+    if (!existsSync8(manifestPath)) {
       rmSync2(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"
@@ -1322,7 +1686,7 @@ var MarketplaceClient = class {
       rmSync2(tempDir, { recursive: true, force: true });
       throw new Error(`Marketplace "${name}" already exists`);
     }
-    const finalDir = join7(this.marketplacesDir, name);
+    const finalDir = join9(this.marketplacesDir, name);
     renameSync(tempDir, finalDir);
     registry[name] = {
       source,
@@ -1344,7 +1708,7 @@ var MarketplaceClient = class {
       throw new Error(`Marketplace "${name}" not found`);
     }
     this.removeInstalledPluginsForMarketplace(name);
-    if (existsSync7(entry.installLocation)) {
+    if (existsSync8(entry.installLocation)) {
       rmSync2(entry.installLocation, { recursive: true, force: true });
     }
     delete registry[name];
@@ -1364,12 +1728,12 @@ var MarketplaceClient = class {
     if (!entry) {
       throw new Error(`Marketplace "${name}" not found`);
     }
-    if (!existsSync7(entry.installLocation)) {
+    if (!existsSync8(entry.installLocation)) {
       throw new Error(`Marketplace directory for "${name}" does not exist`);
     }
     if (entry.source.type === "local") {
       const localSource = entry.source;
-      if (!existsSync7(localSource.path)) {
+      if (!existsSync8(localSource.path)) {
         throw new Error(`Local marketplace path does not exist: ${localSource.path}`);
       }
       rmSync2(entry.installLocation, { recursive: true, force: true });
@@ -1404,8 +1768,8 @@ var MarketplaceClient = class {
     if (!entry) {
       throw new Error(`Marketplace "${marketplaceName}" not found`);
     }
-    const manifestPath = join7(entry.installLocation, ".claude-plugin", "marketplace.json");
-    if (!existsSync7(manifestPath)) {
+    const manifestPath = join9(entry.installLocation, ".claude-plugin", "marketplace.json");
+    if (!existsSync8(manifestPath)) {
       throw new Error(
         `Marketplace "${marketplaceName}" does not contain .claude-plugin/marketplace.json`
       );
@@ -1472,11 +1836,11 @@ var MarketplaceClient = class {
    * and updates the registry.
    */
   removeInstalledPluginsForMarketplace(marketplaceName) {
-    const installedPath = join7(this.pluginsDir, "installed_plugins.json");
-    if (!existsSync7(installedPath)) return;
+    const installedPath = join9(this.pluginsDir, "installed_plugins.json");
+    if (!existsSync8(installedPath)) return;
     let registry;
     try {
-      const raw = readFileSync7(installedPath, "utf-8");
+      const raw = readFileSync8(installedPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data !== "object" || data === null) return;
       registry = data;
@@ -1486,7 +1850,7 @@ var MarketplaceClient = class {
     let changed = false;
     for (const [pluginId, record] of Object.entries(registry)) {
       if (record.marketplace === marketplaceName) {
-        if (record.installPath && existsSync7(record.installPath)) {
+        if (record.installPath && existsSync8(record.installPath)) {
           rmSync2(record.installPath, { recursive: true, force: true });
         }
         delete registry[pluginId];
@@ -1495,15 +1859,15 @@ var MarketplaceClient = class {
     }
     if (changed) {
       const dir = dirname4(installedPath);
-      if (!existsSync7(dir)) {
-        mkdirSync3(dir, { recursive: true });
+      if (!existsSync8(dir)) {
+        mkdirSync4(dir, { recursive: true });
       }
       writeFileSync3(installedPath, JSON.stringify(registry, null, 2), "utf-8");
     }
   }
   /** Read and parse a marketplace.json from a file path. */
   readManifestFromPath(path) {
-    const raw = readFileSync7(path, "utf-8");
+    const raw = readFileSync8(path, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data !== "object" || data === null) {
       throw new Error("Invalid marketplace manifest: not an object");
@@ -1516,11 +1880,11 @@ var MarketplaceClient = class {
   }
   /** Read the known_marketplaces.json registry. */
   readRegistry() {
-    if (!existsSync7(this.registryPath)) {
+    if (!existsSync8(this.registryPath)) {
       return {};
     }
     try {
-      const raw = readFileSync7(this.registryPath, "utf-8");
+      const raw = readFileSync8(this.registryPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data === "object" && data !== null) {
         return data;
@@ -1533,8 +1897,8 @@ var MarketplaceClient = class {
   /** Write the known_marketplaces.json registry. */
   writeRegistry(registry) {
     const dir = dirname4(this.registryPath);
-    if (!existsSync7(dir)) {
-      mkdirSync3(dir, { recursive: true });
+    if (!existsSync8(dir)) {
+      mkdirSync4(dir, { recursive: true });
     }
     writeFileSync3(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
   }
@@ -1544,78 +1908,6 @@ var MarketplaceClient = class {
   }
 };
 
-// src/tools/agent-tool.ts
-import { z as z2 } from "zod";
-import { createZodFunctionTool } from "@robota-sdk/agent-tools";
-function asZodSchema(schema) {
-  return schema;
-}
-var AgentSchema = z2.object({
-  prompt: z2.string().describe("Task description for the sub-agent"),
-  description: z2.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 = 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
 import { bashTool as bashTool2 } from "@robota-sdk/agent-tools";
 import { readTool as readTool2 } from "@robota-sdk/agent-tools";
@@ -1625,26 +1917,33 @@ import { globTool as globTool2 } from "@robota-sdk/agent-tools";
 import { grepTool as grepTool2 } from "@robota-sdk/agent-tools";
 export {
   AgentExecutor,
+  BUILT_IN_AGENTS,
   BundlePluginInstaller,
   BundlePluginLoader,
   DEFAULT_TOOL_DESCRIPTIONS,
-  FileSessionLogger,
+  FileSessionLogger2 as FileSessionLogger,
   MarketplaceClient,
   PluginSettingsStore,
   PromptExecutor,
-  Session2 as Session,
+  Session3 as Session,
   SessionStore,
   SilentSessionLogger,
   TRUST_TO_MODE,
-  agentTool,
+  assembleSubagentPrompt,
   bashTool2 as bashTool,
   buildSystemPrompt,
+  createAgentTool,
   createDefaultTools,
   createProvider,
   createSession,
+  createSubagentLogger,
+  createSubagentSession,
   detectProject,
   editTool2 as editTool,
   evaluatePermission,
+  getBuiltInAgent,
+  getForkWorkerSuffix,
+  getSubagentSuffix,
   globTool2 as globTool,
   grepTool2 as grepTool,
   loadConfig,
@@ -1653,8 +1952,10 @@ export {
   promptForApproval,
   query,
   readTool2 as readTool,
+  resolveSubagentLogDir,
+  retrieveAgentToolDeps,
   runHooks,
-  setAgentToolDeps,
+  storeAgentToolDeps,
   userPaths,
   writeTool2 as writeTool
 };