@robota-sdk/agent-sdk 3.0.0-beta.5 → 3.0.0-beta.51

package/dist/node/index.cjs

@@ -30,41 +30,155 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  DEFAULT_TOOL_DESCRIPTIONS: () => DEFAULT_TOOL_DESCRIPTIONS,
-  FileSessionLogger: () => import_agent_sessions3.FileSessionLogger,
-  Session: () => import_agent_sessions2.Session,
-  SessionStore: () => import_agent_sessions4.SessionStore,
-  SilentSessionLogger: () => import_agent_sessions3.SilentSessionLogger,
-  TRUST_TO_MODE: () => import_agent_core.TRUST_TO_MODE,
-  agentTool: () => agentTool,
-  bashTool: () => import_agent_tools3.bashTool,
-  buildSystemPrompt: () => buildSystemPrompt,
-  createDefaultTools: () => createDefaultTools,
-  createProvider: () => createProvider,
-  createSession: () => createSession,
-  detectProject: () => detectProject,
-  editTool: () => import_agent_tools6.editTool,
-  evaluatePermission: () => import_agent_core2.evaluatePermission,
-  globTool: () => import_agent_tools7.globTool,
-  grepTool: () => import_agent_tools8.grepTool,
-  loadConfig: () => loadConfig,
-  loadContext: () => loadContext,
+  AgentExecutor: () => AgentExecutor,
+  BUILT_IN_AGENTS: () => BUILT_IN_AGENTS,
+  BuiltinCommandSource: () => BuiltinCommandSource,
+  BundlePluginInstaller: () => BundlePluginInstaller,
+  BundlePluginLoader: () => BundlePluginLoader,
+  CommandRegistry: () => CommandRegistry,
+  InteractiveSession: () => InteractiveSession,
+  MarketplaceClient: () => MarketplaceClient,
+  PluginCommandSource: () => PluginCommandSource,
+  PluginSettingsStore: () => PluginSettingsStore,
+  PromptExecutor: () => PromptExecutor,
+  SkillCommandSource: () => SkillCommandSource,
+  TRUST_TO_MODE: () => import_agent_core3.TRUST_TO_MODE,
+  assembleSubagentPrompt: () => assembleSubagentPrompt,
+  buildSkillPrompt: () => buildSkillPrompt,
+  chatEntryToMessage: () => import_agent_core4.chatEntryToMessage,
+  createAgentTool: () => createAgentTool,
+  createQuery: () => createQuery,
+  createSubagentLogger: () => createSubagentLogger,
+  createSubagentSession: () => createSubagentSession,
+  evaluatePermission: () => import_agent_core5.evaluatePermission,
+  getBuiltInAgent: () => getBuiltInAgent,
+  getForkWorkerSuffix: () => getForkWorkerSuffix,
+  getMessagesForAPI: () => import_agent_core4.getMessagesForAPI,
+  getSubagentSuffix: () => getSubagentSuffix,
+  isChatEntry: () => import_agent_core4.isChatEntry,
+  messageToHistoryEntry: () => import_agent_core4.messageToHistoryEntry,
+  parseFrontmatter: () => parseFrontmatter2,
+  preprocessShellCommands: () => preprocessShellCommands,
   projectPaths: () => projectPaths,
   promptForApproval: () => promptForApproval,
-  query: () => query,
-  readTool: () => import_agent_tools4.readTool,
-  runHooks: () => import_agent_core3.runHooks,
-  setAgentToolDeps: () => setAgentToolDeps,
-  userPaths: () => userPaths,
-  writeTool: () => import_agent_tools5.writeTool
+  resolveSubagentLogDir: () => resolveSubagentLogDir,
+  retrieveAgentToolDeps: () => retrieveAgentToolDeps,
+  runHooks: () => import_agent_core6.runHooks,
+  storeAgentToolDeps: () => storeAgentToolDeps,
+  substituteVariables: () => substituteVariables,
+  userPaths: () => userPaths
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/types.ts
-var import_agent_core = require("@robota-sdk/agent-core");
+// src/hooks/prompt-executor.ts
+function extractJson(raw) {
+  const codeBlockMatch = /```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/.exec(raw);
+  if (codeBlockMatch) {
+    return codeBlockMatch[1].trim();
+  }
+  return raw.trim();
+}
+var PromptExecutor = class {
+  type = "prompt";
+  providerFactory;
+  defaultModel;
+  constructor(options) {
+    this.providerFactory = options.providerFactory;
+    this.defaultModel = options.defaultModel;
+  }
+  async execute(definition, input) {
+    const promptDef = definition;
+    const model = promptDef.model ?? this.defaultModel;
+    try {
+      const provider = this.providerFactory(model);
+      const prompt = `${promptDef.prompt}
+
+Context:
+${JSON.stringify(input)}
+
+Respond with JSON: { "ok": boolean, "reason"?: string }`;
+      const rawResponse = await provider.complete(prompt);
+      const jsonStr = extractJson(rawResponse);
+      let parsed;
+      try {
+        parsed = JSON.parse(jsonStr);
+      } catch {
+        return {
+          exitCode: 1,
+          stdout: "",
+          stderr: `Failed to parse AI response as JSON: ${rawResponse}`
+        };
+      }
+      if (parsed.ok) {
+        return { exitCode: 0, stdout: JSON.stringify(parsed), stderr: "" };
+      }
+      return {
+        exitCode: 2,
+        stdout: "",
+        stderr: parsed.reason ?? "Blocked by prompt hook"
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { exitCode: 1, stdout: "", stderr: message };
+    }
+  }
+};
+
+// src/hooks/agent-executor.ts
+var DEFAULT_MAX_TURNS = 50;
+var DEFAULT_TIMEOUT_SECONDS = 60;
+function extractJson2(raw) {
+  const codeBlockMatch = /```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/.exec(raw);
+  if (codeBlockMatch) {
+    return codeBlockMatch[1].trim();
+  }
+  return raw.trim();
+}
+var AgentExecutor = class {
+  type = "agent";
+  sessionFactory;
+  constructor(options) {
+    this.sessionFactory = options.sessionFactory;
+  }
+  async execute(definition, input) {
+    const agentDef = definition;
+    const maxTurns = agentDef.maxTurns ?? DEFAULT_MAX_TURNS;
+    const timeout = agentDef.timeout ?? DEFAULT_TIMEOUT_SECONDS;
+    try {
+      const session = this.sessionFactory({ maxTurns, timeout });
+      const prompt = `Hook input:
+${JSON.stringify(input)}
+
+Respond with JSON: { "ok": boolean, "reason"?: string }`;
+      const rawResponse = await session.run(prompt);
+      const jsonStr = extractJson2(rawResponse);
+      let parsed;
+      try {
+        parsed = JSON.parse(jsonStr);
+      } catch {
+        return {
+          exitCode: 1,
+          stdout: "",
+          stderr: `Failed to parse agent response as JSON: ${rawResponse}`
+        };
+      }
+      if (parsed.ok) {
+        return { exitCode: 0, stdout: JSON.stringify(parsed), stderr: "" };
+      }
+      return {
+        exitCode: 2,
+        stdout: "",
+        stderr: parsed.reason ?? "Blocked by agent hook"
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { exitCode: 1, stdout: "", stderr: message };
+    }
+  }
+};
 
 // 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 = {
@@ -95,17 +209,38 @@ function buildToolsSection(descriptions) {
   const lines = ["## Available Tools", ...descriptions.map((d) => `- ${d}`)];
   return lines.join("\n");
 }
+function buildSkillsSection(skills) {
+  const invocable = skills.filter((s) => s.disableModelInvocation !== true);
+  if (invocable.length === 0) {
+    return "";
+  }
+  const lines = [
+    "## Skills",
+    "The following skills are available:",
+    "",
+    ...invocable.map((s) => `- ${s.name}: ${s.description}`)
+  ];
+  return lines.join("\n");
+}
 function buildSystemPrompt(params) {
-  const { agentsMd, claudeMd, toolDescriptions, trustLevel, projectInfo } = params;
+  const { agentsMd, claudeMd, toolDescriptions, trustLevel, projectInfo, cwd, language } = params;
   const sections = [];
-  sections.push(
-    [
-      "## Role",
-      "You are an AI coding assistant with access to tools that let you read and modify code.",
-      "You help developers understand, write, and improve their codebase.",
-      "Always be precise, follow existing code conventions, and prefer minimal changes."
-    ].join("\n")
-  );
+  const roleLines = [
+    "## Role",
+    "You are an AI coding assistant with access to tools that let you read and modify code.",
+    "You help developers understand, write, and improve their codebase.",
+    "Always be precise, follow existing code conventions, and prefer minimal changes."
+  ];
+  if (language) {
+    roleLines.push(
+      `Always respond in ${language}. Use ${language} for all explanations and communications.`
+    );
+  }
+  sections.push(roleLines.join("\n"));
+  if (cwd) {
+    sections.push(`## Working Directory
+\`${cwd}\``);
+  }
   sections.push(buildProjectSection(projectInfo));
   sections.push(
     [
@@ -131,6 +266,12 @@ function buildSystemPrompt(params) {
   if (toolsSection.length > 0) {
     sections.push(toolsSection);
   }
+  if (params.skills !== void 0 && params.skills.length > 0) {
+    const skillsSection = buildSkillsSection(params.skills);
+    if (skillsSection.length > 0) {
+      sections.push(skillsSection);
+    }
+  }
   return sections.join("\n\n");
 }
 
@@ -158,96 +299,554 @@ function createDefaultTools() {
   ];
 }
 
-// src/assembly/create-provider.ts
-var import_agent_provider_anthropic = require("@robota-sdk/agent-provider-anthropic");
-function createProvider(config) {
-  const apiKey = config.provider.apiKey ?? process.env["ANTHROPIC_API_KEY"];
-  if (!apiKey) {
-    throw new Error(
-      "ANTHROPIC_API_KEY is not set. Set the environment variable or configure provider.apiKey in ~/.robota/settings.json"
-    );
+// 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 = options.provider;
+  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,
+      provider: deps.provider,
+      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;
+    }
   }
-  return new import_agent_provider_anthropic.AnthropicProvider({ apiKey });
+  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);
+  if (!options.provider) {
+    throw new Error(
+      "provider is required. SDK is provider-neutral \u2014 consumer must create and pass a provider instance."
+    );
+  }
+  const provider = options.provider;
   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,
+    provider,
+    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,
     claudeMd: options.context.claudeMd,
     toolDescriptions: options.toolDescriptions ?? DEFAULT_TOOL_DESCRIPTIONS,
     trustLevel: options.config.defaultTrustLevel,
-    projectInfo: options.projectInfo ?? { type: "unknown", language: "unknown" }
+    projectInfo: options.projectInfo ?? { type: "unknown", language: "unknown" },
+    cwd: process.cwd(),
+    language: options.config.language
   });
