@robota-sdk/agent-sdk 3.0.0-beta.43 → 3.0.0-beta.45

package/dist/node/index.cjs

@@ -36,55 +36,40 @@ __export(index_exports, {
   BundlePluginInstaller: () => BundlePluginInstaller,
   BundlePluginLoader: () => BundlePluginLoader,
   CommandRegistry: () => CommandRegistry,
-  DEFAULT_TOOL_DESCRIPTIONS: () => DEFAULT_TOOL_DESCRIPTIONS,
-  FileSessionLogger: () => import_agent_sessions6.FileSessionLogger,
   InteractiveSession: () => InteractiveSession,
   MarketplaceClient: () => MarketplaceClient,
+  PluginCommandSource: () => PluginCommandSource,
   PluginSettingsStore: () => PluginSettingsStore,
   PromptExecutor: () => PromptExecutor,
-  Session: () => import_agent_sessions5.Session,
-  SessionStore: () => import_agent_sessions7.SessionStore,
-  SilentSessionLogger: () => import_agent_sessions6.SilentSessionLogger,
   SkillCommandSource: () => SkillCommandSource,
-  SystemCommandExecutor: () => SystemCommandExecutor,
-  TRUST_TO_MODE: () => import_agent_core.TRUST_TO_MODE,
+  TRUST_TO_MODE: () => import_agent_core3.TRUST_TO_MODE,
   assembleSubagentPrompt: () => assembleSubagentPrompt,
-  bashTool: () => import_agent_tools3.bashTool,
-  buildSystemPrompt: () => buildSystemPrompt,
+  buildSkillPrompt: () => buildSkillPrompt,
+  chatEntryToMessage: () => import_agent_core4.chatEntryToMessage,
   createAgentTool: () => createAgentTool,
-  createDefaultTools: () => createDefaultTools,
-  createProvider: () => createProvider,
-  createSession: () => createSession,
+  createQuery: () => createQuery,
   createSubagentLogger: () => createSubagentLogger,
   createSubagentSession: () => createSubagentSession,
-  createSystemCommands: () => createSystemCommands,
-  detectProject: () => detectProject,
-  editTool: () => import_agent_tools6.editTool,
-  evaluatePermission: () => import_agent_core4.evaluatePermission,
+  evaluatePermission: () => import_agent_core5.evaluatePermission,
   getBuiltInAgent: () => getBuiltInAgent,
   getForkWorkerSuffix: () => getForkWorkerSuffix,
+  getMessagesForAPI: () => import_agent_core4.getMessagesForAPI,
   getSubagentSuffix: () => getSubagentSuffix,
-  globTool: () => import_agent_tools7.globTool,
-  grepTool: () => import_agent_tools8.grepTool,
-  loadConfig: () => loadConfig,
-  loadContext: () => loadContext,
+  isChatEntry: () => import_agent_core4.isChatEntry,
+  messageToHistoryEntry: () => import_agent_core4.messageToHistoryEntry,
   parseFrontmatter: () => parseFrontmatter2,
+  preprocessShellCommands: () => preprocessShellCommands,
   projectPaths: () => projectPaths,
   promptForApproval: () => promptForApproval,
-  query: () => query,
-  readTool: () => import_agent_tools4.readTool,
   resolveSubagentLogDir: () => resolveSubagentLogDir,
   retrieveAgentToolDeps: () => retrieveAgentToolDeps,
-  runHooks: () => import_agent_core5.runHooks,
+  runHooks: () => import_agent_core6.runHooks,
   storeAgentToolDeps: () => storeAgentToolDeps,
-  userPaths: () => userPaths,
-  writeTool: () => import_agent_tools5.writeTool
+  substituteVariables: () => substituteVariables,
+  userPaths: () => userPaths
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/types.ts
-var import_agent_core = require("@robota-sdk/agent-core");
-
 // src/hooks/prompt-executor.ts
 function extractJson(raw) {
   const codeBlockMatch = /```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/.exec(raw);
@@ -314,18 +299,6 @@ function createDefaultTools() {
   ];
 }
 
-// src/assembly/create-provider.ts
-var import_agent_provider_anthropic = require("@robota-sdk/agent-provider-anthropic");
-function createProvider(config) {
-  const apiKey = config.provider.apiKey ?? process.env["ANTHROPIC_API_KEY"];
-  if (!apiKey) {
-    throw new Error(
-      "ANTHROPIC_API_KEY is not set. Set the environment variable or configure provider.apiKey in ~/.robota/settings.json"
-    );
-  }
-  return new import_agent_provider_anthropic.AnthropicProvider({ apiKey });
-}
-
 // src/tools/agent-tool.ts
 var import_zod = require("zod");
 var import_agent_tools2 = require("@robota-sdk/agent-tools");
@@ -455,7 +428,7 @@ function createSubagentSession(options) {
     agentsMd: parentContext.agentsMd,
     isForkWorker: options.isForkWorker ?? false
   });
-  const provider = createProvider(parentConfig);
+  const provider = options.provider;
   return new import_agent_sessions.Session({
     tools,
     provider,
@@ -516,6 +489,7 @@ function createAgentTool(deps) {
       parentConfig: deps.config,
       parentContext: deps.context,
       parentTools: deps.tools,
+      provider: deps.provider,
       terminal: deps.terminal,
       permissionMode: deps.permissionMode,
       permissionHandler: deps.permissionHandler,
@@ -662,7 +636,12 @@ var AgentDefinitionLoader = class {
 
 // 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());
@@ -690,6 +669,7 @@ function createSession(options) {
     context: options.context,
     tools,
     terminal: options.terminal,
+    provider,
     permissionMode: options.permissionMode,
     permissionHandler: options.permissionHandler,
     hooks: options.config.hooks,
@@ -759,10 +739,28 @@ function resolveSubagentLogDir(parentSessionId, baseLogsDir) {
   return (0, import_node_path2.join)(baseLogsDir, parentSessionId, "subagents");
 }
 
-// src/index.ts
-var import_agent_sessions5 = require("@robota-sdk/agent-sessions");
-var import_agent_sessions6 = require("@robota-sdk/agent-sessions");
-var import_agent_sessions7 = require("@robota-sdk/agent-sessions");
+// src/interactive/interactive-session.ts
+var import_agent_sessions4 = require("@robota-sdk/agent-sessions");
+
+// src/paths.ts
+var import_node_path3 = require("path");
+var import_node_os2 = require("os");
+function projectPaths(cwd) {
+  const base = (0, import_node_path3.join)(cwd, ".robota");
+  return {
+    settings: (0, import_node_path3.join)(base, "settings.json"),
+    settingsLocal: (0, import_node_path3.join)(base, "settings.local.json"),
+    logs: (0, import_node_path3.join)(base, "logs"),
+    sessions: (0, import_node_path3.join)(base, "sessions")
+  };
+}
+function userPaths() {
+  const base = (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".robota");
+  return {
+    settings: (0, import_node_path3.join)(base, "settings.json"),
+    sessions: (0, import_node_path3.join)(base, "sessions")
+  };
+}
 
 // src/config/config-loader.ts
 var import_fs = require("fs");
@@ -1096,89 +1094,207 @@ async function detectProject(cwd) {
   };
 }
 
-// src/permissions/permission-prompt.ts
-var import_chalk = __toESM(require("chalk"), 1);
-var PERMISSION_OPTIONS = ["Allow", "Deny"];
-var ALLOW_INDEX = 0;
-function formatArgs(toolArgs) {
-  const entries = Object.entries(toolArgs);
-  if (entries.length === 0) {
-    return "(no arguments)";
-  }
-  return entries.map(([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`).join(", ");
-}
-async function promptForApproval(terminal, toolName, toolArgs) {
-  terminal.writeLine("");
-  terminal.writeLine(import_chalk.default.yellow(`[Permission Required] Tool: ${toolName}`));
-  terminal.writeLine(import_chalk.default.dim(`  ${formatArgs(toolArgs)}`));
-  terminal.writeLine("");
-  const selected = await terminal.select(PERMISSION_OPTIONS, ALLOW_INDEX);
-  return selected === ALLOW_INDEX;
-}
+// src/interactive/interactive-session.ts
+var import_agent_core = require("@robota-sdk/agent-core");
+var import_node_crypto = require("crypto");
 
-// src/query.ts
-async function query(prompt, options) {
-  const cwd = options?.cwd ?? process.cwd();
-  const [config, context, projectInfo] = await Promise.all([
-    loadConfig(cwd),
-    loadContext(cwd),
-    detectProject(cwd)
-  ]);
-  const noopTerminal = {
-    write: () => {
+// src/commands/system-command.ts
+var VALID_MODES = ["plan", "default", "acceptEdits", "bypassPermissions"];
+function createSystemCommands() {
+  return [
+    {
+      name: "help",
+      description: "Show available commands",
+      execute: (_session, _args) => ({
+        message: [
+          "Available commands:",
+          "  help              \u2014 Show this help",
+          "  clear             \u2014 Clear conversation",
+          "  compact [instr]   \u2014 Compact context (optional focus instructions)",
+          "  mode [m]          \u2014 Show/change permission mode",
+          "  model <id>        \u2014 Change AI model",
+          "  language <code>   \u2014 Set response language (ko, en, ja, zh)",
+          "  cost              \u2014 Show session info",
+          "  context           \u2014 Context window info",
+          "  permissions       \u2014 Permission rules",
+          "  reset             \u2014 Delete settings and exit"
+        ].join("\n"),
+        success: true
+      })
+    },
+    {
+      name: "clear",
+      description: "Clear conversation history",
+      execute: (session, _args) => {
+        const underlying = session.getSession();
+        underlying.clearHistory();
+        return { message: "Conversation cleared.", success: true };
+      }
+    },
+    {
+      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 }
+        };
+      }
+    },
+    {
+      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
+        };
+      }
+    },
+    {
+      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 session = createSession({
-    config,
-    context,
-    terminal: noopTerminal,
-    projectInfo,
-    permissionMode: options?.permissionMode ?? "bypassPermissions",
-    maxTurns: options?.maxTurns,
-    provider: options?.provider,
-    permissionHandler: options?.permissionHandler,
-    onTextDelta: options?.onTextDelta,
-    onCompact: options?.onCompact,
-    compactInstructions: context.compactInstructions,
-    promptForApproval
-  });
-  return session.run(prompt);
-}
-
-// src/index.ts
-var import_agent_core4 = require("@robota-sdk/agent-core");
-var import_agent_core5 = require("@robota-sdk/agent-core");
-
-// src/paths.ts
-var import_node_path3 = require("path");
-var import_node_os2 = require("os");
-function projectPaths(cwd) {
-  const base = (0, import_node_path3.join)(cwd, ".robota");
-  return {
-    settings: (0, import_node_path3.join)(base, "settings.json"),
-    settingsLocal: (0, import_node_path3.join)(base, "settings.local.json"),
-    logs: (0, import_node_path3.join)(base, "logs"),
-    sessions: (0, import_node_path3.join)(base, "sessions")
-  };
-}
-function userPaths() {
-  const base = (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".robota");
-  return {
-    settings: (0, import_node_path3.join)(base, "settings.json"),
-    sessions: (0, import_node_path3.join)(base, "sessions")
-  };
+    {
+      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: "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
 var import_node_fs3 = require("fs");
@@ -1975,478 +2091,163 @@ var MarketplaceClient = class {
   }
 };
 
-// src/commands/command-registry.ts
-var CommandRegistry = class {
-  sources = [];
-  addSource(source) {
-    this.sources.push(source);
+// src/plugins/plugin-hooks-merger.ts
+var import_node_path8 = require("path");
+function buildPluginEnv(plugin) {
+  const dataDir = (0, import_node_path8.join)((0, import_node_path8.dirname)((0, import_node_path8.dirname)(plugin.pluginDir)), "data", plugin.manifest.name);
+  return {
+    CLAUDE_PLUGIN_ROOT: plugin.pluginDir,
+    CLAUDE_PLUGIN_PATH: plugin.pluginDir,
+    CLAUDE_PLUGIN_DATA: dataDir
+  };
+}
+function resolvePluginRoot(group, pluginDir) {
+  if (Array.isArray(group.hooks)) {
+    return {
+      ...group,
+      hooks: group.hooks.map((h) => {
+        if (typeof h.command === "string") {
+          return {
+            ...h,
+            command: h.command.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, pluginDir)
+          };
+        }
+        return h;
+      })
+    };
   }
-  /** Get all commands, optionally filtered by prefix */
-  getCommands(filter) {
-    const all = [];
-    for (const source of this.sources) {
-      all.push(...source.getCommands());
+  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);
     }
-    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;
+  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];
   }
-  /** 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;
-        }
-      }
+  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 [];
-  }
-};
-
-// src/commands/builtin-source.ts
-var import_agent_core2 = require("@robota-sdk/agent-core");
-function buildModelSubcommands() {
-  const seen = /* @__PURE__ */ new Set();
-  const commands = [];
-  for (const model of Object.values(import_agent_core2.CLAUDE_MODELS)) {
-    if (seen.has(model.name)) continue;
-    seen.add(model.name);
-    commands.push({
-      name: model.id,
-      description: `${model.name} (${(0, import_agent_core2.formatTokenCount)(model.contextWindow).toUpperCase()})`,
-      source: "builtin"
-    });
   }
-  return commands;
-}
-function createBuiltinCommands() {
-  return [
-    { name: "help", description: "Show available commands", source: "builtin" },
-    { name: "clear", description: "Clear conversation history", source: "builtin" },
-    {
-      name: "mode",
-      description: "Permission mode",
-      source: "builtin",
-      subcommands: [
-        { name: "plan", description: "Plan only, no execution", source: "builtin" },
-        { name: "default", description: "Ask before risky actions", source: "builtin" },
-        { name: "acceptEdits", description: "Auto-approve file edits", source: "builtin" },
-        { name: "bypassPermissions", description: "Skip all permission checks", source: "builtin" }
-      ]
-    },
-    {
-      name: "model",
-      description: "Select AI model",
-      source: "builtin",
-      subcommands: buildModelSubcommands()
-    },
-    {
-      name: "language",
-      description: "Set response language",
-      source: "builtin",
-      subcommands: [
-        { name: "ko", description: "Korean", source: "builtin" },
-        { name: "en", description: "English", source: "builtin" },
-        { name: "ja", description: "Japanese", source: "builtin" },
-        { name: "zh", description: "Chinese", source: "builtin" }
-      ]
-    },
-    { name: "compact", description: "Compress context window", source: "builtin" },
-    { name: "cost", description: "Show session info", source: "builtin" },
-    { name: "context", description: "Context window info", source: "builtin" },
-    { name: "permissions", description: "Permission rules", source: "builtin" },
-    { name: "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" }
-  ];
+  return merged;
 }
-var BuiltinCommandSource = class {
-  name = "builtin";
-  commands;
-  constructor() {
-    this.commands = createBuiltinCommands();
-  }
-  getCommands() {
-    return this.commands;
-  }
-};
 
-// src/commands/skill-source.ts
-var import_node_fs7 = require("fs");
-var import_node_path8 = require("path");
+// src/interactive/interactive-session.ts
 var import_node_os3 = require("os");
-var BOOLEAN_KEYS = /* @__PURE__ */ new Set(["disable-model-invocation", "user-invocable"]);
-var LIST_KEYS2 = /* @__PURE__ */ new Set(["allowed-tools"]);
-function kebabToCamel(key) {
-  return key.replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase());
-}
-function parseFrontmatter2(content) {
-  const lines = content.split("\n");
-  if (lines[0]?.trim() !== "---") return null;
-  const result = {};
-  for (let i = 1; i < lines.length; i++) {
-    const line = lines[i];
-    if (line.trim() === "---") break;
-    const match = line.match(/^([a-z][a-z0-9-]*):\s*(.+)/);
-    if (!match) continue;
-    const key = match[1];
-    const rawValue = match[2].trim();
-    const camelKey = kebabToCamel(key);
-    if (BOOLEAN_KEYS.has(key)) {
-      result[camelKey] = rawValue === "true";
-    } else if (LIST_KEYS2.has(key)) {
-      result[camelKey] = rawValue.split(",").map((s) => s.trim());
+var import_node_path9 = require("path");
+var TOOL_ARG_DISPLAY_MAX = 80;
+var TAIL_KEEP = 30;
+var MAX_COMPLETED_TOOLS = 50;
+var STREAMING_FLUSH_INTERVAL_MS = 16;
+var InteractiveSession = class {
+  session = null;
+  commandExecutor;
+  listeners = /* @__PURE__ */ new Map();
+  initialized = false;
+  initPromise = null;
+  // Streaming state
+  streamingText = "";
+  flushTimer = null;
+  // Tool state
+  activeTools = [];
+  // Execution state
+  executing = false;
+  pendingPrompt = null;
+  pendingDisplayInput;
+  pendingRawInput;
+  // Full history timeline (chat messages + events)
+  history = [];
+  constructor(options) {
+    this.commandExecutor = new SystemCommandExecutor(createSystemCommands());
+    if ("session" in options && options.session) {
+      this.session = options.session;
+      this.initialized = true;
     } else {
-      result[camelKey] = rawValue;
+      const stdOpts = options;
+      this.initPromise = this.initializeAsync(stdOpts);
+    }
+  }
+  async initializeAsync(options) {
+    const cwd = options.cwd;
+    const [config, context, projectInfo] = await Promise.all([
+      loadConfig(cwd),
+      loadContext(cwd),
+      detectProject(cwd)
+    ]);
+    const pluginsDir = (0, import_node_path9.join)((0, import_node_os3.homedir)(), ".robota", "plugins");
+    const pluginLoader = new BundlePluginLoader(pluginsDir);
+    let mergedConfig = config;
+    try {
+      const plugins = pluginLoader.loadPluginsSync();
+      if (plugins.length > 0) {
+        const pluginHooks = mergePluginHooks(plugins);
+        mergedConfig = {
+          ...config,
+          hooks: mergeHooksIntoConfig(
+            config.hooks,
+            pluginHooks
+          )
+        };
+      }
+    } catch {
     }
+    const paths = projectPaths(cwd);
+    this.session = createSession({
+      config: mergedConfig,
+      context,
+      projectInfo,
+      permissionMode: options.permissionMode,
+      maxTurns: options.maxTurns,
+      terminal: NOOP_TERMINAL,
+      sessionLogger: new import_agent_sessions4.FileSessionLogger(paths.logs),
+      permissionHandler: options.permissionHandler,
+      provider: options.provider,
+      onTextDelta: (delta) => this.handleTextDelta(delta),
+      onToolExecution: (event) => this.handleToolExecution(event)
+    });
+    this.initialized = true;
   }
-  return Object.keys(result).length > 0 ? result : null;
-}
-function buildCommand(frontmatter, content, fallbackName) {
-  const cmd = {
-    name: frontmatter?.name ?? fallbackName,
-    description: frontmatter?.description ?? `Skill: ${fallbackName}`,
-    source: "skill",
-    skillContent: content
-  };
-  if (frontmatter?.argumentHint !== void 0) cmd.argumentHint = frontmatter.argumentHint;
-  if (frontmatter?.disableModelInvocation !== void 0)
-    cmd.disableModelInvocation = frontmatter.disableModelInvocation;
-  if (frontmatter?.userInvocable !== void 0) cmd.userInvocable = frontmatter.userInvocable;
-  if (frontmatter?.allowedTools !== void 0) cmd.allowedTools = frontmatter.allowedTools;
-  if (frontmatter?.model !== void 0) cmd.model = frontmatter.model;
-  if (frontmatter?.effort !== void 0) cmd.effort = frontmatter.effort;
-  if (frontmatter?.context !== void 0) cmd.context = frontmatter.context;
-  if (frontmatter?.agent !== void 0) cmd.agent = frontmatter.agent;
-  return cmd;
-}
-function scanSkillsDir(skillsDir) {
-  if (!(0, import_node_fs7.existsSync)(skillsDir)) return [];
-  const commands = [];
-  const entries = (0, import_node_fs7.readdirSync)(skillsDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const skillFile = (0, import_node_path8.join)(skillsDir, entry.name, "SKILL.md");
-    if (!(0, import_node_fs7.existsSync)(skillFile)) continue;
-    const content = (0, import_node_fs7.readFileSync)(skillFile, "utf-8");
-    const frontmatter = parseFrontmatter2(content);
-    commands.push(buildCommand(frontmatter, content, entry.name));
-  }
-  return commands;
-}
-function scanCommandsDir(commandsDir) {
-  if (!(0, import_node_fs7.existsSync)(commandsDir)) return [];
-  const commands = [];
-  const entries = (0, import_node_fs7.readdirSync)(commandsDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const filePath = (0, import_node_path8.join)(commandsDir, entry.name);
-    const content = (0, import_node_fs7.readFileSync)(filePath, "utf-8");
-    const frontmatter = parseFrontmatter2(content);
-    const fallbackName = (0, import_node_path8.basename)(entry.name, ".md");
-    commands.push(buildCommand(frontmatter, content, fallbackName));
+  async ensureInitialized() {
+    if (this.initialized) return;
+    if (this.initPromise) await this.initPromise;
   }
-  return commands;
-}
-var SkillCommandSource = class {
-  name = "skill";
-  cwd;
-  home;
-  cachedCommands = null;
-  constructor(cwd, home) {
-    this.cwd = cwd;
-    this.home = home ?? (0, import_node_os3.homedir)();
+  getSessionOrThrow() {
+    if (!this.session)
+      throw new Error("InteractiveSession not initialized. Call submit() or await initialization.");
+    return this.session;
   }
-  getCommands() {
-    if (this.cachedCommands) return this.cachedCommands;
-    const sources = [
-      scanSkillsDir((0, import_node_path8.join)(this.cwd, ".claude", "skills")),
-      scanCommandsDir((0, import_node_path8.join)(this.cwd, ".claude", "commands")),
-      scanSkillsDir((0, import_node_path8.join)(this.home, ".robota", "skills")),
-      scanSkillsDir((0, import_node_path8.join)(this.cwd, ".agents", "skills"))
-    ];
-    const seen = /* @__PURE__ */ new Set();
-    const merged = [];
-    for (const commands of sources) {
-      for (const cmd of commands) {
-        if (!seen.has(cmd.name)) {
-          seen.add(cmd.name);
-          merged.push(cmd);
-        }
-      }
+  // ── Event system ──────────────────────────────────────────────
+  on(event, handler) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
     }
-    this.cachedCommands = merged;
-    return this.cachedCommands;
+    this.listeners.get(event).add(handler);
   }
-  getModelInvocableSkills() {
-    return this.getCommands().filter((cmd) => cmd.disableModelInvocation !== true);
-  }
-  getUserInvocableSkills() {
-    return this.getCommands().filter((cmd) => cmd.userInvocable !== false);
-  }
-};
-
-// 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",
-          "  reset             \u2014 Delete settings and exit"
-        ].join("\n"),
-        success: true
-      })
-    },
-    {
-      name: "clear",
-      description: "Clear conversation history",
-      execute: (session, _args) => {
-        const underlying = session.getSession();
-        underlying.clearHistory();
-        return { message: "Conversation cleared.", success: true };
-      }
-    },
-    {
-      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 }
-        };
-      }
-    },
-    {
-      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
-        };
-      }
-    },
-    {
-      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 }
-        };
-      }
-    },
-    {
-      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 }
-        };
-      }
-    },
-    {
-      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 }
-        };
-      }
-    },
-    {
-      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
-          }
-        };
-      }
-    },
-    {
-      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: "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/interactive/interactive-session.ts
-var import_agent_sessions4 = require("@robota-sdk/agent-sessions");
-var import_agent_core3 = require("@robota-sdk/agent-core");
-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;
-  listeners = /* @__PURE__ */ new Map();
-  // Streaming state
-  streamingText = "";
-  flushTimer = null;
-  // Tool state
-  activeTools = [];
-  // Execution state
-  executing = false;
-  pendingPrompt = null;
-  pendingDisplayInput;
-  pendingRawInput;
-  // Display messages (what clients render — not the raw session history)
-  messages = [];
-  constructor(options) {
-    if (options.session) {
-      this.session = options.session;
-    } else {
-      const cwd = options.cwd ?? process.cwd();
-      const paths = projectPaths(cwd);
-      this.session = createSession({
-        config: options.config,
-        context: options.context,
-        projectInfo: options.projectInfo,
-        sessionStore: options.sessionStore,
-        permissionMode: options.permissionMode,
-        maxTurns: options.maxTurns,
-        terminal: NOOP_TERMINAL,
-        sessionLogger: new import_agent_sessions4.FileSessionLogger(paths.logs),
-        permissionHandler: options.permissionHandler,
-        onTextDelta: (delta) => this.handleTextDelta(delta),
-        onToolExecution: (event) => this.handleToolExecution(event)
-      });
-    }
-  }
-  // ── 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);
+  off(event, handler) {
+    this.listeners.get(event)?.delete(handler);
   }
   emit(event, ...args) {
     const handlers = this.listeners.get(event);
@@ -2457,10 +2258,9 @@ var InteractiveSession = class {
     }
   }
   // ── Public API ────────────────────────────────────────────────
-  /** Submit a prompt. Queues if already executing (max 1 queued).
-   *  displayInput overrides what appears as the user message (e.g., "/audit" instead of full skill prompt).
-   *  rawInput is passed to Session.run() for hook matching (e.g., "/rulebased-harness:audit"). */
+  /** 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;
@@ -2469,14 +2269,30 @@ var InteractiveSession = class {
     }
     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.session.abort();
+    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;
@@ -2484,8 +2300,13 @@ var InteractiveSession = class {
   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.messages;
+    return this.history.filter((e) => e.category === "chat").map((e) => e.data);
   }
   getStreamingText() {
     return this.streamingText;
@@ -2494,39 +2315,44 @@ var InteractiveSession = class {
     return this.activeTools;
   }
   getContextState() {
-    return this.session.getContextState();
+    return this.getSessionOrThrow().getContextState();
   }
+  /** Access underlying Session. For advanced use / testing only. */
   getSession() {
-    return this.session;
+    return this.getSessionOrThrow();
   }
   // ── Execution ─────────────────────────────────────────────────
   async executePrompt(input, displayInput, rawInput) {
     this.executing = true;
     this.clearStreaming();
     this.emit("thinking", true);
-    this.messages.push((0, import_agent_core3.createUserMessage)(displayInput ?? input));
-    const historyBefore = this.session.getHistory().length;
+    this.history.push((0, import_agent_core.messageToHistoryEntry)((0, import_agent_core.createUserMessage)(displayInput ?? input)));
+    const historyBefore = this.getSessionOrThrow().getHistory().length;
     try {
-      const response = await this.session.run(input, rawInput);
+      const response = await this.getSessionOrThrow().run(input, rawInput);
       this.flushStreaming();
+      this.pushToolSummaryMessage();
       this.clearStreaming();
       const result = this.buildResult(response || "(empty response)", historyBefore);
-      this.messages.push((0, import_agent_core3.createAssistantMessage)(result.response));
+      this.history.push((0, import_agent_core.messageToHistoryEntry)((0, import_agent_core.createAssistantMessage)(result.response)));
       this.emit("complete", result);
       this.emit("context_update", this.getContextState());
     } catch (err) {
       this.flushStreaming();
-      this.clearStreaming();
       if (isAbortError(err)) {
         const result = this.buildInterruptedResult(historyBefore);
+        this.pushToolSummaryMessage();
+        this.clearStreaming();
         if (result.response) {
-          this.messages.push((0, import_agent_core3.createAssistantMessage)(result.response));
+          this.history.push((0, import_agent_core.messageToHistoryEntry)((0, import_agent_core.createAssistantMessage)(result.response)));
         }
-        this.messages.push((0, import_agent_core3.createSystemMessage)("Interrupted by user."));
+        this.history.push((0, import_agent_core.messageToHistoryEntry)((0, import_agent_core.createSystemMessage)("Interrupted by user.")));
         this.emit("interrupted", result);
       } else {
+        this.pushToolSummaryMessage();
+        this.clearStreaming();
         const errMsg = err instanceof Error ? err.message : String(err);
-        this.messages.push((0, import_agent_core3.createSystemMessage)(`Error: ${errMsg}`));
+        this.history.push((0, import_agent_core.messageToHistoryEntry)((0, import_agent_core.createSystemMessage)(`Error: ${errMsg}`)));
         this.emit("error", err instanceof Error ? err : new Error(errMsg));
       }
     } finally {
@@ -2556,22 +2382,14 @@ var InteractiveSession = class {
   handleToolExecution(event) {
     if (event.type === "start") {
       const firstArg = extractFirstArg(event.toolArgs);
-      const state = {
-        toolName: event.toolName,
-        firstArg,
-        isRunning: true
-      };
+      const state = { toolName: event.toolName, firstArg, isRunning: true };
       this.activeTools.push(state);
       this.emit("tool_start", state);
     } 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
-        };
+        const finished = { ...this.activeTools[idx], isRunning: false, result };
         this.activeTools[idx] = finished;
         this.trimCompletedTools();
         this.emit("tool_end", finished);
@@ -2579,6 +2397,31 @@ var InteractiveSession = class {
     }
   }
   // ── Helpers ───────────────────────────────────────────────────
+  /** Push tool execution summary into messages (before Robota response).
+   *  Moves tool info from activeTools (real-time display) to messages (permanent display).
+   *  After this, activeTools will be cleared by clearStreaming(). */
+  pushToolSummaryMessage() {
+    if (this.activeTools.length === 0) return;
+    const summary = this.activeTools.map((t) => {
+      const status = t.isRunning ? "\u27F3" : t.result === "success" ? "\u2713" : t.result === "error" ? "\u2717" : "\u2298";
+      return `${status} ${t.toolName}${t.firstArg ? `(${t.firstArg})` : ""}`;
+    }).join("\n");
+    this.history.push({
+      id: (0, import_node_crypto.randomUUID)(),
+      timestamp: /* @__PURE__ */ new Date(),
+      category: "event",
+      type: "tool-summary",
+      data: {
+        tools: this.activeTools.map((t) => ({
+          toolName: t.toolName,
+          firstArg: t.firstArg,
+          isRunning: t.isRunning,
+          result: t.result
+        })),
+        summary
+      }
+    });
+  }
   clearStreaming() {
     this.streamingText = "";
     this.activeTools = [];
@@ -2597,30 +2440,28 @@ var InteractiveSession = class {
     const toolSummaries = this.extractToolSummaries(historyBefore);
     return {
       response,
-      messages: this.messages,
+      history: this.history,
       toolSummaries,
       contextState: this.getContextState()
     };
   }
   buildInterruptedResult(historyBefore) {
-    const history = this.session.getHistory();
+    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);
-      }
+      if (msg?.role === "assistant" && msg.content) parts.push(msg.content);
     }
     return {
       response: parts.join("\n\n"),
-      messages: this.messages,
+      history: this.history,
       toolSummaries,
       contextState: this.getContextState()
     };
   }
   extractToolSummaries(historyBefore) {
-    const history = this.session.getHistory();
+    const history = this.getSessionOrThrow().getHistory();
     const summaries = [];
     for (let i = historyBefore; i < history.length; i++) {
       const msg = history[i];
@@ -2672,13 +2513,395 @@ var NOOP_TERMINAL = {
   } })
 };
 
