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

package/dist/node/index.js

@@ -1,8 +1,112 @@
-// src/types.ts
-import { TRUST_TO_MODE } from "@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
-import { Session } from "@robota-sdk/agent-sessions";
+import { Session as Session2 } from "@robota-sdk/agent-sessions";
 
 // src/context/system-prompt-builder.ts
 var TRUST_LEVEL_DESCRIPTIONS = {
@@ -33,17 +137,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(
     [
@@ -69,6 +194,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");
 }
 
@@ -105,96 +236,554 @@ function createDefaultTools() {
   ];
 }
 
-// src/assembly/create-provider.ts
-import { AnthropicProvider } from "@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
+import { z } from "zod";
+import { createZodFunctionTool } from "@robota-sdk/agent-tools";
+
+// src/agents/built-in-agents.ts
+var GENERAL_PURPOSE_SYSTEM_PROMPT = `You are a general-purpose task execution agent. You have access to all tools available in the parent session and can perform any task delegated to you.
+
+Your role is to complete the assigned task thoroughly and accurately. Follow these guidelines:
+
+- Execute the task as described in the prompt. Do not expand scope beyond what is requested.
+- Use the most appropriate tools for each step. Prefer precise tools (Read, Grep, Glob) over broad ones (Bash) when possible.
+- Report your findings clearly and concisely when the task is complete.
+- If a task cannot be completed, explain why and what information is missing.
+- Maintain the same code quality standards as the parent session (strict types, no fallbacks, proper error handling).`;
+var EXPLORE_SYSTEM_PROMPT = `You are a codebase exploration and analysis agent. Your purpose is to search, read, and understand code without making any modifications.
+
+You operate in read-only mode. You must NEVER attempt to write or edit files. Your tools are restricted to read-only operations: reading files, searching with grep and glob, and running non-destructive bash commands.
+
+Your role is to answer questions about the codebase by:
+
+- Searching for relevant files, symbols, and patterns using Glob and Grep.
+- Reading source files, configuration, and documentation to understand structure and behavior.
+- Tracing code paths across modules to understand how components interact.
+- Summarizing findings in a clear, structured format with file paths and line references.
+- Identifying architectural patterns, dependencies, and potential issues.
+
+When exploring, prefer targeted searches over broad scans. Start with the most likely locations and narrow down. Always include absolute file paths in your responses so the caller can navigate directly to relevant code.`;
+var PLAN_SYSTEM_PROMPT = `You are a planning, research, and architecture agent. Your purpose is to analyze requirements, research approaches, and produce structured plans without making any code modifications.
+
+You operate in read-only mode. You must NEVER attempt to write or edit files. Your tools are restricted to read-only operations.
+
+Your role is to:
+
+- Analyze the current codebase state relevant to the task by reading specs, source code, and tests.
+- Research implementation approaches by examining existing patterns and architectural conventions in the repository.
+- Identify affected files, modules, and interfaces that a proposed change would touch.
+- Assess risks, dependencies, and potential breaking changes.
+- Produce a structured implementation plan with clear steps, file lists, and ordering.
+- Consider edge cases, error handling, and test coverage requirements.
+
+Output your plan in a structured format with numbered steps. For each step, specify which files are involved and what changes are needed. Flag any decisions that require human judgment or clarification.`;
+var BUILT_IN_AGENTS = [
+  {
+    name: "general-purpose",
+    description: "General-purpose task execution agent with full tool access.",
+    systemPrompt: GENERAL_PURPOSE_SYSTEM_PROMPT
+  },
+  {
+    name: "Explore",
+    description: "Read-only codebase exploration and analysis agent.",
+    systemPrompt: EXPLORE_SYSTEM_PROMPT,
+    model: "claude-haiku-4-5",
+    disallowedTools: ["Write", "Edit"]
+  },
+  {
+    name: "Plan",
+    description: "Read-only planning, research, and architecture agent.",
+    systemPrompt: PLAN_SYSTEM_PROMPT,
+    disallowedTools: ["Write", "Edit"]
+  }
+];
+function getBuiltInAgent(name) {
+  return BUILT_IN_AGENTS.find((agent) => agent.name === name);
+}
+
+// src/assembly/create-subagent-session.ts
+import { Session } from "@robota-sdk/agent-sessions";
+
+// src/assembly/subagent-prompts.ts
+function getSubagentSuffix() {
+  return `When you complete the task, respond with a concise report covering what was done and any key findings \u2014 the caller will relay this to the user, so it only needs the essentials.
+
+In your final response, share file paths (always absolute, never relative) that are relevant to the task. Include code snippets only when the exact text is load-bearing \u2014 do not recap code you merely read.
+
+Do not use emojis.`;
+}
+function getForkWorkerSuffix() {
+  return `You are a worker subagent executing a specific task. Do NOT spawn sub-agents; execute directly. Keep your report under 500 words. Use this structure:
+- Scope: What was requested
+- Result: What was done
+- Key files: Relevant file paths (absolute)
+- Files changed: List of modifications
+- Issues: Any problems encountered`;
+}
+function assembleSubagentPrompt(options) {
+  const parts = [options.agentBody];
+  if (options.claudeMd) {
+    parts.push(options.claudeMd);
+  }
+  if (options.agentsMd) {
+    parts.push(options.agentsMd);
+  }
+  const suffix = options.isForkWorker ? getForkWorkerSuffix() : getSubagentSuffix();
+  parts.push(suffix);
+  return parts.join("\n\n");
+}
+
+// src/assembly/create-subagent-session.ts
+var MODEL_SHORTCUTS = {
+  sonnet: "claude-sonnet-4-6",
+  haiku: "claude-haiku-4-5",
+  opus: "claude-opus-4-6"
+};
+function resolveModelId(shortName, _parentModel) {
+  return MODEL_SHORTCUTS[shortName] ?? shortName;
+}
+function filterTools(parentTools, agentDefinition) {
+  let tools = [...parentTools];
+  if (agentDefinition.disallowedTools) {
+    const denySet = new Set(agentDefinition.disallowedTools);
+    tools = tools.filter((t) => !denySet.has(t.getName()));
+  }
+  if (agentDefinition.tools) {
+    const allowSet = new Set(agentDefinition.tools);
+    tools = tools.filter((t) => allowSet.has(t.getName()));
+  }
+  tools = tools.filter((t) => t.getName() !== "Agent");
+  return tools;
+}
+function createSubagentSession(options) {
+  const { agentDefinition, parentConfig, parentContext, parentTools, terminal } = options;
+  const tools = filterTools(parentTools, agentDefinition);
+  const model = agentDefinition.model ? resolveModelId(agentDefinition.model, parentConfig.provider.model) : parentConfig.provider.model;
+  const systemMessage = assembleSubagentPrompt({
+    agentBody: agentDefinition.systemPrompt,
+    claudeMd: parentContext.claudeMd,
+    agentsMd: parentContext.agentsMd,
+    isForkWorker: options.isForkWorker ?? false
+  });
+  const provider = options.provider;
+  return new Session({
+    tools,
+    provider,
+    systemMessage,
+    terminal,
+    model,
+    maxTurns: agentDefinition.maxTurns,
+    permissions: parentConfig.permissions,
+    permissionMode: options.permissionMode,
+    defaultTrustLevel: parentConfig.defaultTrustLevel,
+    permissionHandler: options.permissionHandler,
+    hooks: options.hooks,
+    hookTypeExecutors: options.hookTypeExecutors,
+    onTextDelta: options.onTextDelta,
+    onToolExecution: options.onToolExecution
+  });
+}
+
+// src/tools/agent-tool.ts
+function asZodSchema(schema) {
+  return schema;
+}
+var AgentSchema = z.object({
+  prompt: z.string().describe("The task for the subagent to perform"),
+  subagent_type: z.string().optional().describe('Agent type: "general-purpose", "Explore", "Plan", or a custom agent name'),
+  model: z.string().optional().describe("Optional model override")
+});
+var sessionDepsStore = /* @__PURE__ */ new WeakMap();
+function storeAgentToolDeps(key, deps) {
+  sessionDepsStore.set(key, deps);
+}
+function retrieveAgentToolDeps(key) {
+  return sessionDepsStore.get(key);
+}
+function resolveAgentDefinition(agentType, customRegistry) {
+  const builtIn = getBuiltInAgent(agentType);
+  if (builtIn) return builtIn;
+  if (customRegistry) return customRegistry(agentType);
+  return void 0;
+}
+function generateAgentId() {
+  return `agent_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function createAgentTool(deps) {
+  async function runAgent(args) {
+    const agentType = args.subagent_type ?? "general-purpose";
+    const agentDef = resolveAgentDefinition(agentType, deps.customAgentRegistry);
+    if (!agentDef) {
+      return JSON.stringify({
+        success: false,
+        output: "",
+        error: `Unknown agent type: ${agentType}`
+      });
+    }
+    const effectiveDef = args.model ? { ...agentDef, model: args.model } : agentDef;
+    const session = createSubagentSession({
+      agentDefinition: effectiveDef,
+      parentConfig: deps.config,
+      parentContext: deps.context,
+      parentTools: deps.tools,
+      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 createZodFunctionTool(
+    "Agent",
+    "Launch a subagent to handle a task in an isolated context. The subagent gets its own context window and returns a result when done. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.",
+    asZodSchema(AgentSchema),
+    async (params) => {
+      return runAgent(params);
+    }
+  );
+}
+
+// src/agents/agent-definition-loader.ts
+import { readdirSync, readFileSync, existsSync } from "fs";
+import { join, basename } from "path";
+import { homedir } from "os";
+var LIST_KEYS = /* @__PURE__ */ new Set(["tools", "disallowedTools"]);
+var NUMBER_KEYS = /* @__PURE__ */ new Set(["maxTurns"]);
+function parseFrontmatter(content) {
+  const lines = content.split("\n");
+  if (lines[0]?.trim() !== "---") {
+    return { frontmatter: null, body: content };
+  }
+  let endIndex = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i]?.trim() === "---") {
+      endIndex = i;
+      break;
+    }
+  }
+  if (endIndex === -1) {
+    return { frontmatter: null, body: content };
+  }
+  const result = {};
+  for (let i = 1; i < endIndex; i++) {
+    const line = lines[i];
+    const match = line.match(/^([a-zA-Z][a-zA-Z0-9]*(?:[A-Z][a-z]*)*):\s*(.+)/);
+    if (!match) continue;
+    const key = match[1];
+    const rawValue = match[2].trim();
+    if (LIST_KEYS.has(key)) {
+      result[key] = rawValue.split(",").map((s) => s.trim());
+    } else if (NUMBER_KEYS.has(key)) {
+      result[key] = parseInt(rawValue, 10);
+    } else {
+      result[key] = rawValue;
+    }
+  }
+  const body = lines.slice(endIndex + 1).join("\n").trim();
+  return {
+    frontmatter: Object.keys(result).length > 0 ? result : null,
+    body
+  };
+}
+function scanAgentsDir(dir) {
+  if (!existsSync(dir)) return [];
+  const agents = [];
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+    const filePath = join(dir, entry.name);
+    const content = readFileSync(filePath, "utf-8");
+    const { frontmatter, body } = parseFrontmatter(content);
+    const fallbackName = basename(entry.name, ".md");
+    const agent = {
+      name: frontmatter?.name ?? fallbackName,
+      description: frontmatter?.description ?? "",
+      systemPrompt: body
+    };
+    if (frontmatter?.model !== void 0) agent.model = frontmatter.model;
+    if (frontmatter?.maxTurns !== void 0) agent.maxTurns = frontmatter.maxTurns;
+    if (frontmatter?.tools !== void 0) agent.tools = frontmatter.tools;
+    if (frontmatter?.disallowedTools !== void 0)
+      agent.disallowedTools = frontmatter.disallowedTools;
+    agents.push(agent);
   }
-  return new AnthropicProvider({ apiKey });
+  return agents;
 }
+var AgentDefinitionLoader = class {
+  cwd;
+  home;
+  constructor(cwd, home) {
+    this.cwd = cwd;
+    this.home = home ?? homedir();
+  }
+  /** Load all agent definitions, merged with built-in agents. Custom overrides built-in on name collision. */
+  loadAll() {
+    const sources = [
+      scanAgentsDir(join(this.cwd, ".claude", "agents")),
+      scanAgentsDir(join(this.home, ".robota", "agents"))
+    ];
+    const seen = /* @__PURE__ */ new Set();
+    const customAgents = [];
+    for (const agents of sources) {
+      for (const agent of agents) {
+        if (!seen.has(agent.name)) {
+          seen.add(agent.name);
+          customAgents.push(agent);
+        }
+      }
+    }
+    const result = [...customAgents];
+    for (const builtIn of BUILT_IN_AGENTS) {
+      if (!seen.has(builtIn.name)) {
+        result.push(builtIn);
+      }
+    }
+    return result;
+  }
+  /** Get a specific agent by name (custom or built-in). */
+  getAgent(name) {
+    return this.loadAll().find((agent) => agent.name === name);
+  }
+};
 
 // src/assembly/create-session.ts
 function createSession(options) {
-  const provider = options.provider ?? createProvider(options.config);
+  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 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 Session2({
     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
-import { Session as Session2 } from "@robota-sdk/agent-sessions";
-import { FileSessionLogger, SilentSessionLogger } from "@robota-sdk/agent-sessions";
-import { SessionStore } from "@robota-sdk/agent-sessions";
+// src/assembly/subagent-logger.ts
+import { mkdirSync } from "fs";
+import { join as join2 } from "path";
+import { FileSessionLogger } from "@robota-sdk/agent-sessions";
+function createSubagentLogger(parentSessionId, _agentId, baseLogsDir) {
+  const subagentDir = join2(baseLogsDir, parentSessionId, "subagents");
+  mkdirSync(subagentDir, { recursive: true });
+  return new FileSessionLogger(subagentDir);
+}
+function resolveSubagentLogDir(parentSessionId, baseLogsDir) {
+  return join2(baseLogsDir, parentSessionId, "subagents");
+}
+
+// src/interactive/interactive-session.ts
+import { FileSessionLogger as FileSessionLogger2 } from "@robota-sdk/agent-sessions";
+
+// src/paths.ts
+import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+function projectPaths(cwd) {
+  const base = join3(cwd, ".robota");
+  return {
+    settings: join3(base, "settings.json"),
+    settingsLocal: join3(base, "settings.local.json"),
+    logs: join3(base, "logs"),
+    sessions: join3(base, "sessions")
+  };
+}
+function userPaths() {
+  const base = join3(homedir2(), ".robota");
+  return {
+    settings: join3(base, "settings.json"),
+    sessions: join3(base, "sessions")
+  };
+}
 
 // src/config/config-loader.ts
-import { readFileSync, existsSync } from "fs";
-import { join } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join4 } from "path";
 
 // src/config/config-types.ts
-import { z } from "zod";
-var ProviderSchema = z.object({
-  name: z.string().optional(),
-  model: z.string().optional(),
-  apiKey: z.string().optional()
+import { z as z2 } from "zod";
+var ProviderSchema = z2.object({
+  name: z2.string().optional(),
+  model: z2.string().optional(),
+  apiKey: z2.string().optional()
 });
-var PermissionsSchema = z.object({
+var PermissionsSchema = z2.object({
   /** Patterns that are always approved without prompting */
-  allow: z.array(z.string()).optional(),
+  allow: z2.array(z2.string()).optional(),
   /** Patterns that are always denied */
-  deny: z.array(z.string()).optional()
+  deny: z2.array(z2.string()).optional()
+});
+var EnvSchema = z2.record(z2.string()).optional();
+var CommandHookDefinitionSchema = z2.object({
+  type: z2.literal("command"),
+  command: z2.string(),
+  timeout: z2.number().optional()
+});
+var HttpHookDefinitionSchema = z2.object({
+  type: z2.literal("http"),
+  url: z2.string(),
+  headers: z2.record(z2.string()).optional(),
+  timeout: z2.number().optional()
+});
+var PromptHookDefinitionSchema = z2.object({
+  type: z2.literal("prompt"),
+  prompt: z2.string(),
+  model: z2.string().optional()
 });
-var EnvSchema = z.record(z.string()).optional();
-var HookDefinitionSchema = z.object({
-  type: z.literal("command"),
-  command: z.string()
+var AgentHookDefinitionSchema = z2.object({
+  type: z2.literal("agent"),
+  agent: z2.string(),
+  maxTurns: z2.number().optional(),
+  timeout: z2.number().optional()
 });
-var HookGroupSchema = z.object({
-  matcher: z.string(),
-  hooks: z.array(HookDefinitionSchema)
+var HookDefinitionSchema = z2.discriminatedUnion("type", [
+  CommandHookDefinitionSchema,
+  HttpHookDefinitionSchema,
+  PromptHookDefinitionSchema,
+  AgentHookDefinitionSchema
+]);
+var HookGroupSchema = z2.object({
+  matcher: z2.string(),
+  hooks: z2.array(HookDefinitionSchema)
 });
-var HooksSchema = z.object({
-  PreToolUse: z.array(HookGroupSchema).optional(),
-  PostToolUse: z.array(HookGroupSchema).optional(),
-  SessionStart: z.array(HookGroupSchema).optional(),
-  Stop: z.array(HookGroupSchema).optional()
+var HooksSchema = z2.object({
+  PreToolUse: z2.array(HookGroupSchema).optional(),
+  PostToolUse: z2.array(HookGroupSchema).optional(),
+  SessionStart: z2.array(HookGroupSchema).optional(),
+  Stop: z2.array(HookGroupSchema).optional(),
+  PreCompact: z2.array(HookGroupSchema).optional(),
+  PostCompact: z2.array(HookGroupSchema).optional(),
+  UserPromptSubmit: z2.array(HookGroupSchema).optional(),
+  Notification: z2.array(HookGroupSchema).optional()
 }).optional();
-var SettingsSchema = z.object({
+var EnabledPluginsSchema = z2.record(z2.boolean()).optional();
+var MarketplaceSourceSchema = z2.object({
+  source: z2.object({
+    type: z2.enum(["github", "git", "local", "url"]),
+    repo: z2.string().optional(),
+    url: z2.string().optional(),
+    path: z2.string().optional(),
+    ref: z2.string().optional()
+  })
+});
+var ExtraKnownMarketplacesSchema = z2.record(MarketplaceSourceSchema).optional();
+var SettingsSchema = z2.object({
   /** Trust level used when no --permission-mode flag is given */
-  defaultTrustLevel: z.enum(["safe", "moderate", "full"]).optional(),
+  defaultTrustLevel: z2.enum(["safe", "moderate", "full"]).optional(),
+  /** Response language (e.g., "ko", "en", "ja"). Injected into system prompt. */
+  language: z2.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
@@ -215,11 +804,18 @@ var DEFAULTS = {
   env: {}
 };
 function readJsonFile(filePath) {
-  if (!existsSync(filePath)) {
+  if (!existsSync2(filePath)) {
+    return void 0;
+  }
+  const raw = readFileSync2(filePath, "utf-8").trim();
+  if (raw.length === 0) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
     return void 0;
   }
-  const raw = readFileSync(filePath, "utf-8");
-  return JSON.parse(raw);
 }
 function resolveEnvRef(value) {
   const ENV_PREFIX = "$ENV:";
@@ -254,13 +850,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,
@@ -271,25 +870,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 [
+    join4(home, ".robota", "settings.json"),
+    // 1. user (lowest)
+    join4(cwd, ".robota", "settings.json"),
+    // 2. project
+    join4(cwd, ".robota", "settings.local.json"),
+    // 3. project-local
+    join4(cwd, ".claude", "settings.json"),
+    // 4. project, Claude Code compat
+    join4(cwd, ".claude", "settings.local.json")
+    // 5. project-local (highest)
+  ];
+}
 async function loadConfig(cwd) {
-  const userSettingsPath = join(getHomeDir(), ".robota", "settings.json");
-  const projectSettingsPath = join(cwd, ".robota", "settings.json");
-  const localSettingsPath = 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);
   });
@@ -298,8 +911,8 @@ async function loadConfig(cwd) {
 }
 
 // src/context/context-loader.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { join as join2, dirname, resolve } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join5, dirname, resolve } from "path";
 var AGENTS_FILENAME = "AGENTS.md";
 var CLAUDE_FILENAME = "CLAUDE.md";
 function collectFilesWalkingUp(startDir, filename) {
@@ -307,8 +920,8 @@ function collectFilesWalkingUp(startDir, filename) {
   let current = resolve(startDir);
   let atRoot = false;
   while (!atRoot) {
-    const candidate = join2(current, filename);
-    if (existsSync2(candidate)) {
+    const candidate = join5(current, filename);
+    if (existsSync3(candidate)) {
       found.push(candidate);
     }
     const parent = dirname(current);
@@ -346,47 +959,47 @@ function extractCompactInstructions(content) {
 async function loadContext(cwd) {
   const agentsPaths = collectFilesWalkingUp(cwd, AGENTS_FILENAME);
   const claudePaths = collectFilesWalkingUp(cwd, CLAUDE_FILENAME);
-  const agentsMd = agentsPaths.map((p) => readFileSync2(p, "utf-8")).join("\n\n");
-  const claudeMd = claudePaths.map((p) => readFileSync2(p, "utf-8")).join("\n\n");
+  const agentsMd = agentsPaths.map((p) => readFileSync3(p, "utf-8")).join("\n\n");
+  const claudeMd = claudePaths.map((p) => readFileSync3(p, "utf-8")).join("\n\n");
   const compactInstructions = extractCompactInstructions(claudeMd);
   return { agentsMd, claudeMd, compactInstructions };
 }
 
 // src/context/project-detector.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { join as join6 } from "path";
 function tryReadJson(filePath) {
-  if (!existsSync3(filePath)) return void 0;
+  if (!existsSync4(filePath)) return void 0;
   try {
-    return JSON.parse(readFileSync3(filePath, "utf-8"));
+    return JSON.parse(readFileSync4(filePath, "utf-8"));
   } catch {
     return void 0;
   }
 }
 function detectPackageManager(cwd) {
-  if (existsSync3(join3(cwd, "pnpm-workspace.yaml")) || existsSync3(join3(cwd, "pnpm-lock.yaml"))) {
+  if (existsSync4(join6(cwd, "pnpm-workspace.yaml")) || existsSync4(join6(cwd, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (existsSync3(join3(cwd, "yarn.lock"))) {
+  if (existsSync4(join6(cwd, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync3(join3(cwd, "bun.lockb"))) {
+  if (existsSync4(join6(cwd, "bun.lockb"))) {
     return "bun";
   }
-  if (existsSync3(join3(cwd, "package-lock.json"))) {
+  if (existsSync4(join6(cwd, "package-lock.json"))) {
     return "npm";
   }
   return void 0;
 }
 async function detectProject(cwd) {
-  const pkgJsonPath = join3(cwd, "package.json");
-  const tsconfigPath = join3(cwd, "tsconfig.json");
-  const pyprojectPath = join3(cwd, "pyproject.toml");
-  const cargoPath = join3(cwd, "Cargo.toml");
-  const goModPath = join3(cwd, "go.mod");
-  if (existsSync3(pkgJsonPath)) {
+  const pkgJsonPath = join6(cwd, "package.json");
+  const tsconfigPath = join6(cwd, "tsconfig.json");
+  const pyprojectPath = join6(cwd, "pyproject.toml");
+  const cargoPath = join6(cwd, "Cargo.toml");
+  const goModPath = join6(cwd, "go.mod");
+  if (existsSync4(pkgJsonPath)) {
     const pkgJson = tryReadJson(pkgJsonPath);
-    const language = existsSync3(tsconfigPath) ? "typescript" : "javascript";
+    const language = existsSync4(tsconfigPath) ? "typescript" : "javascript";
     const packageManager = detectPackageManager(cwd);
     return {
       type: "node",
@@ -395,19 +1008,19 @@ async function detectProject(cwd) {
       language
     };
   }
-  if (existsSync3(pyprojectPath) || existsSync3(join3(cwd, "setup.py"))) {
+  if (existsSync4(pyprojectPath) || existsSync4(join6(cwd, "setup.py"))) {
     return {
       type: "python",
       language: "python"
     };
   }
-  if (existsSync3(cargoPath)) {
+  if (existsSync4(cargoPath)) {
     return {
       type: "rust",
       language: "rust"
     };
   }
-  if (existsSync3(goModPath)) {
+  if (existsSync4(goModPath)) {
     return {
       type: "go",
       language: "go"
@@ -419,195 +1032,2000 @@ async function detectProject(cwd) {
   };
 }
 
-// src/permissions/permission-prompt.ts
-import chalk from "chalk";
-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(chalk.yellow(`[Permission Required] Tool: ${toolName}`));
-  terminal.writeLine(chalk.dim(`  ${formatArgs(toolArgs)}`));
-  terminal.writeLine("");
-  const selected = await terminal.select(PERMISSION_OPTIONS, ALLOW_INDEX);
-  return selected === ALLOW_INDEX;
-}
+// src/interactive/interactive-session.ts
+import {
+  createUserMessage,
+  createAssistantMessage,
+  createSystemMessage,
+  messageToHistoryEntry
+} from "@robota-sdk/agent-core";
+import { randomUUID } from "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
-import { evaluatePermission } from "@robota-sdk/agent-core";
-import { runHooks } from "@robota-sdk/agent-core";
-
-// src/paths.ts
-import { join as join4 } from "path";
-import { homedir } from "os";
-function projectPaths(cwd) {
-  const base = join4(cwd, ".robota");
-  return {
-    settings: join4(base, "settings.json"),
-    settingsLocal: join4(base, "settings.local.json"),
-    logs: join4(base, "logs"),
-    sessions: join4(base, "sessions")
-  };
-}
-function userPaths() {
-  const base = join4(homedir(), ".robota");
-  return {
-    settings: join4(base, "settings.json"),
-    sessions: join4(base, "sessions")
-  };
-}
-
-// src/tools/agent-tool.ts
-import { z as z2 } from "zod";
-import { createZodFunctionTool } from "@robota-sdk/agent-tools";
-function asZodSchema(schema) {
-  return schema;
-}
-var AgentSchema = z2.object({
-  prompt: z2.string().describe("Task description for the sub-agent"),
-  description: z2.string().optional().describe("Short description of what the sub-agent will do (3-5 words)")
-});
-var agentToolDeps;
-function setAgentToolDeps(deps) {
-  agentToolDeps = deps;
-}
-async function runAgent(args) {
-  if (!agentToolDeps) {
-    const result = {
-      success: false,
-      output: "",
-      error: "Agent tool not initialized \u2014 missing dependencies"
-    };
-    return JSON.stringify(result);
-  }
-  const noopTerminal = {
-    write: () => {
+    {
+      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);
-  }
-}
-var agentTool = createZodFunctionTool(
-  "Agent",
-  "Spawn a sub-agent with isolated context to handle a task. The sub-agent has its own conversation history and can use all tools.",
-  asZodSchema(AgentSchema),
-  async (params) => {
-    return runAgent(params);
-  }
-);
-
-// src/index.ts
-import { bashTool as bashTool2 } from "@robota-sdk/agent-tools";
-import { readTool as readTool2 } from "@robota-sdk/agent-tools";
-import { writeTool as writeTool2 } from "@robota-sdk/agent-tools";
-import { editTool as editTool2 } from "@robota-sdk/agent-tools";
-import { globTool as globTool2 } from "@robota-sdk/agent-tools";
-import { grepTool as grepTool2 } from "@robota-sdk/agent-tools";
+    {
+      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 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
+import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+var PluginSettingsStore = class {
+  settingsPath;
+  constructor(settingsPath) {
+    this.settingsPath = settingsPath;
+  }
+  /** Read the full settings file from disk. */
+  readAll() {
+    if (!existsSync5(this.settingsPath)) {
+      return {};
+    }
+    try {
+      const raw = readFileSync5(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 = dirname2(this.settingsPath);
+    if (!existsSync5(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    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
+import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
+import { join as join7 } from "path";
+function parseSkillFrontmatter(raw) {
+  const trimmed = raw.trimStart();
+  if (!trimmed.startsWith("---")) {
+    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 (!existsSync6(dirPath)) return [];
+  try {
+    const entries = readdirSync2(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 = join7(this.pluginsDir, "cache");
+    if (!existsSync6(cacheDir)) {
+      return [];
+    }
+    const results = [];
+    const marketplaces = getSortedSubdirs(cacheDir);
+    for (const marketplace of marketplaces) {
+      const marketplaceDir = join7(cacheDir, marketplace);
+      const plugins = getSortedSubdirs(marketplaceDir);
+      for (const pluginName of plugins) {
+        const pluginDir = join7(marketplaceDir, pluginName);
+        const versions = getSortedSubdirs(pluginDir);
+        if (versions.length === 0) continue;
+        const latestVersion = versions[versions.length - 1];
+        const versionDir = join7(pluginDir, latestVersion);
+        const manifestPath = join7(versionDir, ".claude-plugin", "plugin.json");
+        if (!existsSync6(manifestPath)) continue;
+        const manifest = this.readManifest(manifestPath);
+        if (!manifest) continue;
+        const pluginId = `${manifest.name}@${marketplace}`;
+        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 = readFileSync6(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 = join7(pluginDir, "skills");
+    if (!existsSync6(skillsDir)) return [];
+    const entries = readdirSync2(skillsDir, { withFileTypes: true });
+    const skills = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillFile = join7(skillsDir, entry.name, "SKILL.md");
+      if (!existsSync6(skillFile)) continue;
+      const raw = readFileSync6(skillFile, "utf-8");
+      const { metadata, content } = parseSkillFrontmatter(raw);
+      const description = typeof metadata.description === "string" ? metadata.description : "";
+      const skill = {
+        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 = join7(pluginDir, "commands");
+    if (!existsSync6(commandsDir)) return [];
+    const entries = readdirSync2(commandsDir, { withFileTypes: true });
+    const commands = [];
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+      const raw = readFileSync6(join7(commandsDir, entry.name), "utf-8");
+      const { metadata, content } = parseSkillFrontmatter(raw);
+      const name = typeof metadata.name === "string" ? metadata.name : entry.name.replace(/\.md$/, "");
+      const description = typeof metadata.description === "string" ? metadata.description : "";
+      commands.push({
+        ...metadata,
+        name: `${pluginName}:${name}`,
+        description,
+        skillContent: content
+      });
+    }
+    return commands;
+  }
+  /** Load hooks from hooks/hooks.json if present. */
+  loadHooks(pluginDir) {
+    const hooksPath = join7(pluginDir, "hooks", "hooks.json");
+    if (!existsSync6(hooksPath)) return {};
+    try {
+      const raw = readFileSync6(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 = join7(pluginDir, ".mcp.json");
+    const fallbackPath = join7(pluginDir, ".claude-plugin", "mcp.json");
+    const mcpPath = existsSync6(primaryPath) ? primaryPath : fallbackPath;
+    if (!existsSync6(mcpPath)) return void 0;
+    try {
+      const raw = readFileSync6(mcpPath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  /** Load agent definitions from agents/ directory if present. */
+  loadAgents(pluginDir) {
+    const agentsDir = join7(pluginDir, "agents");
+    if (!existsSync6(agentsDir)) return [];
+    try {
+      const entries = readdirSync2(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
+import { execSync } from "child_process";
+import { cpSync, existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync7, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join8, dirname as dirname3 } from "path";
+var GIT_CLONE_TIMEOUT_MS = 6e4;
+var BundlePluginInstaller = class {
+  pluginsDir;
+  cacheDir;
+  registryPath;
+  settingsStore;
+  marketplaceClient;
+  exec;
+  constructor(options) {
+    this.pluginsDir = options.pluginsDir;
+    this.cacheDir = join8(this.pluginsDir, "cache");
+    this.registryPath = join8(this.pluginsDir, "installed_plugins.json");
+    this.settingsStore = options.settingsStore;
+    this.marketplaceClient = options.marketplaceClient;
+    this.exec = options.exec ?? this.defaultExec;
+  }
+  /**
+   * 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 = join8(this.cacheDir, marketplaceName, pluginName, version);
+    if (existsSync7(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 (existsSync7(record.installPath)) {
+      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) {
+    mkdirSync3(targetDir, { recursive: true });
+    const source = this.normalizeSource(rawSource);
+    try {
+      if (typeof source === "string") {
+        const marketplaceDir = this.marketplaceClient.getMarketplaceDir(marketplaceName);
+        const sourcePath = join8(marketplaceDir, source);
+        if (!existsSync7(sourcePath)) {
+          throw new Error(
+            `Plugin source path "${source}" not found in marketplace "${marketplaceName}"`
+          );
+        }
+        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 (existsSync7(targetDir)) {
+        rmSync(targetDir, { recursive: true, force: true });
+      }
+      throw err;
+    }
+  }
+  /** Clone a git repository to the target directory. */
+  cloneToDir(repoUrl, targetDir, pluginName) {
+    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 (!existsSync7(this.registryPath)) {
+      return {};
+    }
+    try {
+      const raw = readFileSync7(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 = dirname3(this.registryPath);
+    if (!existsSync7(dir)) {
+      mkdirSync3(dir, { recursive: true });
+    }
+    writeFileSync2(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
+  }
+  /** Default exec implementation using child_process. */
+  defaultExec(command, options) {
+    return execSync(command, { timeout: options.timeout, stdio: "pipe" });
+  }
+};
+
+// src/plugins/marketplace-client.ts
+import { execSync as execSync2 } from "child_process";
+import {
+  cpSync as cpSync2,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync8,
+  renameSync,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { join as join9, dirname as dirname4 } from "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 = join9(this.pluginsDir, "marketplaces");
+    this.registryPath = join9(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 = join9(this.marketplacesDir, tempName);
+    mkdirSync4(this.marketplacesDir, { recursive: true });
+    if (source.type === "local") {
+      if (!existsSync8(source.path)) {
+        throw new Error(`Local marketplace path does not exist: ${source.path}`);
+      }
+      cpSync2(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 = join9(tempDir, ".claude-plugin", "marketplace.json");
+    if (!existsSync8(manifestPath)) {
+      rmSync2(tempDir, { recursive: true, force: true });
+      throw new Error(
+        source.type === "local" ? "Local directory does not contain .claude-plugin/marketplace.json" : "Cloned repository does not contain .claude-plugin/marketplace.json"
+      );
+    }
+    const manifest = this.readManifestFromPath(manifestPath);
+    const name = manifest.name;
+    if (!name) {
+      rmSync2(tempDir, { recursive: true, force: true });
+      throw new Error('Marketplace manifest does not contain a "name" field');
+    }
+    const registry = this.readRegistry();
+    if (registry[name]) {
+      rmSync2(tempDir, { recursive: true, force: true });
+      throw new Error(`Marketplace "${name}" already exists`);
+    }
+    const finalDir = join9(this.marketplacesDir, name);
+    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 (existsSync8(entry.installLocation)) {
+      rmSync2(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 (!existsSync8(entry.installLocation)) {
+      throw new Error(`Marketplace directory for "${name}" does not exist`);
+    }
+    if (entry.source.type === "local") {
+      const localSource = entry.source;
+      if (!existsSync8(localSource.path)) {
+        throw new Error(`Local marketplace path does not exist: ${localSource.path}`);
+      }
+      rmSync2(entry.installLocation, { recursive: true, force: true });
+      cpSync2(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 = join9(entry.installLocation, ".claude-plugin", "marketplace.json");
+    if (!existsSync8(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 = join9(this.pluginsDir, "installed_plugins.json");
+    if (!existsSync8(installedPath)) return;
+    let registry;
+    try {
+      const raw = readFileSync8(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 && existsSync8(record.installPath)) {
+          rmSync2(record.installPath, { recursive: true, force: true });
+        }
+        delete registry[pluginId];
+        changed = true;
+      }
+    }
+    if (changed) {
+      const dir = dirname4(installedPath);
+      if (!existsSync8(dir)) {
+        mkdirSync4(dir, { recursive: true });
+      }
+      writeFileSync3(installedPath, JSON.stringify(registry, null, 2), "utf-8");
+    }
+  }
+  /** Read and parse a marketplace.json from a file path. */
+  readManifestFromPath(path) {
+    const raw = readFileSync8(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 (!existsSync8(this.registryPath)) {
+      return {};
+    }
+    try {
+      const raw = readFileSync8(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 = dirname4(this.registryPath);
+    if (!existsSync8(dir)) {
+      mkdirSync4(dir, { recursive: true });
+    }
+    writeFileSync3(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
+  }
+  /** Default exec implementation using child_process. */
+  defaultExec(command, options) {
+    return execSync2(command, { timeout: options.timeout, stdio: "pipe" });
+  }
+};
+
+// src/plugins/plugin-hooks-merger.ts
+import { join as join10, dirname as dirname5 } from "path";
+function buildPluginEnv(plugin) {
+  const dataDir = join10(dirname5(dirname5(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
+import { homedir as homedir3 } from "os";
+import { join as join11 } from "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 = join11(homedir3(), ".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 FileSessionLogger2(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(messageToHistoryEntry(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(messageToHistoryEntry(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(messageToHistoryEntry(createAssistantMessage(result.response)));
+        }
+        this.history.push(messageToHistoryEntry(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(messageToHistoryEntry(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: 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: 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: 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
+import { CLAUDE_MODELS, formatTokenCount } from "@robota-sdk/agent-core";
+function buildModelSubcommands() {
+  const seen = /* @__PURE__ */ new Set();
+  const commands = [];
+  for (const model of Object.values(CLAUDE_MODELS)) {
+    if (seen.has(model.name)) continue;
+    seen.add(model.name);
+    commands.push({
+      name: model.id,
+      description: `${model.name} (${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
+import { readdirSync as readdirSync3, readFileSync as readFileSync9, existsSync as existsSync9 } from "fs";
+import { join as join12, basename as basename2 } from "path";
+import { homedir as homedir4 } from "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 (!existsSync9(skillsDir)) return [];
+  const commands = [];
+  const entries = readdirSync3(skillsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillFile = join12(skillsDir, entry.name, "SKILL.md");
+    if (!existsSync9(skillFile)) continue;
+    const content = readFileSync9(skillFile, "utf-8");
+    const frontmatter = parseFrontmatter2(content);
+    commands.push(buildCommand(frontmatter, content, entry.name));
+  }
+  return commands;
+}
+function scanCommandsDir(commandsDir) {
+  if (!existsSync9(commandsDir)) return [];
+  const commands = [];
+  const entries = readdirSync3(commandsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+    const filePath = join12(commandsDir, entry.name);
+    const content = readFileSync9(filePath, "utf-8");
+    const frontmatter = parseFrontmatter2(content);
+    const fallbackName = basename2(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 ?? homedir4();
+  }
+  getCommands() {
+    if (this.cachedCommands) return this.cachedCommands;
+    const sources = [
+      scanSkillsDir(join12(this.cwd, ".claude", "skills")),
+      scanCommandsDir(join12(this.cwd, ".claude", "commands")),
+      scanSkillsDir(join12(this.home, ".robota", "skills")),
+      scanSkillsDir(join12(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
+import { execSync as execSync3 } from "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 = execSync3(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
+import { TRUST_TO_MODE } from "@robota-sdk/agent-core";
+
+// src/index.ts
+import {
+  isChatEntry,
+  chatEntryToMessage,
+  messageToHistoryEntry as messageToHistoryEntry2,
+  getMessagesForAPI
+} from "@robota-sdk/agent-core";
+import { evaluatePermission } from "@robota-sdk/agent-core";
+
+// src/permissions/permission-prompt.ts
+import chalk from "chalk";
+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(chalk.yellow(`[Permission Required] Tool: ${toolName}`));
+  terminal.writeLine(chalk.dim(`  ${formatArgs(toolArgs)}`));
+  terminal.writeLine("");
+  const selected = await terminal.select(PERMISSION_OPTIONS, ALLOW_INDEX);
+  return selected === ALLOW_INDEX;
+}
+
+// src/index.ts
+import { runHooks } from "@robota-sdk/agent-core";
 export {
-  DEFAULT_TOOL_DESCRIPTIONS,
-  FileSessionLogger,
-  Session2 as Session,
-  SessionStore,
-  SilentSessionLogger,
+  AgentExecutor,
+  BUILT_IN_AGENTS,
+  BuiltinCommandSource,
+  BundlePluginInstaller,
+  BundlePluginLoader,
+  CommandRegistry,
+  InteractiveSession,
+  MarketplaceClient,
+  PluginCommandSource,
+  PluginSettingsStore,
+  PromptExecutor,
+  SkillCommandSource,
   TRUST_TO_MODE,
-  agentTool,
-  bashTool2 as bashTool,
-  buildSystemPrompt,
-  createDefaultTools,
-  createProvider,
-  createSession,
-  detectProject,
-  editTool2 as editTool,
+  assembleSubagentPrompt,
+  buildSkillPrompt,
+  chatEntryToMessage,
+  createAgentTool,
+  createQuery,
+  createSubagentLogger,
+  createSubagentSession,
   evaluatePermission,
-  globTool2 as globTool,
-  grepTool2 as grepTool,
-  loadConfig,
-  loadContext,
+  getBuiltInAgent,
+  getForkWorkerSuffix,
+  getMessagesForAPI,
+  getSubagentSuffix,
+  isChatEntry,
+  messageToHistoryEntry2 as messageToHistoryEntry,
+  parseFrontmatter2 as parseFrontmatter,
+  preprocessShellCommands,
   projectPaths,
   promptForApproval,
-  query,
-  readTool2 as readTool,
+  resolveSubagentLogDir,
+  retrieveAgentToolDeps,
   runHooks,
-  setAgentToolDeps,
-  userPaths,
-  writeTool2 as writeTool
+  storeAgentToolDeps,
+  substituteVariables,
+  userPaths
 };