-  return new import_agent_sessions.Session({
+  const defaultAllow = [
+    "Read(.agents/**)",
+    "Read(.claude/**)",
+    "Read(.robota/**)",
+    "Glob(.agents/**)",
+    "Glob(.claude/**)",
+    "Glob(.robota/**)"
+  ];
+  const mergedPermissions = {
+    allow: [...defaultAllow, ...options.config.permissions.allow ?? []],
+    deny: options.config.permissions.deny ?? []
+  };
+  const session = new import_agent_sessions2.Session({
     tools,
     provider,
     systemMessage,
     terminal: options.terminal,
-    permissions: options.config.permissions,
+    permissions: mergedPermissions,
     hooks: options.config.hooks,
     permissionMode: options.permissionMode,
     defaultTrustLevel: options.config.defaultTrustLevel,
     model: options.config.provider.model,
     maxTurns: options.maxTurns,
     sessionStore: options.sessionStore,
+    sessionId: options.sessionId,
     permissionHandler: options.permissionHandler,
     onTextDelta: options.onTextDelta,
+    onToolExecution: options.onToolExecution,
     promptForApproval: options.promptForApproval,
     onCompact: options.onCompact,
     compactInstructions: options.compactInstructions ?? options.context.compactInstructions,
-    sessionLogger: options.sessionLogger
+    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/interactive/interactive-session.ts
 var import_agent_sessions4 = require("@robota-sdk/agent-sessions");
 
+// src/paths.ts
+var import_node_path3 = require("path");
+var import_node_os2 = require("os");
+function projectPaths(cwd) {
+  const base = (0, import_node_path3.join)(cwd, ".robota");
+  return {
+    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_path3.join)((0, import_node_os2.homedir)(), ".robota");
+  return {
+    settings: (0, import_node_path3.join)(base, "settings.json"),
+    sessions: (0, import_node_path3.join)(base, "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 HookDefinitionSchema = import_zod.z.object({
-  type: import_zod.z.literal("command"),
-  command: import_zod.z.string()
+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 HookGroupSchema = import_zod.z.object({
-  matcher: import_zod.z.string(),
-  hooks: import_zod.z.array(HookDefinitionSchema)
+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 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()
+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_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_zod2.z.discriminatedUnion("type", [
+  CommandHookDefinitionSchema,
+  HttpHookDefinitionSchema,
+  PromptHookDefinitionSchema,
+  AgentHookDefinitionSchema
+]);
+var HookGroupSchema = import_zod2.z.object({
+  matcher: import_zod2.z.string(),
+  hooks: import_zod2.z.array(HookDefinitionSchema)
+});
+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 SettingsSchema = import_zod.z.object({
+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_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_zod2.z.string().optional(),
   provider: ProviderSchema.optional(),
   permissions: PermissionsSchema.optional(),
   env: EnvSchema,
-  hooks: HooksSchema
+  hooks: HooksSchema,
+  /** Plugin enablement map: plugin name -> enabled/disabled */
+  enabledPlugins: EnabledPluginsSchema,
+  /** Extra marketplace URLs for BundlePlugin discovery */
+  extraKnownMarketplaces: ExtraKnownMarketplacesSchema
 });
 
 // src/config/config-loader.ts
@@ -271,8 +870,15 @@ function readJsonFile(filePath) {
   if (!(0, import_fs.existsSync)(filePath)) {
     return void 0;
   }
-  const raw = (0, import_fs.readFileSync)(filePath, "utf-8");
-  return JSON.parse(raw);
+  const raw = (0, import_fs.readFileSync)(filePath, "utf-8").trim();
+  if (raw.length === 0) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
 }
 function resolveEnvRef(value) {
   const ENV_PREFIX = "$ENV:";
@@ -307,13 +913,16 @@ function mergeSettings(layers) {
       env: {
         ...merged.env ?? {},
         ...layer.env ?? {}
-      }
+      },
+      enabledPlugins: merged.enabledPlugins !== void 0 || layer.enabledPlugins !== void 0 ? { ...merged.enabledPlugins ?? {}, ...layer.enabledPlugins ?? {} } : void 0,
+      extraKnownMarketplaces: layer.extraKnownMarketplaces ?? merged.extraKnownMarketplaces
     };
   }, {});
 }
 function toResolvedConfig(merged) {
   return {
     defaultTrustLevel: merged.defaultTrustLevel ?? DEFAULTS.defaultTrustLevel,
+    language: merged.language,
     provider: {
       name: merged.provider?.name ?? DEFAULTS.provider.name,
       model: merged.provider?.model ?? DEFAULTS.provider.model,
@@ -324,25 +933,39 @@ function toResolvedConfig(merged) {
       deny: merged.permissions?.deny ?? DEFAULTS.permissions.deny
     },
     env: merged.env ?? DEFAULTS.env,
-    hooks: merged.hooks ?? void 0
+    hooks: merged.hooks ?? void 0,
+    enabledPlugins: merged.enabledPlugins ?? void 0,
+    extraKnownMarketplaces: merged.extraKnownMarketplaces ?? void 0
   };
 }
+function getSettingsPaths(cwd) {
+  const home = getHomeDir();
+  return [
+    (0, import_path.join)(home, ".robota", "settings.json"),
+    // 1. user (lowest)
+    (0, import_path.join)(cwd, ".robota", "settings.json"),
+    // 2. project
+    (0, import_path.join)(cwd, ".robota", "settings.local.json"),
+    // 3. project-local
+    (0, import_path.join)(cwd, ".claude", "settings.json"),
+    // 4. project, Claude Code compat
+    (0, import_path.join)(cwd, ".claude", "settings.local.json")
+    // 5. project-local (highest)
+  ];
+}
 async function loadConfig(cwd) {
-  const userSettingsPath = (0, import_path.join)(getHomeDir(), ".robota", "settings.json");
-  const projectSettingsPath = (0, import_path.join)(cwd, ".robota", "settings.json");
-  const localSettingsPath = (0, import_path.join)(cwd, ".robota", "settings.local.json");
-  const rawLayers = [
-    readJsonFile(userSettingsPath),
-    readJsonFile(projectSettingsPath),
-    readJsonFile(localSettingsPath)
-  ].filter((v) => v !== void 0);
-  const parsedLayers = rawLayers.map((raw, index) => {
+  const allPaths = getSettingsPaths(cwd);
+  const rawEntries = [];
+  for (const filePath of allPaths) {
+    const raw = readJsonFile(filePath);
+    if (raw !== void 0) {
+      rawEntries.push({ raw, path: filePath });
+    }
+  }
+  const parsedLayers = rawEntries.map(({ raw, path }) => {
     const result = SettingsSchema.safeParse(raw);
     if (!result.success) {
-      const paths = [userSettingsPath, projectSettingsPath, localSettingsPath].filter(
-        (_, i) => rawLayers[i] !== void 0
-      );
-      throw new Error(`Invalid settings in ${paths[index] ?? "unknown"}: ${result.error.message}`);
+      throw new Error(`Invalid settings in ${path}: ${result.error.message}`);
     }
     return resolveEnvRefs(result.data);
   });
@@ -472,196 +1095,1983 @@ async function detectProject(cwd) {
   };
 }
 
-// src/permissions/permission-prompt.ts
-var import_chalk = __toESM(require("chalk"), 1);
-var PERMISSION_OPTIONS = ["Allow", "Deny"];
-var ALLOW_INDEX = 0;
-function formatArgs(toolArgs) {
-  const entries = Object.entries(toolArgs);
-  if (entries.length === 0) {
-    return "(no arguments)";
-  }
-  return entries.map(([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`).join(", ");
-}
-async function promptForApproval(terminal, toolName, toolArgs) {
-  terminal.writeLine("");
-  terminal.writeLine(import_chalk.default.yellow(`[Permission Required] Tool: ${toolName}`));
-  terminal.writeLine(import_chalk.default.dim(`  ${formatArgs(toolArgs)}`));
-  terminal.writeLine("");
-  const selected = await terminal.select(PERMISSION_OPTIONS, ALLOW_INDEX);
-  return selected === ALLOW_INDEX;
-}
+// src/interactive/interactive-session.ts
+var import_agent_core = require("@robota-sdk/agent-core");
+var import_node_crypto = require("crypto");
 
-// src/query.ts
-async function query(prompt, options) {
-  const cwd = options?.cwd ?? process.cwd();
-  const [config, context, projectInfo] = await Promise.all([
-    loadConfig(cwd),
-    loadContext(cwd),
-    detectProject(cwd)
-  ]);
-  const noopTerminal = {
-    write: () => {
+// src/commands/system-command.ts
+var VALID_MODES = ["plan", "default", "acceptEdits", "bypassPermissions"];
+function createSystemCommands() {
+  return [
+    {
+      name: "help",
+      description: "Show available commands",
+      execute: (_session, _args) => ({
+        message: [
+          "Available commands:",
+          "  help              \u2014 Show this help",
+          "  clear             \u2014 Clear conversation",
+          "  compact [instr]   \u2014 Compact context (optional focus instructions)",
+          "  mode [m]          \u2014 Show/change permission mode",
+          "  model <id>        \u2014 Change AI model",
+          "  language <code>   \u2014 Set response language (ko, en, ja, zh)",
+          "  cost              \u2014 Show session info",
+          "  context           \u2014 Context window info",
+          "  permissions       \u2014 Permission rules",
+          "  resume            \u2014 Resume a previous session",
+          "  rename <name>     \u2014 Rename the current session",
+          "  reset             \u2014 Delete settings and exit"
+        ].join("\n"),
+        success: true
+      })
     },
-    writeLine: () => {
+    {
+      name: "clear",
+      description: "Clear conversation history",
+      execute: (session, _args) => {
+        const underlying = session.getSession();
+        underlying.clearHistory();
+        return { message: "Conversation cleared.", success: true };
+      }
     },
-    writeMarkdown: () => {
+    {
+      name: "compact",
+      description: "Compress context window",
+      execute: async (session, args) => {
+        const underlying = session.getSession();
+        const instructions = args.trim() || void 0;
+        const before = underlying.getContextState().usedPercentage;
+        await underlying.compact(instructions);
+        const after = underlying.getContextState().usedPercentage;
+        return {
+          message: `Context compacted: ${Math.round(before)}% -> ${Math.round(after)}%`,
+          success: true,
+          data: { before, after }
+        };
+      }
     },
-    writeError: () => {
+    {
+      name: "mode",
+      description: "Show/change permission mode",
+      execute: (session, args) => {
+        const underlying = session.getSession();
+        const arg = args.trim().split(/\s+/)[0];
+        if (!arg) {
+          return {
+            message: `Current mode: ${underlying.getPermissionMode()}`,
+            success: true,
+            data: { mode: underlying.getPermissionMode() }
+          };
+        }
+        if (VALID_MODES.includes(arg)) {
+          underlying.setPermissionMode(arg);
+          return {
+            message: `Permission mode set to: ${arg}`,
+            success: true,
+            data: { mode: arg }
+          };
+        }
+        return {
+          message: `Invalid mode. Valid: ${VALID_MODES.join(" | ")}`,
+          success: false
+        };
+      }
     },
-    prompt: () => Promise.resolve(""),
-    select: () => Promise.resolve(0),
-    spinner: () => ({ stop: () => {
-    }, update: () => {
-    } })
-  };
-  const session = createSession({
-    config,
-    context,
-    terminal: noopTerminal,
-    projectInfo,
-    permissionMode: options?.permissionMode ?? "bypassPermissions",
-    maxTurns: options?.maxTurns,
-    provider: options?.provider,
-    permissionHandler: options?.permissionHandler,
-    onTextDelta: options?.onTextDelta,
-    onCompact: options?.onCompact,
-    compactInstructions: context.compactInstructions,
-    promptForApproval
-  });
-  return session.run(prompt);
-}
-
-// src/index.ts
-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");
-function projectPaths(cwd) {
-  const base = (0, import_node_path.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")
-  };
-}
-function userPaths() {
-  const base = (0, import_node_path.join)((0, import_node_os.homedir)(), ".robota");
-  return {
-    settings: (0, import_node_path.join)(base, "settings.json"),
-    sessions: (0, import_node_path.join)(base, "sessions")
-  };
-}
-
-// 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: () => {
+    {
+      name: "model",
+      description: "Change AI model",
+      execute: (_session, args) => {
+        const modelId = args.trim().split(/\s+/)[0];
+        if (!modelId) {
+          return { message: "Usage: model <model-id>", success: false };
+        }
+        return {
+          message: `Model change requested: ${modelId}`,
+          success: true,
+          data: { modelId }
+        };
+      }
     },
-    writeLine: () => {
+    {
+      name: "language",
+      description: "Set response language",
+      execute: (_session, args) => {
+        const lang = args.trim().split(/\s+/)[0];
+        if (!lang) {
+          return { message: "Usage: language <code> (e.g., ko, en, ja, zh)", success: false };
+        }
+        return {
+          message: `Language set to "${lang}".`,
+          success: true,
+          data: { language: lang }
+        };
+      }
     },
-    writeMarkdown: () => {
+    {
+      name: "cost",
+      description: "Show session info",
+      execute: (session, _args) => {
+        const underlying = session.getSession();
+        const sessionId = underlying.getSessionId();
+        const messageCount = underlying.getMessageCount();
+        return {
+          message: `Session: ${sessionId}
+Messages: ${messageCount}`,
+          success: true,
+          data: { sessionId, messageCount }
+        };
+      }
     },
-    writeError: () => {
+    {
+      name: "context",
+      description: "Context window info",
+      execute: (session, _args) => {
+        const ctx = session.getContextState();
+        return {
+          message: `Context: ${ctx.usedTokens.toLocaleString()} / ${ctx.maxTokens.toLocaleString()} tokens (${Math.round(ctx.usedPercentage)}%)`,
+          success: true,
+          data: {
+            usedTokens: ctx.usedTokens,
+            maxTokens: ctx.maxTokens,
+            percentage: ctx.usedPercentage
+          }
+        };
+      }
     },
-    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);
-  }
+    {
+      name: "permissions",
+      description: "Show permission rules",
+      execute: (session, _args) => {
+        const underlying = session.getSession();
+        const mode = underlying.getPermissionMode();
+        const sessionAllowed = underlying.getSessionAllowedTools();
+        const lines = [`Permission mode: ${mode}`];
+        if (sessionAllowed.length > 0) {
+          lines.push(`Session-approved tools: ${sessionAllowed.join(", ")}`);
+        } else {
+          lines.push("No session-approved tools.");
+        }
+        return {
+          message: lines.join("\n"),
+          success: true,
+          data: { mode, sessionAllowed }
+        };
+      }
+    },
+    {
+      name: "resume",
+      description: "Resume a previous session",
+      execute: (_session, _args) => ({
+        message: "Opening session picker...",
+        success: true,
+        data: { triggerResumePicker: true }
+      })
+    },
+    {
+      name: "rename",
+      description: "Rename the current session",
+      execute: (_session, args) => {
+        const name = args.trim();
+        if (!name) {
+          return { message: "Usage: rename <name>", success: false };
+        }
+        return {
+          message: `Session renamed to "${name}".`,
+          success: true,
+          data: { name }
+        };
+      }
+    },
+    {
+      name: "reset",
+      description: "Delete settings",
+      execute: (_session, _args) => {
+        return {
+          message: "Reset requested.",
+          success: true,
+          data: { resetRequested: true }
+        };
+      }
+    }
+  ];
 }
-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);
+var SystemCommandExecutor = class {
+  commands;
+  constructor(commands) {
+    this.commands = /* @__PURE__ */ new Map();
+    for (const cmd of commands ?? createSystemCommands()) {
+      this.commands.set(cmd.name, cmd);
+    }
+  }
+  /** Register an additional command. */
+  register(command) {
+    this.commands.set(command.name, command);
+  }
+  /** Execute a command by name. Returns null if command not found. */
+  async execute(name, session, args) {
+    const cmd = this.commands.get(name);
+    if (!cmd) return null;
+    return await cmd.execute(session, args);
   }
-);
+  /** List all registered commands. */
+  listCommands() {
+    return [...this.commands.values()];
+  }
+  /** Check if a command exists. */
+  hasCommand(name) {
+    return this.commands.has(name);
+  }
+};
+
+// src/plugins/plugin-settings-store.ts
+var import_node_fs3 = require("fs");
+var import_node_path4 = require("path");
+var PluginSettingsStore = class {
+  settingsPath;
+  constructor(settingsPath) {
+    this.settingsPath = settingsPath;
+  }
+  /** Read the full settings file from disk. */
+  readAll() {
+    if (!(0, import_node_fs3.existsSync)(this.settingsPath)) {
+      return {};
+    }
+    try {
+      const raw = (0, import_node_fs3.readFileSync)(this.settingsPath, "utf-8");
+      const data = JSON.parse(raw);
+      if (typeof data === "object" && data !== null) {
+        return data;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  /** Write the full settings file to disk. */
+  writeAll(settings) {
+    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_fs3.writeFileSync)(this.settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+  }
+  // --- enabledPlugins ---
+  /** Get the enabledPlugins map. */
+  getEnabledPlugins() {
+    const settings = this.readAll();
+    const ep = settings.enabledPlugins;
+    if (typeof ep === "object" && ep !== null) {
+      return ep;
+    }
+    return {};
+  }
+  /** Set a single plugin's enabled state. */
+  setPluginEnabled(pluginId, enabled) {
+    const settings = this.readAll();
+    const ep = this.getEnabledPluginsFrom(settings);
+    ep[pluginId] = enabled;
+    settings.enabledPlugins = ep;
+    this.writeAll(settings);
+  }
+  /** Remove a plugin from enabledPlugins. */
+  removePluginEntry(pluginId) {
+    const settings = this.readAll();
+    const ep = this.getEnabledPluginsFrom(settings);
+    delete ep[pluginId];
+    settings.enabledPlugins = ep;
+    this.writeAll(settings);
+  }
+  // --- extraKnownMarketplaces ---
+  /** Get all persisted marketplace sources. */
+  getMarketplaceSources() {
+    const settings = this.readAll();
+    const extra = settings.extraKnownMarketplaces;
+    if (typeof extra === "object" && extra !== null) {
+      return extra;
+    }
+    return {};
+  }
+  /** Add or update a marketplace source. */
+  setMarketplaceSource(name, source) {
+    const settings = this.readAll();
+    const extra = this.getMarketplaceSourcesFrom(settings);
+    extra[name] = { source };
+    settings.extraKnownMarketplaces = extra;
+    this.writeAll(settings);
+  }
+  /** Remove a marketplace source. */
+  removeMarketplaceSource(name) {
+    const settings = this.readAll();
+    const extra = this.getMarketplaceSourcesFrom(settings);
+    delete extra[name];
+    settings.extraKnownMarketplaces = extra;
+    this.writeAll(settings);
+  }
+  // --- helpers ---
+  getEnabledPluginsFrom(settings) {
+    const ep = settings.enabledPlugins;
+    if (typeof ep === "object" && ep !== null) {
+      return ep;
+    }
+    return {};
+  }
+  getMarketplaceSourcesFrom(settings) {
+    const extra = settings.extraKnownMarketplaces;
+    if (typeof extra === "object" && extra !== null) {
+      return extra;
+    }
+    return {};
+  }
+};
+
+// src/plugins/bundle-plugin-loader.ts
+var import_node_fs4 = require("fs");
+var import_node_path5 = require("path");
+function parseSkillFrontmatter(raw) {
+  const trimmed = raw.trimStart();
+  if (!trimmed.startsWith("---")) {
+    return { metadata: {}, content: raw };
+  }
+  const endIndex = trimmed.indexOf("---", 3);
+  if (endIndex === -1) {
+    return { metadata: {}, content: raw };
+  }
+  const frontmatterBlock = trimmed.slice(3, endIndex).trim();
+  const content = trimmed.slice(endIndex + 3).trimStart();
+  const metadata = {};
+  for (const line of frontmatterBlock.split("\n")) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    let value = line.slice(colonIndex + 1).trim();
+    if (typeof value === "string" && value.startsWith("[") && value.endsWith("]")) {
+      const inner = value.slice(1, -1);
+      value = inner.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    }
+    if (key) {
+      metadata[key] = value;
+    }
+  }
+  return { metadata, content };
+}
+function validateManifest(data) {
+  if (typeof data !== "object" || data === null) return null;
+  const obj = data;
+  if (typeof obj.name !== "string") return null;
+  if (typeof obj.version !== "string") return null;
+  if (typeof obj.description !== "string") return null;
+  const features = typeof obj.features === "object" && obj.features !== null ? obj.features : {};
+  return {
+    name: obj.name,
+    version: obj.version,
+    description: obj.description,
+    features: {
+      commands: features.commands === true ? true : void 0,
+      agents: features.agents === true ? true : void 0,
+      skills: features.skills === true ? true : void 0,
+      hooks: features.hooks === true ? true : void 0,
+      mcp: features.mcp === true ? true : void 0
+    }
+  };
+}
+function getSortedSubdirs(dirPath) {
+  if (!(0, import_node_fs4.existsSync)(dirPath)) return [];
+  try {
+    const entries = (0, import_node_fs4.readdirSync)(dirPath, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  } catch {
+    return [];
+  }
+}
+var BundlePluginLoader = class {
+  pluginsDir;
+  enabledPlugins;
+  constructor(pluginsDir, enabledPlugins) {
+    this.pluginsDir = pluginsDir;
+    this.enabledPlugins = enabledPlugins ?? {};
+  }
+  /** Load all discovered and enabled bundle plugins (sync). */
+  loadPluginsSync() {
+    return this.discoverAndLoad();
+  }
+  /** Load all discovered and enabled bundle plugins (async wrapper). */
+  async loadAll() {
+    return this.discoverAndLoad();
+  }
+  /**
+   * Discover and load plugins from the cache directory.
+   *
+   * Directory structure: `<pluginsDir>/cache/<marketplace>/<plugin>/<version>/`
+   * For each marketplace/plugin pair, the latest version (lexicographically last) is loaded.
+   */
+  discoverAndLoad() {
+    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_path5.join)(cacheDir, marketplace);
+      const plugins = getSortedSubdirs(marketplaceDir);
+      for (const pluginName of plugins) {
+        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_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}`;
+        if (this.isDisabled(pluginId, manifest.name)) continue;
+        const loaded = this.loadPlugin(versionDir, manifest);
+        results.push(loaded);
+      }
+    }
+    return results;
+  }
+  /** Read and validate a plugin.json manifest. Returns null on failure. */
+  readManifest(path) {
+    try {
+      const raw = (0, import_node_fs4.readFileSync)(path, "utf-8");
+      const data = JSON.parse(raw);
+      return validateManifest(data);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Check if a plugin is explicitly disabled.
+   * Checks both `name@marketplace` and `name` keys.
+   * Plugins not listed in enabledPlugins are enabled by default.
+   */
+  isDisabled(pluginId, pluginName) {
+    if (pluginId in this.enabledPlugins) {
+      return this.enabledPlugins[pluginId] === false;
+    }
+    if (pluginName in this.enabledPlugins) {
+      return this.enabledPlugins[pluginName] === false;
+    }
+    return false;
+  }
+  /** Load a single plugin's skills, hooks, agents, and MCP config. */
+  loadPlugin(pluginDir, manifest) {
+    return {
+      manifest,
+      skills: this.loadSkills(pluginDir, manifest.name),
+      commands: this.loadCommands(pluginDir, manifest.name),
+      hooks: this.loadHooks(pluginDir),
+      mcpConfig: this.loadMcpConfig(pluginDir),
+      agents: this.loadAgents(pluginDir),
+      pluginDir
+    };
+  }
+  /** Load skills from the plugin's skills/ directory. */
+  loadSkills(pluginDir, pluginName) {
+    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_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 = {
+        name: entry.name,
+        description,
+        skillContent: content,
+        ...metadata
+      };
+      skills.push(skill);
+    }
+    return skills;
+  }
+  /** Load commands from the plugin's commands/ directory (flat .md files). */
+  loadCommands(pluginDir, pluginName) {
+    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_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 : "";
+      commands.push({
+        ...metadata,
+        name: `${pluginName}:${name}`,
+        description,
+        skillContent: content
+      });
+    }
+    return commands;
+  }
+  /** Load hooks from hooks/hooks.json if present. */
+  loadHooks(pluginDir) {
+    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_fs4.readFileSync)(hooksPath, "utf-8");
+      const data = JSON.parse(raw);
+      if (typeof data === "object" && data !== null) {
+        return data;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  /** Load MCP server configuration if present. Checks `.mcp.json` at plugin root first. */
+  loadMcpConfig(pluginDir) {
+    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_fs4.readFileSync)(mcpPath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  /** Load agent definitions from agents/ directory if present. */
+  loadAgents(pluginDir) {
+    const agentsDir = (0, import_node_path5.join)(pluginDir, "agents");
+    if (!(0, import_node_fs4.existsSync)(agentsDir)) return [];
+    try {
+      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 [];
+    }
+  }
+};
+
+// src/plugins/bundle-plugin-installer.ts
+var import_node_child_process = require("child_process");
+var import_node_fs5 = require("fs");
+var import_node_path6 = require("path");
+var GIT_CLONE_TIMEOUT_MS = 6e4;
+var BundlePluginInstaller = class {
+  pluginsDir;
+  cacheDir;
+  registryPath;
+  settingsStore;
+  marketplaceClient;
+  exec;
+  constructor(options) {
+    this.pluginsDir = options.pluginsDir;
+    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;
+  }
+  /**
+   * Install a plugin from a marketplace.
+   *
+   * 1. Read marketplace manifest to find the plugin entry.
+   * 2. Resolve source (relative path, github, or url).
+   * 3. Copy/clone to `cache/<marketplace>/<plugin>/<version>/`.
+   * 4. Record in `installed_plugins.json`.
+   */
+  async install(pluginName, marketplaceName) {
+    const manifest = this.marketplaceClient.fetchManifest(marketplaceName);
+    const entry = manifest.plugins.find((p) => p.name === pluginName);
+    if (!entry) {
+      throw new Error(`Plugin "${pluginName}" not found in marketplace "${marketplaceName}"`);
+    }
+    const version = this.resolveVersion(entry, marketplaceName);
+    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}"`
+      );
+    }
+    this.resolveAndInstall(entry.source, marketplaceName, pluginName, targetDir);
+    const pluginId = `${pluginName}@${marketplaceName}`;
+    const registry = this.readRegistry();
+    registry[pluginId] = {
+      pluginName,
+      marketplace: marketplaceName,
+      version,
+      installPath: targetDir,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.writeRegistry(registry);
+  }
+  /**
+   * Uninstall a plugin.
+   * Removes from cache and from installed_plugins.json.
+   */
+  async uninstall(pluginId) {
+    const registry = this.readRegistry();
+    const record = registry[pluginId];
+    if (!record) {
+      throw new Error(`Plugin "${pluginId}" is not installed`);
+    }
+    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);
+    this.settingsStore.removePluginEntry(pluginId);
+  }
+  /** Enable a plugin by setting its enabledPlugins entry to true. */
+  async enable(pluginId) {
+    this.settingsStore.setPluginEnabled(pluginId, true);
+  }
+  /** Disable a plugin by setting its enabledPlugins entry to false. */
+  async disable(pluginId) {
+    this.settingsStore.setPluginEnabled(pluginId, false);
+  }
+  /** Get all installed plugins. */
+  getInstalledPlugins() {
+    return this.readRegistry();
+  }
+  /** Get plugins installed from a specific marketplace. */
+  getPluginsByMarketplace(marketplaceName) {
+    const registry = this.readRegistry();
+    return Object.values(registry).filter((r) => r.marketplace === marketplaceName);
+  }
+  // --- Private helpers ---
+  /** Resolve the version for a plugin entry. */
+  resolveVersion(entry, marketplaceName) {
+    const entryWithVersion = entry;
+    if (typeof entryWithVersion.version === "string" && entryWithVersion.version) {
+      return entryWithVersion.version;
+    }
+    return this.marketplaceClient.getMarketplaceSha(marketplaceName);
+  }
+  /**
+   * Normalize source object — Claude Code manifests use `source` key instead of `type`.
+   * e.g., { source: "url", url: "..." } → { type: "url", url: "..." }
+   */
+  normalizeSource(source) {
+    if (typeof source === "string") return source;
+    const obj = source;
+    if (!obj.type && typeof obj.source === "string") {
+      return { ...obj, type: obj.source };
+    }
+    return source;
+  }
+  /** Resolve the source and install the plugin. */
+  resolveAndInstall(rawSource, marketplaceName, pluginName, targetDir) {
+    (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_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_fs5.cpSync)(sourcePath, targetDir, { recursive: true });
+      } else if (source.type === "github") {
+        const repoUrl = `https://github.com/${source.repo}.git`;
+        this.cloneToDir(repoUrl, targetDir, pluginName);
+      } else if (source.type === "url" && typeof source.url === "string" && source.url.endsWith(".git")) {
+        this.cloneToDir(source.url, targetDir, pluginName);
+      } else if (source.type === "url") {
+        throw new Error(`URL source "${source.url}" is not a git repository (must end with .git)`);
+      } else {
+        throw new Error(`Unknown source type: ${JSON.stringify(source)}`);
+      }
+    } catch (err) {
+      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_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" });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to clone plugin "${pluginName}": ${message}`);
+    }
+  }
+  /** Read the installed_plugins.json registry. */
+  readRegistry() {
+    if (!(0, import_node_fs5.existsSync)(this.registryPath)) {
+      return {};
+    }
+    try {
+      const raw = (0, import_node_fs5.readFileSync)(this.registryPath, "utf-8");
+      const data = JSON.parse(raw);
+      if (typeof data === "object" && data !== null) {
+        return data;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  /** Write the installed_plugins.json registry. */
+  writeRegistry(registry) {
+    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_fs5.writeFileSync)(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
+  }
+  /** Default exec implementation using child_process. */
+  defaultExec(command, options) {
+    return (0, import_node_child_process.execSync)(command, { timeout: options.timeout, stdio: "pipe" });
+  }
+};
+
+// src/plugins/marketplace-client.ts
+var import_node_child_process2 = require("child_process");
+var import_node_fs6 = require("fs");
+var import_node_path7 = require("path");
+var GIT_TIMEOUT_MS = 6e4;
+var MarketplaceClient = class {
+  pluginsDir;
+  exec;
+  marketplacesDir;
+  registryPath;
+  constructor(options) {
+    this.pluginsDir = options.pluginsDir;
+    this.exec = options.exec ?? this.defaultExec;
+    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.
+   *
+   * 1. Parse source: `owner/repo` string becomes a GitHub source.
+   * 2. Shallow git clone (`--depth 1`) to `marketplaces/<name>/`.
+   * 3. Read `.claude-plugin/marketplace.json` for the `name` field.
+   * 4. Register in `known_marketplaces.json`.
+   *
+   * Returns the registered marketplace name from the manifest.
+   */
+  addMarketplace(source) {
+    const tempName = "temp-" + Date.now().toString(36);
+    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_fs6.existsSync)(source.path)) {
+        throw new Error(`Local marketplace path does not exist: ${source.path}`);
+      }
+      (0, import_node_fs6.cpSync)(source.path, tempDir, { recursive: true });
+    } else {
+      const cloneUrl = this.resolveCloneUrl(source);
+      const command = `git clone --depth 1 ${cloneUrl} ${tempDir}`;
+      try {
+        this.exec(command, { timeout: GIT_TIMEOUT_MS, stdio: "pipe" });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to clone marketplace: ${message}`);
+      }
+    }
+    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"
+      );
+    }
+    const manifest = this.readManifestFromPath(manifestPath);
+    const name = manifest.name;
+    if (!name) {
+      (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_fs6.rmSync)(tempDir, { recursive: true, force: true });
+      throw new Error(`Marketplace "${name}" already exists`);
+    }
+    const finalDir = (0, import_node_path7.join)(this.marketplacesDir, name);
+    (0, import_node_fs6.renameSync)(tempDir, finalDir);
+    registry[name] = {
+      source,
+      installLocation: finalDir,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.writeRegistry(registry);
+    return name;
+  }
+  /**
+   * Remove a marketplace.
+   * Uninstalls all plugins from that marketplace, then deletes the clone directory
+   * and removes from the registry.
+   */
+  removeMarketplace(name) {
+    const registry = this.readRegistry();
+    const entry = registry[name];
+    if (!entry) {
+      throw new Error(`Marketplace "${name}" not found`);
+    }
+    this.removeInstalledPluginsForMarketplace(name);
+    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);
+  }
+  /**
+   * Update a marketplace by running git pull on its clone.
+   * The manifest is re-read from disk on demand (via fetchManifest), so the
+   * updated manifest is automatically available after pull.
+   *
+   * TODO: After pull, detect version changes in installed plugins and offer
+   * to update them (re-install at new version).
+   */
+  updateMarketplace(name) {
+    const registry = this.readRegistry();
+    const entry = registry[name];
+    if (!entry) {
+      throw new Error(`Marketplace "${name}" not found`);
+    }
+    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_fs6.existsSync)(localSource.path)) {
+        throw new Error(`Local marketplace path does not exist: ${localSource.path}`);
+      }
+      (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 {
+        this.exec(command, { timeout: GIT_TIMEOUT_MS, stdio: "pipe" });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to update marketplace "${name}": ${message}`);
+      }
+    }
+    entry.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    this.writeRegistry(registry);
+  }
+  /** List all registered marketplaces. */
+  listMarketplaces() {
+    const registry = this.readRegistry();
+    return Object.entries(registry).map(([name, entry]) => ({
+      name,
+      source: entry.source,
+      lastUpdated: entry.lastUpdated
+    }));
+  }
+  /**
+   * Read the marketplace manifest from a registered marketplace's clone.
+   */
+  fetchManifest(marketplaceName) {
+    const registry = this.readRegistry();
+    const entry = registry[marketplaceName];
+    if (!entry) {
+      throw new Error(`Marketplace "${marketplaceName}" not found`);
+    }
+    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`
+      );
+    }
+    return this.readManifestFromPath(manifestPath);
+  }
+  /** Get the clone directory path for a registered marketplace. */
+  getMarketplaceDir(name) {
+    const registry = this.readRegistry();
+    const entry = registry[name];
+    if (!entry) {
+      throw new Error(`Marketplace "${name}" not found`);
+    }
+    return entry.installLocation;
+  }
+  /**
+   * Get the current git SHA (first 12 chars) for a marketplace clone.
+   * Used as a version identifier when plugins lack explicit versions.
+   */
+  getMarketplaceSha(name) {
+    const dir = this.getMarketplaceDir(name);
+    try {
+      const result = this.exec(`git -C ${dir} rev-parse HEAD`, {
+        timeout: GIT_TIMEOUT_MS,
+        stdio: "pipe"
+      });
+      return result.toString().trim().slice(0, 12);
+    } catch {
+      return "unknown";
+    }
+  }
+  /** List all available plugins across all marketplaces. */
+  listAvailablePlugins() {
+    const results = [];
+    const marketplaces = this.listMarketplaces();
+    for (const { name } of marketplaces) {
+      try {
+        const manifest = this.fetchManifest(name);
+        for (const plugin of manifest.plugins) {
+          results.push({ ...plugin, marketplace: name });
+        }
+      } catch {
+      }
+    }
+    return results;
+  }
+  // --- Private helpers ---
+  /** Resolve a marketplace source to a git clone URL. */
+  resolveCloneUrl(source) {
+    switch (source.type) {
+      case "github":
+        return `https://github.com/${source.repo}.git`;
+      case "git":
+        return source.url;
+      case "local":
+        throw new Error("Local source type does not use git cloning");
+      case "url":
+        throw new Error("URL marketplace source is not yet supported");
+    }
+  }
+  /**
+   * Remove all installed plugins that belong to a given marketplace.
+   * Reads installed_plugins.json, deletes cache directories for matching plugins,
+   * and updates the registry.
+   */
+  removeInstalledPluginsForMarketplace(marketplaceName) {
+    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_fs6.readFileSync)(installedPath, "utf-8");
+      const data = JSON.parse(raw);
+      if (typeof data !== "object" || data === null) return;
+      registry = data;
+    } catch {
+      return;
+    }
+    let changed = false;
+    for (const [pluginId, record] of Object.entries(registry)) {
+      if (record.marketplace === marketplaceName) {
+        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_path7.dirname)(installedPath);
+      if (!(0, import_node_fs6.existsSync)(dir)) {
+        (0, import_node_fs6.mkdirSync)(dir, { recursive: true });
+      }
+      (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_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");
+    }
+    const obj = data;
+    if (typeof obj.name !== "string") {
+      throw new Error('Invalid marketplace manifest: missing "name" field');
+    }
+    return data;
+  }
+  /** Read the known_marketplaces.json registry. */
+  readRegistry() {
+    if (!(0, import_node_fs6.existsSync)(this.registryPath)) {
+      return {};
+    }
+    try {
+      const raw = (0, import_node_fs6.readFileSync)(this.registryPath, "utf-8");
+      const data = JSON.parse(raw);
+      if (typeof data === "object" && data !== null) {
+        return data;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  /** Write the known_marketplaces.json registry. */
+  writeRegistry(registry) {
+    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_fs6.writeFileSync)(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
+  }
+  /** Default exec implementation using child_process. */
+  defaultExec(command, options) {
+    return (0, import_node_child_process2.execSync)(command, { timeout: options.timeout, stdio: "pipe" });
+  }
+};
+
+// src/plugins/plugin-hooks-merger.ts
+var import_node_path8 = require("path");
+function buildPluginEnv(plugin) {
+  const dataDir = (0, import_node_path8.join)((0, import_node_path8.dirname)((0, import_node_path8.dirname)(plugin.pluginDir)), "data", plugin.manifest.name);
+  return {
+    CLAUDE_PLUGIN_ROOT: plugin.pluginDir,
+    CLAUDE_PLUGIN_PATH: plugin.pluginDir,
+    CLAUDE_PLUGIN_DATA: dataDir
+  };
+}
+function resolvePluginRoot(group, pluginDir) {
+  if (Array.isArray(group.hooks)) {
+    return {
+      ...group,
+      hooks: group.hooks.map((h) => {
+        if (typeof h.command === "string") {
+          return {
+            ...h,
+            command: h.command.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, pluginDir)
+          };
+        }
+        return h;
+      })
+    };
+  }
+  return group;
+}
+function mergePluginHooks(plugins) {
+  const merged = {};
+  for (const plugin of plugins) {
+    const hooksObj = plugin.hooks;
+    if (!hooksObj) continue;
+    const pluginEnv = buildPluginEnv(plugin);
+    const innerHooks = hooksObj.hooks ?? hooksObj;
+    for (const [event, groups] of Object.entries(innerHooks)) {
+      if (!Array.isArray(groups)) continue;
+      if (!merged[event]) merged[event] = [];
+      const resolved = groups.map((group) => {
+        const r = resolvePluginRoot(group, plugin.pluginDir);
+        r.env = pluginEnv;
+        return r;
+      });
+      merged[event].push(...resolved);
+    }
+  }
+  return merged;
+}
+function mergeHooksIntoConfig(configHooks, pluginHooks) {
+  const pluginKeys = Object.keys(pluginHooks);
+  if (pluginKeys.length === 0) return configHooks;
+  const merged = {};
+  for (const [event, groups] of Object.entries(pluginHooks)) {
+    merged[event] = [...groups];
+  }
+  if (configHooks) {
+    for (const [event, groups] of Object.entries(configHooks)) {
+      if (!Array.isArray(groups)) continue;
+      if (!merged[event]) merged[event] = [];
+      merged[event].push(...groups);
+    }
+  }
+  return merged;
+}
+
+// src/interactive/interactive-session.ts
+var import_node_os3 = require("os");
+var import_node_path9 = require("path");
+var TOOL_ARG_DISPLAY_MAX = 80;
+var TAIL_KEEP = 30;
+var MAX_COMPLETED_TOOLS = 50;
+var STREAMING_FLUSH_INTERVAL_MS = 16;
+var InteractiveSession = class {
+  session = null;
+  commandExecutor;
+  listeners = /* @__PURE__ */ new Map();
+  initialized = false;
+  initPromise = null;
+  // Streaming state
+  streamingText = "";
+  flushTimer = null;
+  // Tool state
+  activeTools = [];
+  // Execution state
+  executing = false;
+  pendingPrompt = null;
+  pendingDisplayInput;
+  pendingRawInput;
+  // Full history timeline (chat messages + events)
+  history = [];
+  // Session persistence
+  sessionStore;
+  sessionName;
+  cwd;
+  // Session restore state
+  pendingRestoreMessages = null;
+  resumeSessionId;
+  forkSession;
+  constructor(options) {
+    this.commandExecutor = new SystemCommandExecutor(createSystemCommands());
+    if ("session" in options && options.session) {
+      this.session = options.session;
+      this.initialized = true;
+    } else {
+      const stdOpts = options;
+      this.initPromise = this.initializeAsync(stdOpts);
+    }
+    this.sessionStore = options.sessionStore;
+    this.sessionName = options.sessionName;
+    this.cwd = ("cwd" in options ? options.cwd : void 0) ?? "";
+    this.resumeSessionId = options.resumeSessionId;
+    this.forkSession = options.forkSession ?? false;
+    if (options.resumeSessionId && this.sessionStore) {
+      const record = this.sessionStore.load(options.resumeSessionId);
+      if (record) {
+        this.history = record.history ?? [];
+        this.sessionName = record.name;
+        if (record.messages) {
+          if (this.session) {
+            for (const msg of record.messages) {
+              const m = msg;
+              if (m.role && m.content) {
+                this.session.injectMessage(m.role, m.content);
+              }
+            }
+          } else {
+            this.pendingRestoreMessages = record.messages;
+          }
+        }
+      }
+    }
+  }
+  async initializeAsync(options) {
+    const cwd = options.cwd;
+    const [config, context, projectInfo] = await Promise.all([
+      loadConfig(cwd),
+      loadContext(cwd),
+      detectProject(cwd)
+    ]);
+    const pluginsDir = (0, import_node_path9.join)((0, import_node_os3.homedir)(), ".robota", "plugins");
+    const pluginLoader = new BundlePluginLoader(pluginsDir);
+    let mergedConfig = config;
+    try {
+      const plugins = pluginLoader.loadPluginsSync();
+      if (plugins.length > 0) {
+        const pluginHooks = mergePluginHooks(plugins);
+        mergedConfig = {
+          ...config,
+          hooks: mergeHooksIntoConfig(
+            config.hooks,
+            pluginHooks
+          )
+        };
+      }
+    } catch {
+    }
+    const paths = projectPaths(cwd);
+    const sessionId = this.resumeSessionId && !this.forkSession ? this.resumeSessionId : void 0;
+    this.session = createSession({
+      config: mergedConfig,
+      context,
+      projectInfo,
+      permissionMode: options.permissionMode,
+      maxTurns: options.maxTurns,
+      terminal: NOOP_TERMINAL,
+      sessionLogger: new import_agent_sessions4.FileSessionLogger(paths.logs),
+      permissionHandler: options.permissionHandler,
+      provider: options.provider,
+      onTextDelta: (delta) => this.handleTextDelta(delta),
+      onToolExecution: (event) => this.handleToolExecution(event),
+      sessionId
+    });
+    if (this.pendingRestoreMessages) {
+      for (const msg of this.pendingRestoreMessages) {
+        if (msg && typeof msg === "object" && "role" in msg && "content" in msg) {
+          this.session.injectMessage(
+            msg.role,
+            msg.content
+          );
+        }
+      }
+      this.pendingRestoreMessages = null;
+    }
+    this.initialized = true;
+  }
+  async ensureInitialized() {
+    if (this.initialized) return;
+    if (this.initPromise) await this.initPromise;
+  }
+  getSessionOrThrow() {
+    if (!this.session)
+      throw new Error("InteractiveSession not initialized. Call submit() or await initialization.");
+    return this.session;
+  }
+  // ── Event system ──────────────────────────────────────────────
+  on(event, handler) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(handler);
+  }
+  off(event, handler) {
+    this.listeners.get(event)?.delete(handler);
+  }
+  emit(event, ...args) {
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        handler(...args);
+      }
+    }
+  }
+  // ── Public API ────────────────────────────────────────────────
+  /** Submit a prompt. Queues if already executing (max 1 queued). */
+  async submit(input, displayInput, rawInput) {
+    await this.ensureInitialized();
+    if (this.executing) {
+      this.pendingPrompt = input;
+      this.pendingDisplayInput = displayInput;
+      this.pendingRawInput = rawInput;
+      return;
+    }
+    await this.executePrompt(input, displayInput, rawInput);
+  }
+  /** Execute a system command by name. Returns null if not found. */
+  async executeCommand(name, args) {
+    await this.ensureInitialized();
+    return this.commandExecutor.execute(name, this, args);
+  }
+  /** List all registered system commands. */
+  listCommands() {
+    return this.commandExecutor.listCommands().map((cmd) => ({
+      name: cmd.name,
+      description: cmd.description
+    }));
+  }
+  /** Abort current execution and clear queue. */
+  abort() {
+    this.pendingPrompt = null;
+    this.pendingDisplayInput = void 0;
+    this.pendingRawInput = void 0;
+    this.session?.abort();
+  }
+  /** Cancel queued prompt without aborting current execution. */
+  cancelQueue() {
+    this.pendingPrompt = null;
+    this.pendingDisplayInput = void 0;
+    this.pendingRawInput = void 0;
+  }
+  isExecuting() {
+    return this.executing;
+  }
+  getPendingPrompt() {
+    return this.pendingPrompt;
+  }
+  /** Get full history timeline (chat + events) for TUI rendering */
+  getFullHistory() {
+    return this.history;
+  }
+  /** Get chat messages only (backward compatible) */
+  getMessages() {
+    return this.history.filter((e) => e.category === "chat").map((e) => e.data);
+  }
+  getStreamingText() {
+    return this.streamingText;
+  }
+  getActiveTools() {
+    return this.activeTools;
+  }
+  getContextState() {
+    return this.getSessionOrThrow().getContextState();
+  }
+  /** Get session name. */
+  getName() {
+    return this.sessionName;
+  }
+  /** Set session name and persist if store is available. */
+  setName(name) {
+    this.sessionName = name;
+    if (this.sessionStore && this.session) {
+      try {
+        const id = this.getSessionOrThrow().getSessionId();
+        const existing = this.sessionStore.load(id);
+        if (existing) {
+          existing.name = name;
+          existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          this.sessionStore.save(existing);
+        }
+      } catch {
+      }
+    }
+  }
+  /** Attach a transport adapter to this session. Calls transport.attach(this). */
+  attachTransport(transport) {
+    transport.attach(this);
+  }
+  /** Access underlying Session. For advanced use / testing only. */
+  getSession() {
+    return this.getSessionOrThrow();
+  }
+  // ── Execution ─────────────────────────────────────────────────
+  async executePrompt(input, displayInput, rawInput) {
+    this.executing = true;
+    this.clearStreaming();
+    this.emit("thinking", true);
+    this.history.push((0, import_agent_core.messageToHistoryEntry)((0, import_agent_core.createUserMessage)(displayInput ?? input)));
+    const historyBefore = this.getSessionOrThrow().getHistory().length;
+    try {
+      const response = await this.getSessionOrThrow().run(input, rawInput);
+      this.flushStreaming();
+      this.pushToolSummaryMessage();
+      this.clearStreaming();
+      const result = this.buildResult(response || "(empty response)", historyBefore);
+      this.history.push((0, import_agent_core.messageToHistoryEntry)((0, import_agent_core.createAssistantMessage)(result.response)));
+      this.emit("complete", result);
+      this.emit("context_update", this.getContextState());
+    } catch (err) {
+      this.flushStreaming();
+      if (isAbortError(err)) {
+        const result = this.buildInterruptedResult(historyBefore);
+        this.pushToolSummaryMessage();
+        this.clearStreaming();
+        if (result.response) {
+          this.history.push((0, import_agent_core.messageToHistoryEntry)((0, import_agent_core.createAssistantMessage)(result.response)));
+        }
+        this.history.push((0, import_agent_core.messageToHistoryEntry)((0, import_agent_core.createSystemMessage)("Interrupted by user.")));
+        this.emit("interrupted", result);
+      } else {
+        this.pushToolSummaryMessage();
+        this.clearStreaming();
+        const errMsg = err instanceof Error ? err.message : String(err);
+        this.history.push((0, import_agent_core.messageToHistoryEntry)((0, import_agent_core.createSystemMessage)(`Error: ${errMsg}`)));
+        this.emit("error", err instanceof Error ? err : new Error(errMsg));
+      }
+    } finally {
+      this.executing = false;
+      this.emit("thinking", false);
+      if (this.sessionStore && this.session) {
+        try {
+          const sessionId = this.getSessionOrThrow().getSessionId();
+          const existing = this.sessionStore.load(sessionId);
+          this.sessionStore.save({
+            id: sessionId,
+            name: this.sessionName ?? existing?.name,
+            cwd: this.cwd ?? "",
+            createdAt: existing?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+            updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            messages: this.getSessionOrThrow().getHistory(),
+            history: this.history
+          });
+        } catch {
+        }
+      }
+      if (this.pendingPrompt) {
+        const queued = this.pendingPrompt;
+        const queuedDisplay = this.pendingDisplayInput;
+        const queuedRaw = this.pendingRawInput;
+        this.pendingPrompt = null;
+        this.pendingDisplayInput = void 0;
+        this.pendingRawInput = void 0;
+        setTimeout(() => this.executePrompt(queued, queuedDisplay, queuedRaw), 0);
+      }
+    }
+  }
+  // ── Streaming callbacks ───────────────────────────────────────
+  handleTextDelta(delta) {
+    this.streamingText += delta;
+    this.emit("text_delta", delta);
+    if (!this.flushTimer) {
+      this.flushTimer = setTimeout(() => {
+        this.flushTimer = null;
+      }, STREAMING_FLUSH_INTERVAL_MS);
+    }
+  }
+  handleToolExecution(event) {
+    if (event.type === "start") {
+      const firstArg = extractFirstArg(event.toolArgs);
+      const state = { toolName: event.toolName, firstArg, isRunning: true };
+      this.activeTools.push(state);
+      this.emit("tool_start", state);
+      this.history.push({
+        id: (0, import_node_crypto.randomUUID)(),
+        timestamp: /* @__PURE__ */ new Date(),
+        category: "event",
+        type: "tool-start",
+        data: { toolName: event.toolName, firstArg, isRunning: true }
+      });
+    } else {
+      const result = event.denied ? "denied" : event.success === false ? "error" : "success";
+      const idx = this.activeTools.findIndex((t) => t.toolName === event.toolName && t.isRunning);
+      if (idx !== -1) {
+        const finished = { ...this.activeTools[idx], isRunning: false, result };
+        this.activeTools[idx] = finished;
+        this.trimCompletedTools();
+        this.emit("tool_end", finished);
+        this.history.push({
+          id: (0, import_node_crypto.randomUUID)(),
+          timestamp: /* @__PURE__ */ new Date(),
+          category: "event",
+          type: "tool-end",
+          data: {
+            toolName: finished.toolName,
+            firstArg: finished.firstArg,
+            isRunning: false,
+            result
+          }
+        });
+      }
+    }
+  }
+  // ── Helpers ───────────────────────────────────────────────────
+  /** Push tool execution summary into messages (before Robota response).
+   *  Moves tool info from activeTools (real-time display) to messages (permanent display).
+   *  After this, activeTools will be cleared by clearStreaming(). */
+  pushToolSummaryMessage() {
+    if (this.activeTools.length === 0) return;
+    const summary = this.activeTools.map((t) => {
+      const status = t.isRunning ? "\u27F3" : t.result === "success" ? "\u2713" : t.result === "error" ? "\u2717" : "\u2298";
+      return `${status} ${t.toolName}${t.firstArg ? `(${t.firstArg})` : ""}`;
+    }).join("\n");
+    this.history.push({
+      id: (0, import_node_crypto.randomUUID)(),
+      timestamp: /* @__PURE__ */ new Date(),
+      category: "event",
+      type: "tool-summary",
+      data: {
+        tools: this.activeTools.map((t) => ({
+          toolName: t.toolName,
+          firstArg: t.firstArg,
+          isRunning: t.isRunning,
+          result: t.result
+        })),
+        summary
+      }
+    });
+  }
+  clearStreaming() {
+    this.streamingText = "";
+    this.activeTools = [];
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  flushStreaming() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  buildResult(response, historyBefore) {
+    const toolSummaries = this.extractToolSummaries(historyBefore);
+    return {
+      response,
+      history: this.history,
+      toolSummaries,
+      contextState: this.getContextState()
+    };
+  }
+  buildInterruptedResult(historyBefore) {
+    const history = this.getSessionOrThrow().getHistory();
+    const toolSummaries = this.extractToolSummaries(historyBefore);
+    const parts = [];
+    for (let i = historyBefore; i < history.length; i++) {
+      const msg = history[i];
+      if (msg?.role === "assistant" && msg.content) parts.push(msg.content);
+    }
+    return {
+      response: parts.join("\n\n"),
+      history: this.history,
+      toolSummaries,
+      contextState: this.getContextState()
+    };
+  }
+  extractToolSummaries(historyBefore) {
+    const history = this.getSessionOrThrow().getHistory();
+    const summaries = [];
+    for (let i = historyBefore; i < history.length; i++) {
+      const msg = history[i];
+      if (msg?.role === "assistant" && msg.toolCalls) {
+        for (const tc of msg.toolCalls) {
+          summaries.push({ name: tc.function.name, args: tc.function.arguments });
+        }
+      }
+    }
+    return summaries;
+  }
+  trimCompletedTools() {
+    const completed = this.activeTools.filter((t) => !t.isRunning);
+    if (completed.length > MAX_COMPLETED_TOOLS) {
+      const excess = completed.length - MAX_COMPLETED_TOOLS;
+      let removed = 0;
+      this.activeTools = this.activeTools.filter((t) => {
+        if (!t.isRunning && removed < excess) {
+          removed++;
+          return false;
+        }
+        return true;
+      });
+    }
+  }
+};
+function isAbortError(err) {
+  return err instanceof DOMException && err.name === "AbortError" || err instanceof Error && (err.message.includes("aborted") || err.message.includes("abort"));
+}
+function extractFirstArg(toolArgs) {
+  if (!toolArgs) return "";
+  const firstVal = Object.values(toolArgs)[0];
+  const raw = typeof firstVal === "string" ? firstVal : JSON.stringify(firstVal ?? "");
+  return raw.length > TOOL_ARG_DISPLAY_MAX ? raw.slice(0, TOOL_ARG_DISPLAY_MAX - TAIL_KEEP - 3) + "..." + raw.slice(-TAIL_KEEP) : raw;
+}
+var NOOP_TERMINAL = {
+  write: () => {
+  },
+  writeLine: () => {
+  },
+  writeMarkdown: () => {
+  },
+  writeError: () => {
+  },
+  prompt: () => Promise.resolve(""),
+  select: () => Promise.resolve(0),
+  spinner: () => ({ stop: () => {
+  }, update: () => {
+  } })
+};
+
+// src/query.ts
+function createQuery(options) {
+  const session = new InteractiveSession({
+    cwd: options.cwd ?? process.cwd(),
+    provider: options.provider,
+    permissionMode: options.permissionMode ?? "bypassPermissions",
+    maxTurns: options.maxTurns,
+    permissionHandler: options.permissionHandler
+  });
+  if (options.onTextDelta) {
+    session.on("text_delta", options.onTextDelta);
+  }
+  return async (prompt) => {
+    return new Promise((resolve2, reject) => {
+      const onComplete = (result) => {
+        cleanup();
+        resolve2(result.response);
+      };
+      const onInterrupted = (result) => {
+        cleanup();
+        resolve2(result.response);
+      };
+      const onError = (error) => {
+        cleanup();
+        reject(error);
+      };
+      const cleanup = () => {
+        session.off("complete", onComplete);
+        session.off("interrupted", onInterrupted);
+        session.off("error", onError);
+      };
+      session.on("complete", onComplete);
+      session.on("interrupted", onInterrupted);
+      session.on("error", onError);
+      session.submit(prompt).catch((err) => {
+        cleanup();
+        reject(err instanceof Error ? err : new Error(String(err)));
+      });
+    });
+  };
+}
+
+// src/commands/command-registry.ts
+var CommandRegistry = class {
+  sources = [];
+  addSource(source) {
+    this.sources.push(source);
+  }
+  /** Get all commands, optionally filtered by prefix */
+  getCommands(filter) {
+    const all = [];
+    for (const source of this.sources) {
+      all.push(...source.getCommands());
+    }
+    if (!filter) return all;
+    const lower = filter.toLowerCase();
+    return all.filter((cmd) => cmd.name.toLowerCase().startsWith(lower));
+  }
+  /** Resolve a short name to its fully qualified plugin:name form */
+  resolveQualifiedName(shortName) {
+    const matches = this.getCommands().filter(
+      (c) => c.source === "plugin" && c.name.includes(":") && c.name.endsWith(`:${shortName}`)
+    );
+    if (matches.length !== 1) return null;
+    return matches[0].name;
+  }
+  /** Get subcommands for a specific command */
+  getSubcommands(commandName) {
+    const lower = commandName.toLowerCase();
+    for (const source of this.sources) {
+      for (const cmd of source.getCommands()) {
+        if (cmd.name.toLowerCase() === lower && cmd.subcommands) {
+          return cmd.subcommands;
+        }
+      }
+    }
+    return [];
+  }
+};
+
+// src/commands/builtin-source.ts
+var import_agent_core2 = require("@robota-sdk/agent-core");
+function buildModelSubcommands() {
+  const seen = /* @__PURE__ */ new Set();
+  const commands = [];
+  for (const model of Object.values(import_agent_core2.CLAUDE_MODELS)) {
+    if (seen.has(model.name)) continue;
+    seen.add(model.name);
+    commands.push({
+      name: model.id,
+      description: `${model.name} (${(0, import_agent_core2.formatTokenCount)(model.contextWindow).toUpperCase()})`,
+      source: "builtin"
+    });
+  }
+  return commands;
+}
+function createBuiltinCommands() {
+  return [
+    { name: "help", description: "Show available commands", source: "builtin" },
+    { name: "clear", description: "Clear conversation history", source: "builtin" },
+    {
+      name: "mode",
+      description: "Permission mode",
+      source: "builtin",
+      subcommands: [
+        { name: "plan", description: "Plan only, no execution", source: "builtin" },
+        { name: "default", description: "Ask before risky actions", source: "builtin" },
+        { name: "acceptEdits", description: "Auto-approve file edits", source: "builtin" },
+        { name: "bypassPermissions", description: "Skip all permission checks", source: "builtin" }
+      ]
+    },
+    {
+      name: "model",
+      description: "Select AI model",
+      source: "builtin",
+      subcommands: buildModelSubcommands()
+    },
+    {
+      name: "language",
+      description: "Set response language",
+      source: "builtin",
+      subcommands: [
+        { name: "ko", description: "Korean", source: "builtin" },
+        { name: "en", description: "English", source: "builtin" },
+        { name: "ja", description: "Japanese", source: "builtin" },
+        { name: "zh", description: "Chinese", source: "builtin" }
+      ]
+    },
+    { name: "compact", description: "Compress context window", source: "builtin" },
+    { name: "cost", description: "Show session info", source: "builtin" },
+    { name: "context", description: "Context window info", source: "builtin" },
+    { name: "permissions", description: "Permission rules", source: "builtin" },
+    { name: "resume", description: "Resume a previous session", source: "builtin" },
+    { name: "rename", description: "Rename the current session", source: "builtin" },
+    { name: "plugin", description: "Manage plugins", source: "builtin" },
+    { name: "reload-plugins", description: "Reload all plugin resources", source: "builtin" },
+    { name: "reset", description: "Delete settings and exit", source: "builtin" },
+    { name: "exit", description: "Exit CLI", source: "builtin" }
+  ];
+}
+var BuiltinCommandSource = class {
+  name = "builtin";
+  commands;
+  constructor() {
+    this.commands = createBuiltinCommands();
+  }
+  getCommands() {
+    return this.commands;
+  }
+};
+
+// src/commands/skill-source.ts
+var import_node_fs7 = require("fs");
+var import_node_path10 = require("path");
+var import_node_os4 = require("os");
+var BOOLEAN_KEYS = /* @__PURE__ */ new Set(["disable-model-invocation", "user-invocable"]);
+var LIST_KEYS2 = /* @__PURE__ */ new Set(["allowed-tools"]);
+function kebabToCamel(key) {
+  return key.replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase());
+}
+function parseFrontmatter2(content) {
+  const lines = content.split("\n");
+  if (lines[0]?.trim() !== "---") return null;
+  const result = {};
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "---") break;
+    const match = line.match(/^([a-z][a-z0-9-]*):\s*(.+)/);
+    if (!match) continue;
+    const key = match[1];
+    const rawValue = match[2].trim();
+    const camelKey = kebabToCamel(key);
+    if (BOOLEAN_KEYS.has(key)) {
+      result[camelKey] = rawValue === "true";
+    } else if (LIST_KEYS2.has(key)) {
+      result[camelKey] = rawValue.split(",").map((s) => s.trim());
+    } else {
+      result[camelKey] = rawValue;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : null;
+}
+function buildCommand(frontmatter, content, fallbackName) {
+  const cmd = {
+    name: frontmatter?.name ?? fallbackName,
+    description: frontmatter?.description ?? `Skill: ${fallbackName}`,
+    source: "skill",
+    skillContent: content
+  };
+  if (frontmatter?.argumentHint !== void 0) cmd.argumentHint = frontmatter.argumentHint;
+  if (frontmatter?.disableModelInvocation !== void 0)
+    cmd.disableModelInvocation = frontmatter.disableModelInvocation;
+  if (frontmatter?.userInvocable !== void 0) cmd.userInvocable = frontmatter.userInvocable;
+  if (frontmatter?.allowedTools !== void 0) cmd.allowedTools = frontmatter.allowedTools;
+  if (frontmatter?.model !== void 0) cmd.model = frontmatter.model;
+  if (frontmatter?.effort !== void 0) cmd.effort = frontmatter.effort;
+  if (frontmatter?.context !== void 0) cmd.context = frontmatter.context;
+  if (frontmatter?.agent !== void 0) cmd.agent = frontmatter.agent;
+  return cmd;
+}
+function scanSkillsDir(skillsDir) {
+  if (!(0, import_node_fs7.existsSync)(skillsDir)) return [];
+  const commands = [];
+  const entries = (0, import_node_fs7.readdirSync)(skillsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillFile = (0, import_node_path10.join)(skillsDir, entry.name, "SKILL.md");
+    if (!(0, import_node_fs7.existsSync)(skillFile)) continue;
+    const content = (0, import_node_fs7.readFileSync)(skillFile, "utf-8");
+    const frontmatter = parseFrontmatter2(content);
+    commands.push(buildCommand(frontmatter, content, entry.name));
+  }
+  return commands;
+}
+function scanCommandsDir(commandsDir) {
+  if (!(0, import_node_fs7.existsSync)(commandsDir)) return [];
+  const commands = [];
+  const entries = (0, import_node_fs7.readdirSync)(commandsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+    const filePath = (0, import_node_path10.join)(commandsDir, entry.name);
+    const content = (0, import_node_fs7.readFileSync)(filePath, "utf-8");
+    const frontmatter = parseFrontmatter2(content);
+    const fallbackName = (0, import_node_path10.basename)(entry.name, ".md");
+    commands.push(buildCommand(frontmatter, content, fallbackName));
+  }
+  return commands;
+}
+var SkillCommandSource = class {
+  name = "skill";
+  cwd;
+  home;
+  cachedCommands = null;
+  constructor(cwd, home) {
+    this.cwd = cwd;
+    this.home = home ?? (0, import_node_os4.homedir)();
+  }
+  getCommands() {
+    if (this.cachedCommands) return this.cachedCommands;
+    const sources = [
+      scanSkillsDir((0, import_node_path10.join)(this.cwd, ".claude", "skills")),
+      scanCommandsDir((0, import_node_path10.join)(this.cwd, ".claude", "commands")),
+      scanSkillsDir((0, import_node_path10.join)(this.home, ".robota", "skills")),
+      scanSkillsDir((0, import_node_path10.join)(this.cwd, ".agents", "skills"))
+    ];
+    const seen = /* @__PURE__ */ new Set();
+    const merged = [];
+    for (const commands of sources) {
+      for (const cmd of commands) {
+        if (!seen.has(cmd.name)) {
+          seen.add(cmd.name);
+          merged.push(cmd);
+        }
+      }
+    }
+    this.cachedCommands = merged;
+    return this.cachedCommands;
+  }
+  getModelInvocableSkills() {
+    return this.getCommands().filter((cmd) => cmd.disableModelInvocation !== true);
+  }
+  getUserInvocableSkills() {
+    return this.getCommands().filter((cmd) => cmd.userInvocable !== false);
+  }
+};
+
+// src/commands/plugin-source.ts
+var PluginCommandSource = class {
+  name = "plugin";
+  plugins;
+  constructor(plugins) {
+    this.plugins = plugins;
+  }
+  getCommands() {
+    const commands = [];
+    for (const plugin of this.plugins) {
+      for (const skill of plugin.skills) {
+        const baseName = skill.name.includes("@") ? skill.name.split("@")[0] : skill.name;
+        commands.push({
+          name: baseName,
+          description: `(${plugin.manifest.name}) ${skill.description}`,
+          source: "plugin",
+          skillContent: skill.skillContent,
+          pluginDir: plugin.pluginDir
+        });
+      }
+      for (const cmd of plugin.commands) {
+        commands.push({
+          name: cmd.name,
+          description: cmd.description,
+          source: "plugin",
+          skillContent: cmd.skillContent,
+          pluginDir: plugin.pluginDir
+        });
+      }
+    }
+    return commands;
+  }
+};
+
+// src/utils/skill-prompt.ts
+var import_node_child_process3 = require("child_process");
+function substituteVariables(content, args, context) {
+  const argParts = args ? args.split(/\s+/) : [];
+  let result = content;
+  result = result.replace(/\$ARGUMENTS\[(\d+)]/g, (_match, index) => {
+    return argParts[Number(index)] ?? "";
+  });
+  result = result.replace(/\$ARGUMENTS/g, args);
+  result = result.replace(/\$(\d)(?!\d|\w|\[)/g, (_match, digit) => {
+    return argParts[Number(digit)] ?? "";
+  });
+  result = result.replace(/\$\{CLAUDE_SESSION_ID}/g, context?.sessionId ?? "");
+  result = result.replace(/\$\{CLAUDE_SKILL_DIR}/g, context?.skillDir ?? "");
+  return result;
+}
+async function preprocessShellCommands(content) {
+  const shellPattern = /!`([^`]+)`/g;
+  if (!shellPattern.test(content)) {
+    return content;
+  }
+  shellPattern.lastIndex = 0;
+  let result = content;
+  let match;
+  const matches = [];
+  while ((match = shellPattern.exec(content)) !== null) {
+    matches.push({ full: match[0], command: match[1] });
+  }
+  for (const { full, command } of matches) {
+    let output = "";
+    try {
+      output = (0, import_node_child_process3.execSync)(command, {
+        timeout: 5e3,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trimEnd();
+    } catch {
+      output = "";
+    }
+    result = result.replace(full, output);
+  }
+  return result;
+}
+async function buildSkillPrompt(input, registry, context) {
+  const parts = input.slice(1).split(/\s+/);
+  const cmd = parts[0]?.toLowerCase() ?? "";
+  const skillCmd = registry.getCommands().find((c) => c.name === cmd && (c.source === "skill" || c.source === "plugin"));
+  if (!skillCmd) return null;
+  const args = parts.slice(1).join(" ").trim();
+  const userInstruction = args || skillCmd.description;
+  if (skillCmd.skillContent) {
+    let processed = await preprocessShellCommands(skillCmd.skillContent);
+    processed = substituteVariables(processed, args, context);
+    return `<skill name="${cmd}">
+${processed}
+</skill>
+
+Execute the "${cmd}" skill: ${userInstruction}`;
+  }
+  return `Use the "${cmd}" skill: ${userInstruction}`;
+}
+
+// src/types.ts
+var import_agent_core3 = require("@robota-sdk/agent-core");
+
+// src/index.ts
+var import_agent_core4 = require("@robota-sdk/agent-core");
+var import_agent_core5 = require("@robota-sdk/agent-core");
+
+// src/permissions/permission-prompt.ts
+var import_chalk = __toESM(require("chalk"), 1);
+var PERMISSION_OPTIONS = ["Allow", "Deny"];
+var ALLOW_INDEX = 0;
+function formatArgs(toolArgs) {
+  const entries = Object.entries(toolArgs);
+  if (entries.length === 0) {
+    return "(no arguments)";
+  }
+  return entries.map(([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`).join(", ");
+}
+async function promptForApproval(terminal, toolName, toolArgs) {
+  terminal.writeLine("");
+  terminal.writeLine(import_chalk.default.yellow(`[Permission Required] Tool: ${toolName}`));
+  terminal.writeLine(import_chalk.default.dim(`  ${formatArgs(toolArgs)}`));
+  terminal.writeLine("");
+  const selected = await terminal.select(PERMISSION_OPTIONS, ALLOW_INDEX);
+  return selected === ALLOW_INDEX;
+}
 
 // src/index.ts
-var import_agent_tools3 = require("@robota-sdk/agent-tools");
-var import_agent_tools4 = require("@robota-sdk/agent-tools");
-var import_agent_tools5 = require("@robota-sdk/agent-tools");
-var import_agent_tools6 = require("@robota-sdk/agent-tools");
-var import_agent_tools7 = require("@robota-sdk/agent-tools");
-var import_agent_tools8 = require("@robota-sdk/agent-tools");
+var import_agent_core6 = require("@robota-sdk/agent-core");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DEFAULT_TOOL_DESCRIPTIONS,
-  FileSessionLogger,
-  Session,
-  SessionStore,
-  SilentSessionLogger,
+  AgentExecutor,
+  BUILT_IN_AGENTS,
+  BuiltinCommandSource,
+  BundlePluginInstaller,
+  BundlePluginLoader,
+  CommandRegistry,
+  InteractiveSession,
+  MarketplaceClient,
+  PluginCommandSource,
+  PluginSettingsStore,
+  PromptExecutor,
+  SkillCommandSource,
   TRUST_TO_MODE,
-  agentTool,
-  bashTool,
-  buildSystemPrompt,
-  createDefaultTools,
-  createProvider,
-  createSession,
-  detectProject,
-  editTool,
+  assembleSubagentPrompt,
+  buildSkillPrompt,
+  chatEntryToMessage,
+  createAgentTool,
+  createQuery,
+  createSubagentLogger,
+  createSubagentSession,
   evaluatePermission,
-  globTool,
-  grepTool,
-  loadConfig,
-  loadContext,
+  getBuiltInAgent,
+  getForkWorkerSuffix,
+  getMessagesForAPI,
+  getSubagentSuffix,
+  isChatEntry,
+  messageToHistoryEntry,
+  parseFrontmatter,
+  preprocessShellCommands,
   projectPaths,
   promptForApproval,
-  query,
-  readTool,
+  resolveSubagentLogDir,
+  retrieveAgentToolDeps,
   runHooks,
-  setAgentToolDeps,
-  userPaths,
-  writeTool
+  storeAgentToolDeps,
+  substituteVariables,
+  userPaths
 });