+// src/query.ts
+function createQuery(options) {
+  const session = new InteractiveSession({
+    cwd: options.cwd ?? process.cwd(),
+    provider: options.provider,
+    permissionMode: options.permissionMode ?? "bypassPermissions",
+    maxTurns: options.maxTurns,
+    permissionHandler: options.permissionHandler
+  });
+  if (options.onTextDelta) {
+    session.on("text_delta", options.onTextDelta);
+  }
+  return async (prompt) => {
+    return new Promise((resolve2, reject) => {
+      const onComplete = (result) => {
+        cleanup();
+        resolve2(result.response);
+      };
+      const onInterrupted = (result) => {
+        cleanup();
+        resolve2(result.response);
+      };
+      const onError = (error) => {
+        cleanup();
+        reject(error);
+      };
+      const cleanup = () => {
+        session.off("complete", onComplete);
+        session.off("interrupted", onInterrupted);
+        session.off("error", onError);
+      };
+      session.on("complete", onComplete);
+      session.on("interrupted", onInterrupted);
+      session.on("error", onError);
+      session.submit(prompt).catch((err) => {
+        cleanup();
+        reject(err instanceof Error ? err : new Error(String(err)));
+      });
+    });
+  };
+}
+
+// src/commands/command-registry.ts
+var CommandRegistry = class {
+  sources = [];
+  addSource(source) {
+    this.sources.push(source);
+  }
+  /** Get all commands, optionally filtered by prefix */
+  getCommands(filter) {
+    const all = [];
+    for (const source of this.sources) {
+      all.push(...source.getCommands());
+    }
+    if (!filter) return all;
+    const lower = filter.toLowerCase();
+    return all.filter((cmd) => cmd.name.toLowerCase().startsWith(lower));
+  }
+  /** Resolve a short name to its fully qualified plugin:name form */
+  resolveQualifiedName(shortName) {
+    const matches = this.getCommands().filter(
+      (c) => c.source === "plugin" && c.name.includes(":") && c.name.endsWith(`:${shortName}`)
+    );
+    if (matches.length !== 1) return null;
+    return matches[0].name;
+  }
+  /** Get subcommands for a specific command */
+  getSubcommands(commandName) {
+    const lower = commandName.toLowerCase();
+    for (const source of this.sources) {
+      for (const cmd of source.getCommands()) {
+        if (cmd.name.toLowerCase() === lower && cmd.subcommands) {
+          return cmd.subcommands;
+        }
+      }
+    }
+    return [];
+  }
+};
+
+// src/commands/builtin-source.ts
+var import_agent_core2 = require("@robota-sdk/agent-core");
+function buildModelSubcommands() {
+  const seen = /* @__PURE__ */ new Set();
+  const commands = [];
+  for (const model of Object.values(import_agent_core2.CLAUDE_MODELS)) {
+    if (seen.has(model.name)) continue;
+    seen.add(model.name);
+    commands.push({
+      name: model.id,
+      description: `${model.name} (${(0, import_agent_core2.formatTokenCount)(model.contextWindow).toUpperCase()})`,
+      source: "builtin"
+    });
+  }
+  return commands;
+}
+function createBuiltinCommands() {
+  return [
+    { name: "help", description: "Show available commands", source: "builtin" },
+    { name: "clear", description: "Clear conversation history", source: "builtin" },
+    {
+      name: "mode",
+      description: "Permission mode",
+      source: "builtin",
+      subcommands: [
+        { name: "plan", description: "Plan only, no execution", source: "builtin" },
+        { name: "default", description: "Ask before risky actions", source: "builtin" },
+        { name: "acceptEdits", description: "Auto-approve file edits", source: "builtin" },
+        { name: "bypassPermissions", description: "Skip all permission checks", source: "builtin" }
+      ]
+    },
+    {
+      name: "model",
+      description: "Select AI model",
+      source: "builtin",
+      subcommands: buildModelSubcommands()
+    },
+    {
+      name: "language",
+      description: "Set response language",
+      source: "builtin",
+      subcommands: [
+        { name: "ko", description: "Korean", source: "builtin" },
+        { name: "en", description: "English", source: "builtin" },
+        { name: "ja", description: "Japanese", source: "builtin" },
+        { name: "zh", description: "Chinese", source: "builtin" }
+      ]
+    },
+    { name: "compact", description: "Compress context window", source: "builtin" },
+    { name: "cost", description: "Show session info", source: "builtin" },
+    { name: "context", description: "Context window info", source: "builtin" },
+    { name: "permissions", description: "Permission rules", source: "builtin" },
+    { name: "plugin", description: "Manage plugins", source: "builtin" },
+    { name: "reload-plugins", description: "Reload all plugin resources", source: "builtin" },
+    { name: "reset", description: "Delete settings and exit", source: "builtin" },
+    { name: "exit", description: "Exit CLI", source: "builtin" }
+  ];
+}
+var BuiltinCommandSource = class {
+  name = "builtin";
+  commands;
+  constructor() {
+    this.commands = createBuiltinCommands();
+  }
+  getCommands() {
+    return this.commands;
+  }
+};
+
+// src/commands/skill-source.ts
+var import_node_fs7 = require("fs");
+var import_node_path10 = require("path");
+var import_node_os4 = require("os");
+var BOOLEAN_KEYS = /* @__PURE__ */ new Set(["disable-model-invocation", "user-invocable"]);
+var LIST_KEYS2 = /* @__PURE__ */ new Set(["allowed-tools"]);
+function kebabToCamel(key) {
+  return key.replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase());
+}
+function parseFrontmatter2(content) {
+  const lines = content.split("\n");
+  if (lines[0]?.trim() !== "---") return null;
+  const result = {};
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "---") break;
+    const match = line.match(/^([a-z][a-z0-9-]*):\s*(.+)/);
+    if (!match) continue;
+    const key = match[1];
+    const rawValue = match[2].trim();
+    const camelKey = kebabToCamel(key);
+    if (BOOLEAN_KEYS.has(key)) {
+      result[camelKey] = rawValue === "true";
+    } else if (LIST_KEYS2.has(key)) {
+      result[camelKey] = rawValue.split(",").map((s) => s.trim());
+    } else {
+      result[camelKey] = rawValue;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : null;
+}
+function buildCommand(frontmatter, content, fallbackName) {
+  const cmd = {
+    name: frontmatter?.name ?? fallbackName,
+    description: frontmatter?.description ?? `Skill: ${fallbackName}`,
+    source: "skill",
+    skillContent: content
+  };
+  if (frontmatter?.argumentHint !== void 0) cmd.argumentHint = frontmatter.argumentHint;
+  if (frontmatter?.disableModelInvocation !== void 0)
+    cmd.disableModelInvocation = frontmatter.disableModelInvocation;
+  if (frontmatter?.userInvocable !== void 0) cmd.userInvocable = frontmatter.userInvocable;
+  if (frontmatter?.allowedTools !== void 0) cmd.allowedTools = frontmatter.allowedTools;
+  if (frontmatter?.model !== void 0) cmd.model = frontmatter.model;
+  if (frontmatter?.effort !== void 0) cmd.effort = frontmatter.effort;
+  if (frontmatter?.context !== void 0) cmd.context = frontmatter.context;
+  if (frontmatter?.agent !== void 0) cmd.agent = frontmatter.agent;
+  return cmd;
+}
+function scanSkillsDir(skillsDir) {
+  if (!(0, import_node_fs7.existsSync)(skillsDir)) return [];
+  const commands = [];
+  const entries = (0, import_node_fs7.readdirSync)(skillsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillFile = (0, import_node_path10.join)(skillsDir, entry.name, "SKILL.md");
+    if (!(0, import_node_fs7.existsSync)(skillFile)) continue;
+    const content = (0, import_node_fs7.readFileSync)(skillFile, "utf-8");
+    const frontmatter = parseFrontmatter2(content);
+    commands.push(buildCommand(frontmatter, content, entry.name));
+  }
+  return commands;
+}
+function scanCommandsDir(commandsDir) {
+  if (!(0, import_node_fs7.existsSync)(commandsDir)) return [];
+  const commands = [];
+  const entries = (0, import_node_fs7.readdirSync)(commandsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+    const filePath = (0, import_node_path10.join)(commandsDir, entry.name);
+    const content = (0, import_node_fs7.readFileSync)(filePath, "utf-8");
+    const frontmatter = parseFrontmatter2(content);
+    const fallbackName = (0, import_node_path10.basename)(entry.name, ".md");
+    commands.push(buildCommand(frontmatter, content, fallbackName));
+  }
+  return commands;
+}
+var SkillCommandSource = class {
+  name = "skill";
+  cwd;
+  home;
+  cachedCommands = null;
+  constructor(cwd, home) {
+    this.cwd = cwd;
+    this.home = home ?? (0, import_node_os4.homedir)();
+  }
+  getCommands() {
+    if (this.cachedCommands) return this.cachedCommands;
+    const sources = [
+      scanSkillsDir((0, import_node_path10.join)(this.cwd, ".claude", "skills")),
+      scanCommandsDir((0, import_node_path10.join)(this.cwd, ".claude", "commands")),
+      scanSkillsDir((0, import_node_path10.join)(this.home, ".robota", "skills")),
+      scanSkillsDir((0, import_node_path10.join)(this.cwd, ".agents", "skills"))
+    ];
+    const seen = /* @__PURE__ */ new Set();
+    const merged = [];
+    for (const commands of sources) {
+      for (const cmd of commands) {
+        if (!seen.has(cmd.name)) {
+          seen.add(cmd.name);
+          merged.push(cmd);
+        }
+      }
+    }
+    this.cachedCommands = merged;
+    return this.cachedCommands;
+  }
+  getModelInvocableSkills() {
+    return this.getCommands().filter((cmd) => cmd.disableModelInvocation !== true);
+  }
+  getUserInvocableSkills() {
+    return this.getCommands().filter((cmd) => cmd.userInvocable !== false);
+  }
+};
+
+// src/commands/plugin-source.ts
+var PluginCommandSource = class {
+  name = "plugin";
+  plugins;
+  constructor(plugins) {
+    this.plugins = plugins;
+  }
+  getCommands() {
+    const commands = [];
+    for (const plugin of this.plugins) {
+      for (const skill of plugin.skills) {
+        const baseName = skill.name.includes("@") ? skill.name.split("@")[0] : skill.name;
+        commands.push({
+          name: baseName,
+          description: `(${plugin.manifest.name}) ${skill.description}`,
+          source: "plugin",
+          skillContent: skill.skillContent,
+          pluginDir: plugin.pluginDir
+        });
+      }
+      for (const cmd of plugin.commands) {
+        commands.push({
+          name: cmd.name,
+          description: cmd.description,
+          source: "plugin",
+          skillContent: cmd.skillContent,
+          pluginDir: plugin.pluginDir
+        });
+      }
+    }
+    return commands;
+  }
+};
+
+// src/utils/skill-prompt.ts
+var import_node_child_process3 = require("child_process");
+function substituteVariables(content, args, context) {
+  const argParts = args ? args.split(/\s+/) : [];
+  let result = content;
+  result = result.replace(/\$ARGUMENTS\[(\d+)]/g, (_match, index) => {
+    return argParts[Number(index)] ?? "";
+  });
+  result = result.replace(/\$ARGUMENTS/g, args);
+  result = result.replace(/\$(\d)(?!\d|\w|\[)/g, (_match, digit) => {
+    return argParts[Number(digit)] ?? "";
+  });
+  result = result.replace(/\$\{CLAUDE_SESSION_ID}/g, context?.sessionId ?? "");
+  result = result.replace(/\$\{CLAUDE_SKILL_DIR}/g, context?.skillDir ?? "");
+  return result;
+}
+async function preprocessShellCommands(content) {
+  const shellPattern = /!`([^`]+)`/g;
+  if (!shellPattern.test(content)) {
+    return content;
+  }
+  shellPattern.lastIndex = 0;
+  let result = content;
+  let match;
+  const matches = [];
+  while ((match = shellPattern.exec(content)) !== null) {
+    matches.push({ full: match[0], command: match[1] });
+  }
+  for (const { full, command } of matches) {
+    let output = "";
+    try {
+      output = (0, import_node_child_process3.execSync)(command, {
+        timeout: 5e3,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trimEnd();
+    } catch {
+      output = "";
+    }
+    result = result.replace(full, output);
+  }
+  return result;
+}
+async function buildSkillPrompt(input, registry, context) {
+  const parts = input.slice(1).split(/\s+/);
+  const cmd = parts[0]?.toLowerCase() ?? "";
+  const skillCmd = registry.getCommands().find((c) => c.name === cmd && (c.source === "skill" || c.source === "plugin"));
+  if (!skillCmd) return null;
+  const args = parts.slice(1).join(" ").trim();
+  const userInstruction = args || skillCmd.description;
+  if (skillCmd.skillContent) {
+    let processed = await preprocessShellCommands(skillCmd.skillContent);
+    processed = substituteVariables(processed, args, context);
+    return `<skill name="${cmd}">
+${processed}
+</skill>
+
+Execute the "${cmd}" skill: ${userInstruction}`;
+  }
+  return `Use the "${cmd}" skill: ${userInstruction}`;
+}
+
+// src/types.ts
+var import_agent_core3 = require("@robota-sdk/agent-core");
+
+// src/index.ts
+var import_agent_core4 = require("@robota-sdk/agent-core");
+var import_agent_core5 = require("@robota-sdk/agent-core");
+
+// src/permissions/permission-prompt.ts
+var import_chalk = __toESM(require("chalk"), 1);
+var PERMISSION_OPTIONS = ["Allow", "Deny"];
+var ALLOW_INDEX = 0;
+function formatArgs(toolArgs) {
+  const entries = Object.entries(toolArgs);
+  if (entries.length === 0) {
+    return "(no arguments)";
+  }
+  return entries.map(([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`).join(", ");
+}
+async function promptForApproval(terminal, toolName, toolArgs) {
+  terminal.writeLine("");
+  terminal.writeLine(import_chalk.default.yellow(`[Permission Required] Tool: ${toolName}`));
+  terminal.writeLine(import_chalk.default.dim(`  ${formatArgs(toolArgs)}`));
+  terminal.writeLine("");
+  const selected = await terminal.select(PERMISSION_OPTIONS, ALLOW_INDEX);
+  return selected === ALLOW_INDEX;
+}
+
 // src/index.ts
