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

package/dist/node/index.js

@@ -1,6 +1,3 @@
-// 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);
@@ -239,18 +236,6 @@ 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"
-    );
-  }
-  return new AnthropicProvider({ apiKey });
-}
-
 // src/tools/agent-tool.ts
 import { z } from "zod";
 import { createZodFunctionTool } from "@robota-sdk/agent-tools";
@@ -380,7 +365,7 @@ function createSubagentSession(options) {
     agentsMd: parentContext.agentsMd,
     isForkWorker: options.isForkWorker ?? false
   });
-  const provider = createProvider(parentConfig);
+  const provider = options.provider;
   return new Session({
     tools,
     provider,
@@ -441,6 +426,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,
@@ -587,7 +573,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());
@@ -615,6 +606,7 @@ function createSession(options) {
     context: options.context,
     tools,
     terminal: options.terminal,
+    provider,
     permissionMode: options.permissionMode,
     permissionHandler: options.permissionHandler,
     hooks: options.config.hooks,
@@ -684,14 +676,32 @@ function resolveSubagentLogDir(parentSessionId, baseLogsDir) {
   return join2(baseLogsDir, parentSessionId, "subagents");
 }
 
-// src/index.ts
-import { Session as Session3 } from "@robota-sdk/agent-sessions";
-import { FileSessionLogger as FileSessionLogger3, SilentSessionLogger } from "@robota-sdk/agent-sessions";
-import { SessionStore } from "@robota-sdk/agent-sessions";
+// 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 as readFileSync2, existsSync as existsSync2 } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 
 // src/config/config-types.ts
 import { z as z2 } from "zod";
@@ -867,15 +877,15 @@ function toResolvedConfig(merged) {
 function getSettingsPaths(cwd) {
   const home = getHomeDir();
   return [
-    join3(home, ".robota", "settings.json"),
+    join4(home, ".robota", "settings.json"),
     // 1. user (lowest)
-    join3(cwd, ".robota", "settings.json"),
+    join4(cwd, ".robota", "settings.json"),
     // 2. project
-    join3(cwd, ".robota", "settings.local.json"),
+    join4(cwd, ".robota", "settings.local.json"),
     // 3. project-local
-    join3(cwd, ".claude", "settings.json"),
+    join4(cwd, ".claude", "settings.json"),
     // 4. project, Claude Code compat
-    join3(cwd, ".claude", "settings.local.json")
+    join4(cwd, ".claude", "settings.local.json")
     // 5. project-local (highest)
   ];
 }
@@ -901,7 +911,7 @@ async function loadConfig(cwd) {
 
 // src/context/context-loader.ts
 import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join4, dirname, resolve } from "path";
+import { join as join5, dirname, resolve } from "path";
 var AGENTS_FILENAME = "AGENTS.md";
 var CLAUDE_FILENAME = "CLAUDE.md";
 function collectFilesWalkingUp(startDir, filename) {
@@ -909,7 +919,7 @@ function collectFilesWalkingUp(startDir, filename) {
   let current = resolve(startDir);
   let atRoot = false;
   while (!atRoot) {
-    const candidate = join4(current, filename);
+    const candidate = join5(current, filename);
     if (existsSync3(candidate)) {
       found.push(candidate);
     }
@@ -956,7 +966,7 @@ async function loadContext(cwd) {
 
 // src/context/project-detector.ts
 import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 function tryReadJson(filePath) {
   if (!existsSync4(filePath)) return void 0;
   try {
@@ -966,26 +976,26 @@ function tryReadJson(filePath) {
   }
 }
 function detectPackageManager(cwd) {
-  if (existsSync4(join5(cwd, "pnpm-workspace.yaml")) || existsSync4(join5(cwd, "pnpm-lock.yaml"))) {
+  if (existsSync4(join6(cwd, "pnpm-workspace.yaml")) || existsSync4(join6(cwd, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (existsSync4(join5(cwd, "yarn.lock"))) {
+  if (existsSync4(join6(cwd, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync4(join5(cwd, "bun.lockb"))) {
+  if (existsSync4(join6(cwd, "bun.lockb"))) {
     return "bun";
   }
-  if (existsSync4(join5(cwd, "package-lock.json"))) {
+  if (existsSync4(join6(cwd, "package-lock.json"))) {
     return "npm";
   }
   return void 0;
 }
 async function detectProject(cwd) {
-  const pkgJsonPath = join5(cwd, "package.json");
-  const tsconfigPath = join5(cwd, "tsconfig.json");
-  const pyprojectPath = join5(cwd, "pyproject.toml");
-  const cargoPath = join5(cwd, "Cargo.toml");
-  const goModPath = join5(cwd, "go.mod");
+  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 = existsSync4(tsconfigPath) ? "typescript" : "javascript";
@@ -997,7 +1007,7 @@ async function detectProject(cwd) {
       language
     };
   }
-  if (existsSync4(pyprojectPath) || existsSync4(join5(cwd, "setup.py"))) {
+  if (existsSync4(pyprojectPath) || existsSync4(join6(cwd, "setup.py"))) {
     return {
       type: "python",
       language: "python"
@@ -1021,102 +1031,225 @@ 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",
+          "  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 join6 } from "path";
-import { homedir as homedir2 } from "os";
-function projectPaths(cwd) {
-  const base = join6(cwd, ".robota");
-  return {
-    settings: join6(base, "settings.json"),
-    settingsLocal: join6(base, "settings.local.json"),
-    logs: join6(base, "logs"),
-    sessions: join6(base, "sessions")
-  };
-}
-function userPaths() {
-  const base = join6(homedir2(), ".robota");
-  return {
-    settings: join6(base, "settings.json"),
-    sessions: join6(base, "sessions")
-  };
+    {
+      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 }
+        };
+      }
+    }
+  ];
 }
-
-// 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 {};
+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");
@@ -1908,479 +2041,160 @@ var MarketplaceClient = class {
   }
 };
 
-// src/commands/command-registry.ts
-var CommandRegistry = class {
-  sources = [];
-  addSource(source) {
-    this.sources.push(source);
+// 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;
+      })
+    };
   }
-  /** 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
-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: "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
-import { readdirSync as readdirSync3, readFileSync as readFileSync9, existsSync as existsSync9 } from "fs";
-import { join as join10, basename as basename2 } from "path";
+// src/interactive/interactive-session.ts
 import { homedir as homedir3 } 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());
+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 = [];
+  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 = 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);
+    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)
+    });
+    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 (!existsSync9(skillsDir)) return [];
-  const commands = [];
-  const entries = readdirSync3(skillsDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const skillFile = join10(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));
+  async ensureInitialized() {
+    if (this.initialized) return;
+    if (this.initPromise) await this.initPromise;
   }
-  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 = join10(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));
+  getSessionOrThrow() {
+    if (!this.session)
+      throw new Error("InteractiveSession not initialized. Call submit() or await initialization.");
+    return this.session;
   }
-  return commands;
-}
-var SkillCommandSource = class {
-  name = "skill";
-  cwd;
-  home;
-  cachedCommands = null;
-  constructor(cwd, home) {
-    this.cwd = cwd;
-    this.home = home ?? homedir3();
-  }
-  getCommands() {
-    if (this.cachedCommands) return this.cachedCommands;
-    const sources = [
-      scanSkillsDir(join10(this.cwd, ".claude", "skills")),
-      scanCommandsDir(join10(this.cwd, ".claude", "commands")),
-      scanSkillsDir(join10(this.home, ".robota", "skills")),
-      scanSkillsDir(join10(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/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
-import { FileSessionLogger as FileSessionLogger2 } from "@robota-sdk/agent-sessions";
-import {
-  createUserMessage,
-  createAssistantMessage,
-  createSystemMessage
-} from "@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 FileSessionLogger2(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);
+  // ── 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);
@@ -2394,10 +2208,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;
@@ -2406,14 +2219,30 @@ var InteractiveSession = class {
     }
     await this.executePrompt(input, displayInput, rawInput);
   }
-  /** Abort current execution and clear queue. */
-  abort() {
-    this.pendingPrompt = null;
-    this.session.abort();
+  /** 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;
@@ -2421,8 +2250,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;
@@ -2431,39 +2265,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(createUserMessage(displayInput ?? input));
-    const historyBefore = this.session.getHistory().length;
+    this.history.push(messageToHistoryEntry(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(createAssistantMessage(result.response));
+      this.history.push(messageToHistoryEntry(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(createAssistantMessage(result.response));
+          this.history.push(messageToHistoryEntry(createAssistantMessage(result.response)));
         }
-        this.messages.push(createSystemMessage("Interrupted by user."));
+        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.messages.push(createSystemMessage(`Error: ${errMsg}`));
+        this.history.push(messageToHistoryEntry(createSystemMessage(`Error: ${errMsg}`)));
         this.emit("error", err instanceof Error ? err : new Error(errMsg));
       }
     } finally {
@@ -2493,22 +2332,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);
@@ -2516,6 +2347,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: 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 = [];
@@ -2534,30 +2390,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];
@@ -2609,13 +2463,400 @@ 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
+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: "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 { 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";
+import { runHooks } from "@robota-sdk/agent-core";
 export {
   AgentExecutor,
   BUILT_IN_AGENTS,
@@ -2623,47 +2864,35 @@ export {
   BundlePluginInstaller,
   BundlePluginLoader,
   CommandRegistry,
-  DEFAULT_TOOL_DESCRIPTIONS,
-  FileSessionLogger3 as FileSessionLogger,
   InteractiveSession,
   MarketplaceClient,
+  PluginCommandSource,
   PluginSettingsStore,
   PromptExecutor,
-  Session3 as Session,
-  SessionStore,
-  SilentSessionLogger,
   SkillCommandSource,
-  SystemCommandExecutor,
   TRUST_TO_MODE,
   assembleSubagentPrompt,
-  bashTool2 as bashTool,
-  buildSystemPrompt,
+  buildSkillPrompt,
+  chatEntryToMessage,
   createAgentTool,
-  createDefaultTools,
-  createProvider,
-  createSession,
+  createQuery,
   createSubagentLogger,
   createSubagentSession,
-  createSystemCommands,
-  detectProject,
-  editTool2 as editTool,
   evaluatePermission,
   getBuiltInAgent,
   getForkWorkerSuffix,
+  getMessagesForAPI,
   getSubagentSuffix,
-  globTool2 as globTool,
-  grepTool2 as grepTool,
-  loadConfig,
-  loadContext,
+  isChatEntry,
+  messageToHistoryEntry2 as messageToHistoryEntry,
   parseFrontmatter2 as parseFrontmatter,
+  preprocessShellCommands,
   projectPaths,
   promptForApproval,
-  query,
-  readTool2 as readTool,
   resolveSubagentLogDir,
   retrieveAgentToolDeps,
   runHooks,
   storeAgentToolDeps,
-  userPaths,
-  writeTool2 as writeTool
+  substituteVariables,
+  userPaths
 };