-var import_agent_tools3 = require("@robota-sdk/agent-tools");
-var import_agent_tools4 = require("@robota-sdk/agent-tools");
-var import_agent_tools5 = require("@robota-sdk/agent-tools");
-var import_agent_tools6 = require("@robota-sdk/agent-tools");
-var import_agent_tools7 = require("@robota-sdk/agent-tools");
-var import_agent_tools8 = require("@robota-sdk/agent-tools");
+var import_agent_core6 = require("@robota-sdk/agent-core");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AgentExecutor,
@@ -2687,47 +2910,35 @@ var import_agent_tools8 = require("@robota-sdk/agent-tools");
   BundlePluginInstaller,
   BundlePluginLoader,
   CommandRegistry,
-  DEFAULT_TOOL_DESCRIPTIONS,
-  FileSessionLogger,
   InteractiveSession,
   MarketplaceClient,
+  PluginCommandSource,
   PluginSettingsStore,
   PromptExecutor,
-  Session,
-  SessionStore,
-  SilentSessionLogger,
   SkillCommandSource,
-  SystemCommandExecutor,
   TRUST_TO_MODE,
   assembleSubagentPrompt,
-  bashTool,
-  buildSystemPrompt,
+  buildSkillPrompt,
+  chatEntryToMessage,
   createAgentTool,
-  createDefaultTools,
-  createProvider,
-  createSession,
+  createQuery,
   createSubagentLogger,
   createSubagentSession,
-  createSystemCommands,
-  detectProject,
-  editTool,
   evaluatePermission,
   getBuiltInAgent,
   getForkWorkerSuffix,
+  getMessagesForAPI,
   getSubagentSuffix,
-  globTool,
-  grepTool,
-  loadConfig,
-  loadContext,
+  isChatEntry,
+  messageToHistoryEntry,
   parseFrontmatter,
+  preprocessShellCommands,
   projectPaths,
   promptForApproval,
-  query,
-  readTool,
   resolveSubagentLogDir,
   retrieveAgentToolDeps,
   runHooks,
   storeAgentToolDeps,
-  userPaths,
-  writeTool
+  substituteVariables,
+  userPaths
 });