@robota-sdk/agent-cli 3.0.0-beta.40 → 3.0.0-beta.41

package/dist/node/index.cjs

@@ -30,21 +30,21 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  Session: () => import_agent_sdk7.Session,
-  SessionStore: () => import_agent_sdk7.SessionStore,
-  TRUST_TO_MODE: () => import_agent_sdk7.TRUST_TO_MODE,
-  query: () => import_agent_sdk7.query,
+  Session: () => import_agent_sdk5.Session,
+  SessionStore: () => import_agent_sdk5.SessionStore,
+  TRUST_TO_MODE: () => import_agent_sdk5.TRUST_TO_MODE,
+  query: () => import_agent_sdk5.query,
   startCli: () => startCli
 });
 module.exports = __toCommonJS(index_exports);
-var import_agent_sdk7 = require("@robota-sdk/agent-sdk");
+var import_agent_sdk5 = require("@robota-sdk/agent-sdk");
 
 // src/cli.ts
-var import_node_fs4 = require("fs");
+var import_node_fs2 = require("fs");
 var import_node_path5 = require("path");
 var import_node_url = require("url");
-var import_agent_sdk5 = require("@robota-sdk/agent-sdk");
-var import_agent_sdk6 = require("@robota-sdk/agent-sdk");
+var import_agent_sdk3 = require("@robota-sdk/agent-sdk");
+var import_agent_sdk4 = require("@robota-sdk/agent-sdk");
 
 // src/utils/cli-args.ts
 var import_node_util = require("util");
@@ -182,606 +182,50 @@ var PrintTerminal = class {
 var import_ink14 = require("ink");
 
 // src/ui/App.tsx
-var import_react16 = require("react");
+var import_react12 = require("react");
 var import_ink13 = require("ink");
-var import_agent_core6 = require("@robota-sdk/agent-core");
-var import_agent_core7 = require("@robota-sdk/agent-core");
+var import_agent_core4 = require("@robota-sdk/agent-core");
 
-// src/ui/hooks/useSession.ts
+// src/ui/hooks/useInteractiveSession.ts
 var import_react = require("react");
+var import_node_os = require("os");
+var import_node_path3 = require("path");
 var import_agent_sdk = require("@robota-sdk/agent-sdk");
-
-// src/utils/edit-diff.ts
-var import_node_fs2 = require("fs");
-var CONTEXT_LINES = 2;
-function generateDiffLines(oldStr, newStr, startLine = 1) {
-  if (oldStr === newStr) return [];
-  const lines = [];
-  const oldLines = oldStr.split("\n");
-  const newLines = newStr.split("\n");
-  for (let i = 0; i < oldLines.length; i++) {
-    lines.push({ type: "remove", text: oldLines[i], lineNumber: startLine + i });
-  }
-  for (let i = 0; i < newLines.length; i++) {
-    lines.push({ type: "add", text: newLines[i], lineNumber: startLine + i });
-  }
-  return lines;
-}
-function generateDiffLinesWithContext(oldStr, newStr, startLine, filePath) {
-  if (oldStr === newStr) return [];
-  const diffLines = generateDiffLines(oldStr, newStr, startLine);
-  let fileLines;
-  try {
-    fileLines = (0, import_node_fs2.readFileSync)(filePath, "utf-8").split("\n");
-  } catch {
-    return diffLines;
-  }
-  const result = [];
-  const contextStart = Math.max(0, startLine - 1 - CONTEXT_LINES);
-  for (let i = contextStart; i < startLine - 1; i++) {
-    if (i < fileLines.length) {
-      result.push({ type: "context", text: fileLines[i], lineNumber: i + 1 });
-    }
-  }
-  result.push(...diffLines);
-  const newLineCount = newStr.split("\n").length;
-  const afterStart = startLine - 1 + newLineCount;
-  for (let i = afterStart; i < afterStart + CONTEXT_LINES; i++) {
-    if (i < fileLines.length) {
-      result.push({ type: "context", text: fileLines[i], lineNumber: i + 1 });
-    }
-  }
-  return result;
-}
-function extractEditDiff(toolName, toolArgs, startLine) {
-  if (toolName !== "Edit" || !toolArgs) return null;
-  const filePath = toolArgs.file_path ?? toolArgs.filePath;
-  const oldStr = toolArgs.old_string ?? toolArgs.oldString;
-  const newStr = toolArgs.new_string ?? toolArgs.newString;
-  if (typeof filePath !== "string") return null;
-  if (typeof oldStr !== "string" || typeof newStr !== "string") return null;
-  let sl = startLine ?? 0;
-  if (!sl) {
-    try {
-      const fileContent = (0, import_node_fs2.readFileSync)(filePath, "utf-8");
-      const idx = fileContent.indexOf(newStr);
-      if (idx >= 0) {
-        sl = fileContent.substring(0, idx).split("\n").length;
-      } else {
-        sl = 1;
-      }
-    } catch {
-      sl = 1;
-    }
-  }
-  const lines = generateDiffLinesWithContext(oldStr, newStr, sl, filePath);
-  if (lines.length === 0) return null;
-  return { file: filePath, lines };
-}
-
-// src/ui/hooks/useSession.ts
-var TOOL_ARG_DISPLAY_MAX = 80;
-var TAIL_KEEP = 30;
-var MAX_COMPLETED_TOOLS = 50;
-var NOOP_TERMINAL = {
-  write: () => {
-  },
-  writeLine: () => {
-  },
-  writeMarkdown: () => {
-  },
-  writeError: () => {
-  },
-  prompt: () => Promise.resolve(""),
-  select: () => Promise.resolve(0),
-  spinner: () => ({ stop: () => {
-  }, update: () => {
-  } })
-};
-function useSession(props) {
-  const [permissionRequest, setPermissionRequest] = (0, import_react.useState)(null);
-  const [streamingText, setStreamingText] = (0, import_react.useState)("");
-  const streamingTextRef = (0, import_react.useRef)("");
-  const [activeTools, setActiveTools] = (0, import_react.useState)([]);
-  const permissionQueueRef = (0, import_react.useRef)([]);
-  const processingRef = (0, import_react.useRef)(false);
-  const processNextPermission = (0, import_react.useCallback)(() => {
-    if (processingRef.current) return;
-    const next = permissionQueueRef.current[0];
-    if (!next) {
-      setPermissionRequest(null);
-      return;
-    }
-    processingRef.current = true;
-    setPermissionRequest({
-      toolName: next.toolName,
-      toolArgs: next.toolArgs,
-      resolve: (result) => {
-        permissionQueueRef.current.shift();
-        processingRef.current = false;
-        setPermissionRequest(null);
-        next.resolve(result);
-        setTimeout(() => processNextPermission(), 0);
-      }
-    });
-  }, []);
-  const sessionRef = (0, import_react.useRef)(null);
-  if (sessionRef.current === null) {
-    const permissionHandler = (toolName, toolArgs) => {
-      return new Promise((resolve) => {
-        permissionQueueRef.current.push({ toolName, toolArgs, resolve });
-        processNextPermission();
-      });
-    };
-    let flushTimer = null;
-    const onTextDelta = (delta) => {
-      streamingTextRef.current += delta;
-      if (!flushTimer) {
-        flushTimer = setTimeout(() => {
-          setStreamingText(streamingTextRef.current);
-          flushTimer = null;
-        }, 16);
-      }
-    };
-    const onToolExecution = (event) => {
-      if (event.type === "start") {
-        let firstArg = "";
-        if (event.toolArgs) {
-          const firstVal = Object.values(event.toolArgs)[0];
-          const raw = typeof firstVal === "string" ? firstVal : JSON.stringify(firstVal ?? "");
-          firstArg = raw.length > TOOL_ARG_DISPLAY_MAX ? raw.slice(0, TOOL_ARG_DISPLAY_MAX - TAIL_KEEP - 3) + "..." + raw.slice(-TAIL_KEEP) : raw;
-        }
-        setActiveTools((prev) => [
-          ...prev,
-          { toolName: event.toolName, firstArg, isRunning: true, _toolArgs: event.toolArgs }
-        ]);
-      } else {
-        const toolResult = event.denied ? "denied" : event.success === false ? "error" : "success";
-        setActiveTools((prev) => {
-          const updated = prev.map((t) => {
-            if (!(t.toolName === event.toolName && t.isRunning)) return t;
-            let startLine;
-            if (event.toolResultData && event.toolName === "Edit") {
-              try {
-                const parsed = JSON.parse(event.toolResultData);
-                if (typeof parsed.startLine === "number") {
-                  startLine = parsed.startLine;
-                }
-              } catch {
-              }
-            }
-            const editDiff = extractEditDiff(
-              event.toolName,
-              t._toolArgs,
-              startLine
-            );
-            const finished = {
-              ...t,
-              isRunning: false,
-              result: toolResult
-            };
-            if (editDiff) {
-              finished.diffLines = editDiff.lines;
-              finished.diffFile = editDiff.file;
-            }
-            delete finished._toolArgs;
-            return finished;
-          });
-          const completed = updated.filter((t) => !t.isRunning);
-          if (completed.length > MAX_COMPLETED_TOOLS) {
-            const excess = completed.length - MAX_COMPLETED_TOOLS;
-            let removed = 0;
-            return updated.filter((t) => {
-              if (!t.isRunning && removed < excess) {
-                removed++;
-                return false;
-              }
-              return true;
-            });
-          }
-          return updated;
-        });
-      }
-    };
-    const paths = (0, import_agent_sdk.projectPaths)(props.cwd ?? process.cwd());
-    sessionRef.current = (0, import_agent_sdk.createSession)({
-      config: props.config,
-      context: props.context,
-      terminal: NOOP_TERMINAL,
-      sessionLogger: new import_agent_sdk.FileSessionLogger(paths.logs),
-      projectInfo: props.projectInfo,
-      sessionStore: props.sessionStore,
-      permissionMode: props.permissionMode,
-      maxTurns: props.maxTurns,
-      permissionHandler,
-      onTextDelta,
-      onToolExecution
-    });
-  }
-  const clearStreamingText = (0, import_react.useCallback)(() => {
-    setStreamingText("");
-    streamingTextRef.current = "";
-    setActiveTools([]);
-  }, []);
-  return {
-    session: sessionRef.current,
-    permissionRequest,
-    streamingText,
-    clearStreamingText,
-    activeTools
-  };
-}
-
-// src/ui/hooks/useMessages.ts
-var import_react2 = require("react");
-var MAX_RENDERED_MESSAGES = 100;
-function useMessages() {
-  const [messages, setMessages] = (0, import_react2.useState)([]);
-  const addMessage = (0, import_react2.useCallback)((msg) => {
-    setMessages((prev) => {
-      const updated = [...prev, msg];
-      if (updated.length > MAX_RENDERED_MESSAGES) {
-        return updated.slice(-MAX_RENDERED_MESSAGES);
-      }
-      return updated;
-    });
-  }, []);
-  return { messages, setMessages, addMessage };
-}
-
-// src/ui/hooks/useSlashCommands.ts
-var import_react3 = require("react");
 var import_agent_core = require("@robota-sdk/agent-core");
 
-// src/commands/slash-executor.ts
-var VALID_MODES2 = ["plan", "default", "acceptEdits", "bypassPermissions"];
-var HELP_TEXT = [
-  "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",
-  "  /language [lang]   \u2014 Set response language (ko, en, ja, zh)",
-  "  /cost              \u2014 Show session info",
-  "  /reset             \u2014 Delete settings and exit",
-  "  /exit              \u2014 Exit CLI"
-].join("\n");
-function handleHelp(addMessage) {
-  addMessage({ role: "system", content: HELP_TEXT });
-  return { handled: true };
-}
-function handleClear(addMessage, clearMessages, session) {
-  clearMessages();
-  session.clearHistory();
-  addMessage({ role: "system", content: "Conversation cleared." });
-  return { handled: true };
-}
-async function handleCompact(args, session, addMessage) {
-  const instructions = args.trim() || void 0;
-  const before = session.getContextState().usedPercentage;
-  addMessage({ role: "system", content: "Compacting context..." });
-  await session.compact(instructions);
-  const after = session.getContextState().usedPercentage;
-  addMessage({
-    role: "system",
-    content: `Context compacted: ${Math.round(before)}% -> ${Math.round(after)}%`
-  });
-  return { handled: true };
-}
-function handleMode(arg, session, addMessage) {
-  if (!arg) {
-    addMessage({ role: "system", content: `Current mode: ${session.getPermissionMode()}` });
-  } else if (VALID_MODES2.includes(arg)) {
-    session.setPermissionMode(arg);
-    addMessage({ role: "system", content: `Permission mode set to: ${arg}` });
-  } else {
-    addMessage({ role: "system", content: `Invalid mode. Valid: ${VALID_MODES2.join(" | ")}` });
-  }
-  return { handled: true };
-}
-function handleModel(modelId, addMessage) {
-  if (!modelId) {
-    addMessage({ role: "system", content: "Select a model from the /model submenu." });
-    return { handled: true };
-  }
-  return { handled: true, pendingModelId: modelId };
-}
-function handleCost(session, addMessage) {
-  addMessage({
-    role: "system",
-    content: `Session: ${session.getSessionId()}
-Messages: ${session.getMessageCount()}`
-  });
-  return { handled: true };
-}
-function handlePermissions(session, addMessage) {
-  const mode = session.getPermissionMode();
-  const sessionAllowed = session.getSessionAllowedTools();
-  const lines = [`Permission mode: ${mode}`];
-  if (sessionAllowed.length > 0) {
-    lines.push(`Session-approved tools: ${sessionAllowed.join(", ")}`);
-  } else {
-    lines.push("No session-approved tools.");
-  }
-  addMessage({ role: "system", content: lines.join("\n") });
-  return { handled: true };
-}
-function handleContext(session, addMessage) {
-  const ctx = session.getContextState();
-  addMessage({
-    role: "system",
-    content: `Context: ${ctx.usedTokens.toLocaleString()} / ${ctx.maxTokens.toLocaleString()} tokens (${Math.round(ctx.usedPercentage)}%)`
-  });
-  return { handled: true };
-}
-function handleLanguage(lang, addMessage) {
-  if (!lang) {
-    addMessage({ role: "system", content: "Usage: /language <code> (e.g., ko, en, ja, zh)" });
-    return { handled: true };
-  }
-  const settingsPath = getUserSettingsPath();
-  const settings = readSettings(settingsPath);
-  settings.language = lang;
-  writeSettings(settingsPath, settings);
-  addMessage({ role: "system", content: `Language set to "${lang}". Restarting...` });
-  return { handled: true, exitRequested: true };
-}
-function handleReset(addMessage) {
-  const settingsPath = getUserSettingsPath();
-  if (deleteSettings(settingsPath)) {
-    addMessage({ role: "system", content: `Deleted ${settingsPath}. Exiting...` });
-  } else {
-    addMessage({ role: "system", content: "No user settings found." });
-  }
-  return { handled: true, exitRequested: true };
-}
-async function handlePluginCommand(args, addMessage, callbacks) {
-  const parts = args.trim().split(/\s+/);
-  const subcommand = parts[0] ?? "";
-  const subArgs = parts.slice(1).join(" ").trim();
-  try {
-    switch (subcommand) {
-      case "":
-      case void 0:
-      case "manage": {
-        return { handled: true, triggerPluginTUI: true };
-      }
-      case "install": {
-        if (!subArgs) {
-          addMessage({ role: "system", content: "Usage: /plugin install <name>@<marketplace>" });
-          return { handled: true };
-        }
-        await callbacks.install(subArgs);
-        addMessage({ role: "system", content: `Installed plugin: ${subArgs}` });
-        return { handled: true };
-      }
-      case "uninstall": {
-        if (!subArgs) {
-          addMessage({ role: "system", content: "Usage: /plugin uninstall <name>@<marketplace>" });
-          return { handled: true };
-        }
-        await callbacks.uninstall(subArgs);
-        addMessage({ role: "system", content: `Uninstalled plugin: ${subArgs}` });
-        return { handled: true };
-      }
-      case "enable": {
-        if (!subArgs) {
-          addMessage({ role: "system", content: "Usage: /plugin enable <name>@<marketplace>" });
-          return { handled: true };
-        }
-        await callbacks.enable(subArgs);
-        addMessage({ role: "system", content: `Enabled plugin: ${subArgs}` });
-        return { handled: true };
-      }
-      case "disable": {
-        if (!subArgs) {
-          addMessage({ role: "system", content: "Usage: /plugin disable <name>@<marketplace>" });
-          return { handled: true };
-        }
-        await callbacks.disable(subArgs);
-        addMessage({ role: "system", content: `Disabled plugin: ${subArgs}` });
-        return { handled: true };
-      }
-      case "marketplace": {
-        const mpParts = subArgs.split(/\s+/);
-        const mpSubcommand = mpParts[0] ?? "";
-        const mpArgs = mpParts.slice(1).join(" ").trim();
-        if (mpSubcommand === "add" && mpArgs) {
-          const registeredName = await callbacks.marketplaceAdd(mpArgs);
-          addMessage({
-            role: "system",
-            content: `Added marketplace: "${registeredName}" (from ${mpArgs})
-Install plugins with: /plugin install <name>@${registeredName}`
-          });
-          return { handled: true };
-        } else if (mpSubcommand === "remove" && mpArgs) {
-          await callbacks.marketplaceRemove(mpArgs);
-          addMessage({
-            role: "system",
-            content: `Removed marketplace "${mpArgs}" and uninstalled its plugins.`
-          });
-          return { handled: true };
-        } else if (mpSubcommand === "update" && mpArgs) {
-          await callbacks.marketplaceUpdate(mpArgs);
-          addMessage({
-            role: "system",
-            content: `Updated marketplace "${mpArgs}".`
-          });
-          return { handled: true };
-        } else if (mpSubcommand === "list") {
-          const sources = await callbacks.marketplaceList();
-          if (sources.length === 0) {
-            addMessage({ role: "system", content: "No marketplace sources configured." });
-          } else {
-            const lines = sources.map((s) => `  ${s.name} (${s.type})`);
-            addMessage({ role: "system", content: `Marketplace sources:
-${lines.join("\n")}` });
-          }
-          return { handled: true };
-        } else {
-          addMessage({
-            role: "system",
-            content: "Usage: /plugin marketplace add <source> | remove <name> | update <name> | list"
-          });
-          return { handled: true };
-        }
-      }
-      default:
-        addMessage({ role: "system", content: `Unknown plugin subcommand: ${subcommand}` });
-        return { handled: true };
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    addMessage({ role: "system", content: `Plugin error: ${message}` });
-    return { handled: true };
-  }
-}
-async function handleReloadPlugins(addMessage, callbacks) {
-  await callbacks.reloadPlugins();
-  addMessage({ role: "system", content: "Plugins reload complete." });
-  return { handled: true };
-}
-async function executeSlashCommand(cmd, args, session, addMessage, clearMessages, registry, pluginCallbacks) {
-  switch (cmd) {
-    case "help":
-      return handleHelp(addMessage);
-    case "clear":
-      return handleClear(addMessage, clearMessages, session);
-    case "compact":
-      return handleCompact(args, session, addMessage);
-    case "mode":
-      return handleMode(args.split(/\s+/)[0] || void 0, session, addMessage);
-    case "model":
-      return handleModel(args.split(/\s+/)[0] || void 0, addMessage);
-    case "language":
-      return handleLanguage(args.split(/\s+/)[0] || void 0, addMessage);
-    case "cost":
-      return handleCost(session, addMessage);
-    case "permissions":
-      return handlePermissions(session, addMessage);
-    case "context":
-      return handleContext(session, addMessage);
-    case "reset":
-      return handleReset(addMessage);
-    case "exit":
-      return { handled: true, exitRequested: true };
-    case "plugin":
-      if (pluginCallbacks) {
-        return handlePluginCommand(args, addMessage, pluginCallbacks);
-      }
-      addMessage({ role: "system", content: "Plugin management is not available." });
-      return { handled: true };
-    case "reload-plugins":
-      if (pluginCallbacks) {
-        return handleReloadPlugins(addMessage, pluginCallbacks);
-      }
-      addMessage({ role: "system", content: "Plugin management is not available." });
-      return { handled: true };
-    default: {
-      const dynamicCmd = registry.getCommands().find((c) => c.name === cmd && (c.source === "skill" || c.source === "plugin"));
-      if (dynamicCmd) {
-        addMessage({ role: "system", content: `Invoking ${dynamicCmd.source}: ${cmd}` });
-        return { handled: false };
-      }
-      addMessage({ role: "system", content: `Unknown command "/${cmd}". Type /help for help.` });
-      return { handled: true };
-    }
+// src/commands/plugin-source.ts
+var PluginCommandSource = class {
+  name = "plugin";
+  plugins;
+  constructor(plugins) {
+    this.plugins = plugins;
   }
-}
-
-// src/ui/hooks/useSlashCommands.ts
-var EXIT_DELAY_MS = 500;
-function useSlashCommands(session, addMessage, setMessages, exit, registry, pendingModelChangeRef, setPendingModelId, pluginCallbacks, setShowPluginTUI) {
-  return (0, import_react3.useCallback)(
-    async (input) => {
-      const parts = input.slice(1).split(/\s+/);
-      const cmd = parts[0]?.toLowerCase() ?? "";
-      const args = parts.slice(1).join(" ");
-      const clearMessages = () => setMessages([]);
-      const slashAddMessage = (msg) => {
-        addMessage((0, import_agent_core.createSystemMessage)(msg.content));
-      };
-      const result = await executeSlashCommand(
-        cmd,
-        args,
-        session,
-        slashAddMessage,
-        clearMessages,
-        registry,
-        pluginCallbacks
-      );
-      if (result.pendingModelId) {
-        pendingModelChangeRef.current = result.pendingModelId;
-        setPendingModelId(result.pendingModelId);
-      }
-      if (result.triggerPluginTUI) {
-        setShowPluginTUI?.(true);
-      }
-      if (result.exitRequested) {
-        setTimeout(() => exit(), EXIT_DELAY_MS);
+  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
+        });
       }
-      return result.handled;
-    },
-    [
-      session,
-      addMessage,
-      setMessages,
-      exit,
-      registry,
-      pendingModelChangeRef,
-      setPendingModelId,
-      pluginCallbacks,
-      setShowPluginTUI
-    ]
-  );
-}
-
-// src/ui/hooks/useSubmitHandler.ts
-var import_react4 = require("react");
-var import_node_crypto = require("crypto");
-var import_agent_sdk2 = require("@robota-sdk/agent-sdk");
-var import_agent_core2 = require("@robota-sdk/agent-core");
-
-// src/utils/tool-call-extractor.ts
-var TOOL_ARG_MAX_LENGTH = 80;
-var TAIL_KEEP2 = 30;
-function extractToolCallsWithDiff(history, startIndex) {
-  const summaries = [];
-  for (let i = startIndex; i < history.length; i++) {
-    const msg = history[i];
-    if (msg.role === "assistant" && msg.toolCalls) {
-      for (const tc of msg.toolCalls) {
-        const value = parseFirstArgValue(tc.function.arguments);
-        const truncated = value.length > TOOL_ARG_MAX_LENGTH ? value.slice(0, TOOL_ARG_MAX_LENGTH - TAIL_KEEP2 - 3) + "..." + value.slice(-TAIL_KEEP2) : value;
-        const summary = {
-          line: `${tc.function.name}(${truncated})`
-        };
-        if (tc.function.name === "Edit") {
-          try {
-            const args = JSON.parse(tc.function.arguments);
-            const diff = extractEditDiff("Edit", args);
-            if (diff) {
-              summary.diffLines = diff.lines;
-              summary.diffFile = diff.file;
-            }
-          } catch {
-          }
-        }
-        summaries.push(summary);
+      for (const cmd of plugin.commands) {
+        commands.push({
+          name: cmd.name,
+          description: cmd.description,
+          source: "plugin",
+          skillContent: cmd.skillContent,
+          pluginDir: plugin.pluginDir
+        });
       }
     }
+    return commands;
   }
-  return summaries;
-}
-function parseFirstArgValue(argsJson) {
-  try {
-    const parsed = JSON.parse(argsJson);
-    const firstVal = Object.values(parsed)[0];
-    return typeof firstVal === "string" ? firstVal : JSON.stringify(firstVal);
-  } catch {
-    return argsJson;
-  }
-}
+};
 
 // src/utils/skill-prompt.ts
 var import_node_child_process = require("child_process");
@@ -815,518 +259,63 @@ async function preprocessShellCommands(content) {
     let output = "";
     try {
       output = (0, import_node_child_process.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/commands/skill-executor.ts
-function buildProcessedContent(skill, args, context) {
-  if (!skill.skillContent) return null;
-  return substituteVariables(skill.skillContent, args, context);
-}
-function buildInjectPrompt(skill, args, context) {
-  const processed = buildProcessedContent(skill, args, context);
-  if (processed) {
-    const userInstruction = args || skill.description;
-    return `<skill name="${skill.name}">
-${processed}
-</skill>
-
-Execute the "${skill.name}" skill: ${userInstruction}`;
-  }
-  return `Use the "${skill.name}" skill: ${args || skill.description}`;
-}
-async function executeSkill(skill, args, callbacks, context) {
-  if (skill.context === "fork") {
-    if (!callbacks.runInFork) {
-      throw new Error("Fork execution is not available. Agent tool deps may not be initialized.");
-    }
-    const content = buildProcessedContent(skill, args, context);
-    const prompt2 = content ?? `Use the "${skill.name}" skill: ${args || skill.description}`;
-    const options = {};
-    if (skill.agent) options.agent = skill.agent;
-    if (skill.allowedTools) options.allowedTools = skill.allowedTools;
-    const result = await callbacks.runInFork(prompt2, options);
-    return { mode: "fork", result };
-  }
-  const prompt = buildInjectPrompt(skill, args, context);
-  return { mode: "inject", prompt };
-}
-
-// src/ui/hooks/useSubmitHandler.ts
-function syncContextState(session, setter) {
-  const ctx = session.getContextState();
-  setter({ percentage: ctx.usedPercentage, usedTokens: ctx.usedTokens, maxTokens: ctx.maxTokens });
-}
-async function runSessionPrompt(prompt, session, addMessage, clearStreamingText, setIsThinking, setContextState, rawInput) {
-  setIsThinking(true);
-  clearStreamingText();
-  const historyBefore = session.getHistory().length;
-  try {
-    const response = await session.run(prompt, rawInput);
-    clearStreamingText();
-    const history = session.getHistory();
-    const toolSummaries = extractToolCallsWithDiff(
-      history,
-      historyBefore
-    );
-    if (toolSummaries.length > 0) {
-      addMessage(
-        (0, import_agent_core2.createToolMessage)(JSON.stringify(toolSummaries), {
-          toolCallId: (0, import_node_crypto.randomUUID)(),
-          name: `${toolSummaries.length} tools`
-        })
-      );
-    }
-    addMessage((0, import_agent_core2.createAssistantMessage)(response || "(empty response)"));
-    syncContextState(session, setContextState);
-  } catch (err) {
-    clearStreamingText();
-    const isAbortError = err instanceof DOMException && err.name === "AbortError" || err instanceof Error && (err.message.includes("aborted") || err.message.includes("abort"));
-    if (isAbortError) {
-      const history = session.getHistory();
-      const toolSummaries = extractToolCallsWithDiff(
-        history,
-        historyBefore
-      );
-      if (toolSummaries.length > 0) {
-        addMessage(
-          (0, import_agent_core2.createToolMessage)(JSON.stringify(toolSummaries), {
-            toolCallId: (0, import_node_crypto.randomUUID)(),
-            name: `${toolSummaries.length} tools`
-          })
-        );
-      }
-      const assistantParts = [];
-      let lastAssistantState = "complete";
-      for (let i = historyBefore; i < history.length; i++) {
-        const msg = history[i];
-        if (msg && msg.role === "assistant" && msg.content) {
-          assistantParts.push(msg.content);
-          if (msg.state === "interrupted") lastAssistantState = "interrupted";
-        }
-      }
-      if (assistantParts.length > 0) {
-        addMessage(
-          (0, import_agent_core2.createAssistantMessage)(assistantParts.join("\n\n"), { state: lastAssistantState })
-        );
-      }
-      addMessage((0, import_agent_core2.createSystemMessage)("Interrupted by user."));
-    } else {
-      const errMsg = err instanceof Error ? err.message : String(err);
-      addMessage((0, import_agent_core2.createSystemMessage)(`Error: ${errMsg}`));
-    }
-  } finally {
-    setIsThinking(false);
-  }
-}
-function createForkRunner(sessionKey) {
-  const deps = (0, import_agent_sdk2.retrieveAgentToolDeps)(sessionKey);
-  if (!deps) return void 0;
-  return async (content, options) => {
-    const agentType = options.agent ?? "general-purpose";
-    const agentDef = (0, import_agent_sdk2.getBuiltInAgent)(agentType) ?? deps.customAgentRegistry?.(agentType);
-    if (!agentDef) {
-      throw new Error(`Unknown agent type for fork execution: ${agentType}`);
-    }
-    const effectiveDef = options.allowedTools ? { ...agentDef, tools: options.allowedTools } : agentDef;
-    const subSession = (0, import_agent_sdk2.createSubagentSession)({
-      agentDefinition: effectiveDef,
-      parentConfig: deps.config,
-      parentContext: deps.context,
-      parentTools: deps.tools,
-      terminal: deps.terminal,
-      isForkWorker: true,
-      permissionHandler: deps.permissionHandler,
-      onTextDelta: deps.onTextDelta,
-      onToolExecution: deps.onToolExecution
-    });
-    return await subSession.run(content);
-  };
-}
-function findSkillCommand(input, registry) {
-  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;
-  return { skill: skillCmd, args: parts.slice(1).join(" ").trim() };
-}
-function useSubmitHandler(session, addMessage, handleSlashCommand, clearStreamingText, setIsThinking, setContextState, registry) {
-  return (0, import_react4.useCallback)(
-    async (input) => {
-      if (input.startsWith("/")) {
-        const handled = await handleSlashCommand(input);
-        if (handled) {
-          syncContextState(session, setContextState);
-          return;
-        }
-        const found = findSkillCommand(input, registry);
-        if (!found) return;
-        const { skill, args } = found;
-        if (skill.context === "fork") {
-          const runInFork = createForkRunner(session);
-          const result = await executeSkill(skill, args, { runInFork });
-          if (result.mode === "fork") {
-            addMessage((0, import_agent_core2.createAssistantMessage)(result.result ?? "(empty response)"));
-            syncContextState(session, setContextState);
-            return;
-          }
-          if (result.prompt) {
-            const cmdName2 = input.slice(1).split(/\s+/)[0]?.toLowerCase() ?? "";
-            const qualifiedName2 = registry.resolveQualifiedName(cmdName2);
-            const hookInput2 = qualifiedName2 ? `/${qualifiedName2}${input.slice(1 + cmdName2.length)}` : input;
-            return runSessionPrompt(
-              result.prompt,
-              session,
-              addMessage,
-              clearStreamingText,
-              setIsThinking,
-              setContextState,
-              hookInput2
-            );
-          }
-          return;
-        }
-        const prompt = await buildSkillPrompt(input, registry);
-        if (!prompt) return;
-        const cmdName = input.slice(1).split(/\s+/)[0]?.toLowerCase() ?? "";
-        const qualifiedName = registry.resolveQualifiedName(cmdName);
-        const hookInput = qualifiedName ? `/${qualifiedName}${input.slice(1 + cmdName.length)}` : input;
-        return runSessionPrompt(
-          prompt,
-          session,
-          addMessage,
-          clearStreamingText,
-          setIsThinking,
-          setContextState,
-          hookInput
-        );
-      }
-      addMessage((0, import_agent_core2.createUserMessage)(input));
-      return runSessionPrompt(
-        input,
-        session,
-        addMessage,
-        clearStreamingText,
-        setIsThinking,
-        setContextState
-      );
-    },
-    [
-      session,
-      addMessage,
-      handleSlashCommand,
-      clearStreamingText,
-      setIsThinking,
-      setContextState,
-      registry
-    ]
-  );
-}
-
-// src/ui/hooks/useCommandRegistry.ts
-var import_react5 = require("react");
-var import_node_os2 = require("os");
-var import_node_path3 = require("path");
-var import_agent_sdk3 = require("@robota-sdk/agent-sdk");
-
-// 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_core3 = require("@robota-sdk/agent-core");
-function buildModelSubcommands() {
-  const seen = /* @__PURE__ */ new Set();
-  const commands = [];
-  for (const model of Object.values(import_agent_core3.CLAUDE_MODELS)) {
-    if (seen.has(model.name)) continue;
-    seen.add(model.name);
-    commands.push({
-      name: model.id,
-      description: `${model.name} (${(0, import_agent_core3.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_fs3 = require("fs");
-var import_node_path2 = require("path");
-var import_node_os = require("os");
-var BOOLEAN_KEYS = /* @__PURE__ */ new Set(["disable-model-invocation", "user-invocable"]);
-var LIST_KEYS = /* @__PURE__ */ new Set(["allowed-tools"]);
-function kebabToCamel(key) {
-  return key.replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase());
-}
-function parseFrontmatter(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_KEYS.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_fs3.existsSync)(skillsDir)) return [];
-  const commands = [];
-  const entries = (0, import_node_fs3.readdirSync)(skillsDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const skillFile = (0, import_node_path2.join)(skillsDir, entry.name, "SKILL.md");
-    if (!(0, import_node_fs3.existsSync)(skillFile)) continue;
-    const content = (0, import_node_fs3.readFileSync)(skillFile, "utf-8");
-    const frontmatter = parseFrontmatter(content);
-    commands.push(buildCommand(frontmatter, content, entry.name));
-  }
-  return commands;
-}
-function scanCommandsDir(commandsDir) {
-  if (!(0, import_node_fs3.existsSync)(commandsDir)) return [];
-  const commands = [];
-  const entries = (0, import_node_fs3.readdirSync)(commandsDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const filePath = (0, import_node_path2.join)(commandsDir, entry.name);
-    const content = (0, import_node_fs3.readFileSync)(filePath, "utf-8");
-    const frontmatter = parseFrontmatter(content);
-    const fallbackName = (0, import_node_path2.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_os.homedir)();
-  }
-  getCommands() {
-    if (this.cachedCommands) return this.cachedCommands;
-    const sources = [
-      scanSkillsDir((0, import_node_path2.join)(this.cwd, ".claude", "skills")),
-      // 1. project .claude/skills
-      scanCommandsDir((0, import_node_path2.join)(this.cwd, ".claude", "commands")),
-      // 2. project .claude/commands (legacy)
-      scanSkillsDir((0, import_node_path2.join)(this.home, ".robota", "skills")),
-      // 3. user ~/.robota/skills
-      scanSkillsDir((0, import_node_path2.join)(this.cwd, ".agents", "skills"))
-      // 4. project .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);
-        }
-      }
+        timeout: 5e3,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trimEnd();
+    } catch {
+      output = "";
     }
-    this.cachedCommands = merged;
-    return this.cachedCommands;
-  }
-  /** Get skills that models can invoke (excludes disableModelInvocation: true) */
-  getModelInvocableSkills() {
-    return this.getCommands().filter((cmd) => cmd.disableModelInvocation !== true);
-  }
-  /** Get skills that users can invoke (excludes userInvocable: false) */
-  getUserInvocableSkills() {
-    return this.getCommands().filter((cmd) => cmd.userInvocable !== false);
+    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>
 
-// 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;
+Execute the "${cmd}" skill: ${userInstruction}`;
   }
-};
+  return `Use the "${cmd}" skill: ${userInstruction}`;
+}
 
-// src/ui/hooks/useCommandRegistry.ts
+// src/ui/hooks/plugin-hooks-merger.ts
+var import_node_path2 = require("path");
 function buildPluginEnv(plugin) {
-  const dataDir = (0, import_node_path3.join)((0, import_node_path3.dirname)((0, import_node_path3.dirname)(plugin.pluginDir)), "data", plugin.manifest.name);
+  const dataDir = (0, import_node_path2.join)((0, import_node_path2.dirname)((0, import_node_path2.dirname)(plugin.pluginDir)), "data", plugin.manifest.name);
   return {
     CLAUDE_PLUGIN_ROOT: plugin.pluginDir,
     CLAUDE_PLUGIN_PATH: plugin.pluginDir,
     CLAUDE_PLUGIN_DATA: dataDir
   };
 }
+function resolvePluginRoot(group, pluginDir) {
+  if (Array.isArray(group.hooks)) {
+    return {
+      ...group,
+      hooks: group.hooks.map((h) => {
+        if (typeof h.command === "string") {
+          return {
+            ...h,
+            command: h.command.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, pluginDir)
+          };
+        }
+        return h;
+      })
+    };
+  }
+  return group;
+}
 function mergePluginHooks(plugins) {
   const merged = {};
   for (const plugin of plugins) {
@@ -1338,78 +327,293 @@ function mergePluginHooks(plugins) {
       if (!Array.isArray(groups)) continue;
       if (!merged[event]) merged[event] = [];
       const resolved = groups.map((group) => {
-        const resolved2 = resolvePluginRoot(group, plugin.pluginDir);
-        if (typeof resolved2 === "object" && resolved2 !== null) {
-          resolved2.env = pluginEnv;
-        }
-        return resolved2;
+        const r = resolvePluginRoot(group, plugin.pluginDir);
+        r.env = pluginEnv;
+        return r;
       });
       merged[event].push(...resolved);
     }
   }
   return merged;
 }
-function resolvePluginRoot(group, pluginDir) {
-  if (typeof group !== "object" || group === null) return group;
-  const obj = group;
-  if (Array.isArray(obj.hooks)) {
-    return {
-      ...obj,
-      hooks: obj.hooks.map((h) => {
-        if (typeof h !== "object" || h === null) return h;
-        const hook = h;
-        if (typeof hook.command === "string") {
-          return {
-            ...hook,
-            command: hook.command.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, pluginDir)
-          };
-        }
-        return hook;
-      })
-    };
+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];
   }
-  return group;
+  if (configHooks) {
+    for (const [event, groups] of Object.entries(configHooks)) {
+      if (!Array.isArray(groups)) continue;
+      if (!merged[event]) merged[event] = [];
+      merged[event].push(...groups);
+    }
+  }
+  return merged;
 }
-function useCommandRegistry(cwd) {
-  const resultRef = (0, import_react5.useRef)(null);
-  if (resultRef.current === null) {
-    const registry = new CommandRegistry();
-    registry.addSource(new BuiltinCommandSource());
-    registry.addSource(new SkillCommandSource(cwd));
-    let pluginHooks = {};
-    const pluginsDir = (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".robota", "plugins");
-    const loader = new import_agent_sdk3.BundlePluginLoader(pluginsDir);
-    try {
-      const plugins = loader.loadPluginsSync();
-      if (plugins.length > 0) {
-        registry.addSource(new PluginCommandSource(plugins));
-        pluginHooks = mergePluginHooks(plugins);
+
+// src/ui/hooks/useInteractiveSession.ts
+var MAX_RENDERED_MESSAGES = 100;
+function initializeSession(props, permissionHandler) {
+  const cwd = props.cwd ?? process.cwd();
+  const registry = new import_agent_sdk.CommandRegistry();
+  registry.addSource(new import_agent_sdk.BuiltinCommandSource());
+  registry.addSource(new import_agent_sdk.SkillCommandSource(cwd));
+  let pluginHooks = {};
+  const pluginsDir = (0, import_node_path3.join)((0, import_node_os.homedir)(), ".robota", "plugins");
+  const loader = new import_agent_sdk.BundlePluginLoader(pluginsDir);
+  try {
+    const plugins = loader.loadPluginsSync();
+    if (plugins.length > 0) {
+      registry.addSource(new PluginCommandSource(plugins));
+      pluginHooks = mergePluginHooks(plugins);
+    }
+  } catch {
+  }
+  const mergedConfig = {
+    ...props.config,
+    hooks: mergeHooksIntoConfig(
+      props.config.hooks,
+      pluginHooks
+    )
+  };
+  const interactiveSession = new import_agent_sdk.InteractiveSession({
+    config: mergedConfig,
+    context: props.context,
+    projectInfo: props.projectInfo,
+    sessionStore: props.sessionStore,
+    permissionMode: props.permissionMode,
+    maxTurns: props.maxTurns,
+    cwd,
+    permissionHandler
+  });
+  return {
+    interactiveSession,
+    registry,
+    commandExecutor: new import_agent_sdk.SystemCommandExecutor(),
+    pluginHooks
+  };
+}
+function useInteractiveSession(props) {
+  const [messages, setMessages] = (0, import_react.useState)([]);
+  const addMessage = (0, import_react.useCallback)((msg) => {
+    setMessages((prev) => {
+      const updated = [...prev, msg];
+      return updated.length > MAX_RENDERED_MESSAGES ? updated.slice(-MAX_RENDERED_MESSAGES) : updated;
+    });
+  }, []);
+  const [streamingText, setStreamingText] = (0, import_react.useState)("");
+  const [activeTools, setActiveTools] = (0, import_react.useState)([]);
+  const [isThinking, setIsThinking] = (0, import_react.useState)(false);
+  const [isAborting, setIsAborting] = (0, import_react.useState)(false);
+  const [pendingPrompt, setPendingPrompt] = (0, import_react.useState)(null);
+  const [contextState, setContextState] = (0, import_react.useState)({ percentage: 0, usedTokens: 0, maxTokens: 0 });
+  const [permissionRequest, setPermissionRequest] = (0, import_react.useState)(null);
+  const permissionQueueRef = (0, import_react.useRef)([]);
+  const processingRef = (0, import_react.useRef)(false);
+  const processNextPermission = (0, import_react.useCallback)(() => {
+    if (processingRef.current) return;
+    const next = permissionQueueRef.current[0];
+    if (!next) {
+      setPermissionRequest(null);
+      return;
+    }
+    processingRef.current = true;
+    setPermissionRequest({
+      toolName: next.toolName,
+      toolArgs: next.toolArgs,
+      resolve: (result) => {
+        permissionQueueRef.current.shift();
+        processingRef.current = false;
+        setPermissionRequest(null);
+        next.resolve(result);
+        setTimeout(() => processNextPermission(), 0);
       }
-    } catch {
+    });
+  }, []);
+  const permissionHandler = (0, import_react.useCallback)(
+    (toolName, toolArgs) => new Promise((resolve) => {
+      permissionQueueRef.current.push({ toolName, toolArgs, resolve });
+      processNextPermission();
+    }),
+    [processNextPermission]
+  );
+  const stateRef = (0, import_react.useRef)(null);
+  if (stateRef.current === null) {
+    stateRef.current = initializeSession(props, permissionHandler);
+  }
+  const { interactiveSession, registry, commandExecutor } = stateRef.current;
+  (0, import_react.useEffect)(() => {
+    let streamBuf = "";
+    const onTextDelta = (delta) => {
+      streamBuf += delta;
+      setStreamingText(streamBuf);
+    };
+    const onToolStart = (state) => {
+      setActiveTools((prev) => [...prev, state]);
+    };
+    const onToolEnd = (state) => {
+      setActiveTools(
+        (prev) => prev.map((t) => t.toolName === state.toolName && t.isRunning ? state : t)
+      );
+    };
+    const onThinking = (thinking) => {
+      setIsThinking(thinking);
+      if (!thinking) {
+        setIsAborting(false);
+        streamBuf = "";
+        setStreamingText("");
+        setActiveTools([]);
+      }
+    };
+    const onComplete = (result) => {
+      setContextState({
+        percentage: result.contextState.usedPercentage,
+        usedTokens: result.contextState.usedTokens,
+        maxTokens: result.contextState.maxTokens
+      });
+    };
+    const onInterrupted = () => {
+    };
+    const onError = () => {
+    };
+    interactiveSession.on("text_delta", onTextDelta);
+    interactiveSession.on("tool_start", onToolStart);
+    interactiveSession.on("tool_end", onToolEnd);
+    interactiveSession.on("thinking", onThinking);
+    interactiveSession.on("complete", onComplete);
+    interactiveSession.on("interrupted", onInterrupted);
+    interactiveSession.on("error", onError);
+    return () => {
+      interactiveSession.off("text_delta", onTextDelta);
+      interactiveSession.off("tool_start", onToolStart);
+      interactiveSession.off("tool_end", onToolEnd);
+      interactiveSession.off("thinking", onThinking);
+      interactiveSession.off("complete", onComplete);
+      interactiveSession.off("interrupted", onInterrupted);
+      interactiveSession.off("error", onError);
+    };
+  }, [interactiveSession]);
+  (0, import_react.useEffect)(() => {
+    if (!isThinking) {
+      const sessionMessages = interactiveSession.getMessages();
+      if (sessionMessages.length > 0) {
+        setMessages(
+          sessionMessages.length > MAX_RENDERED_MESSAGES ? sessionMessages.slice(-MAX_RENDERED_MESSAGES) : [...sessionMessages]
+        );
+      }
+      setPendingPrompt(interactiveSession.getPendingPrompt());
     }
-    resultRef.current = { registry, pluginHooks };
+  }, [isThinking, interactiveSession]);
+  const handleSubmit = (0, import_react.useCallback)(
+    async (input) => {
+      if (input.startsWith("/")) {
+        const parts = input.slice(1).split(/\s+/);
+        const cmd = parts[0]?.toLowerCase() ?? "";
+        const args = parts.slice(1).join(" ");
+        const result = await commandExecutor.execute(cmd, interactiveSession, args);
+        if (result) {
+          addMessage((0, import_agent_core.createSystemMessage)(result.message));
+          const effects = interactiveSession;
+          if (result.data?.modelId) {
+            effects._pendingModelId = result.data.modelId;
+            return;
+          }
+          if (result.data?.language) {
+            effects._pendingLanguage = result.data.language;
+            return;
+          }
+          if (result.data?.resetRequested) {
+            effects._resetRequested = true;
+            return;
+          }
+          const ctx = interactiveSession.getContextState();
+          setContextState({
+            percentage: ctx.usedPercentage,
+            usedTokens: ctx.usedTokens,
+            maxTokens: ctx.maxTokens
+          });
+          return;
+        }
+        const skillCmd = registry.getCommands().find((c) => c.name === cmd && (c.source === "skill" || c.source === "plugin"));
+        if (skillCmd) {
+          const prompt = await buildSkillPrompt(input, registry);
+          if (prompt) {
+            await interactiveSession.submit(prompt);
+            return;
+          }
+        }
+        if (cmd === "exit") {
+          interactiveSession._exitRequested = true;
+          return;
+        }
+        if (cmd === "plugin") {
+          interactiveSession._triggerPluginTUI = true;
+          return;
+        }
+        addMessage((0, import_agent_core.createSystemMessage)(`Unknown command "/${cmd}". Type /help for help.`));
+        return;
+      }
+      await interactiveSession.submit(input);
+    },
+    [interactiveSession, commandExecutor, registry, addMessage]
+  );
+  const handleAbort = (0, import_react.useCallback)(() => {
+    setIsAborting(true);
+    interactiveSession.abort();
+  }, [interactiveSession]);
+  const handleCancelQueue = (0, import_react.useCallback)(() => {
+    interactiveSession.cancelQueue();
+    setPendingPrompt(null);
+  }, [interactiveSession]);
+  if (contextState.maxTokens === 0) {
+    const ctx = interactiveSession.getContextState();
+    setContextState({
+      percentage: ctx.usedPercentage,
+      usedTokens: ctx.usedTokens,
+      maxTokens: ctx.maxTokens
+    });
   }
-  return resultRef.current;
+  return {
+    interactiveSession,
+    registry,
+    commandExecutor,
+    pluginHooks: stateRef.current.pluginHooks,
+    messages,
+    addMessage,
+    setMessages,
+    streamingText,
+    activeTools,
+    isThinking,
+    isAborting,
+    pendingPrompt,
+    permissionRequest,
+    contextState,
+    handleSubmit,
+    handleAbort,
+    handleCancelQueue
+  };
 }
 
 // src/ui/hooks/usePluginCallbacks.ts
-var import_react6 = require("react");
-var import_node_os3 = require("os");
+var import_react2 = require("react");
+var import_node_os2 = require("os");
 var import_node_path4 = require("path");
-var import_agent_sdk4 = require("@robota-sdk/agent-sdk");
+var import_agent_sdk2 = require("@robota-sdk/agent-sdk");
 function usePluginCallbacks(cwd) {
-  return (0, import_react6.useMemo)(() => {
-    const home = (0, import_node_os3.homedir)();
+  return (0, import_react2.useMemo)(() => {
+    const home = (0, import_node_os2.homedir)();
     const pluginsDir = (0, import_node_path4.join)(home, ".robota", "plugins");
     const userSettingsPath = (0, import_node_path4.join)(home, ".robota", "settings.json");
-    const settingsStore = new import_agent_sdk4.PluginSettingsStore(userSettingsPath);
-    const marketplace = new import_agent_sdk4.MarketplaceClient({ pluginsDir });
-    const installer = new import_agent_sdk4.BundlePluginInstaller({
+    const settingsStore = new import_agent_sdk2.PluginSettingsStore(userSettingsPath);
+    const marketplace = new import_agent_sdk2.MarketplaceClient({ pluginsDir });
+    const installer = new import_agent_sdk2.BundlePluginInstaller({
       pluginsDir,
       settingsStore,
       marketplaceClient: marketplace
     });
-    const loader = new import_agent_sdk4.BundlePluginLoader(pluginsDir);
+    const loader = new import_agent_sdk2.BundlePluginLoader(pluginsDir);
     return {
       listInstalled: async () => {
         const plugins = await loader.loadAll();
@@ -1448,7 +652,7 @@ function usePluginCallbacks(cwd) {
         }
         if (scope === "project") {
           const projectPluginsDir = (0, import_node_path4.join)(cwd, ".robota", "plugins");
-          const projectInstaller = new import_agent_sdk4.BundlePluginInstaller({
+          const projectInstaller = new import_agent_sdk2.BundlePluginInstaller({
             pluginsDir: projectPluginsDir,
             settingsStore,
             marketplaceClient: marketplace
@@ -1497,9 +701,9 @@ function usePluginCallbacks(cwd) {
 }
 
 // src/ui/MessageList.tsx
-var import_react7 = __toESM(require("react"), 1);
+var import_react3 = __toESM(require("react"), 1);
 var import_ink2 = require("ink");
-var import_agent_core4 = require("@robota-sdk/agent-core");
+var import_agent_core2 = require("@robota-sdk/agent-core");
 
 // src/ui/render-markdown.ts
 var import_marked = require("marked");
@@ -1585,7 +789,7 @@ function RoleLabel({ role }) {
   }
 }
 function ToolMessage({ message }) {
-  if (!(0, import_agent_core4.isToolMessage)(message)) {
+  if (!(0, import_agent_core2.isToolMessage)(message)) {
     return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, {});
   }
   const toolName = message.name;
@@ -1645,10 +849,10 @@ function ToolMessage({ message }) {
     ] }, i))
   ] });
 }
-var MessageItem = import_react7.default.memo(function MessageItem2({
+var MessageItem = import_react3.default.memo(function MessageItem2({
   message
 }) {
-  if ((0, import_agent_core4.isToolMessage)(message)) {
+  if ((0, import_agent_core2.isToolMessage)(message)) {
     return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ToolMessage, { message });
   }
   const content = message.content ?? "";
@@ -1656,7 +860,7 @@ var MessageItem = import_react7.default.memo(function MessageItem2({
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Box, { flexDirection: "column", marginBottom: 1, children: [
     /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(RoleLabel, { role: message.role }) }),
     /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Text, { children: " " }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Box, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Text, { wrap: "wrap", children: (0, import_agent_core4.isAssistantMessage)(message) ? renderMarkdown(content + (isInterrupted ? "\n\n_(interrupted)_" : "")) : content }) })
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Box, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Text, { wrap: "wrap", children: (0, import_agent_core2.isAssistantMessage)(message) ? renderMarkdown(content + (isInterrupted ? "\n\n_(interrupted)_" : "")) : content }) })
   ] });
 });
 function MessageList({ messages }) {
@@ -1665,7 +869,7 @@ function MessageList({ messages }) {
 
 // src/ui/StatusBar.tsx
 var import_ink3 = require("ink");
-var import_agent_core5 = require("@robota-sdk/agent-core");
+var import_agent_core3 = require("@robota-sdk/agent-core");
 var import_jsx_runtime3 = require("react/jsx-runtime");
 var CONTEXT_YELLOW_THRESHOLD = 70;
 var CONTEXT_RED_THRESHOLD = 90;
@@ -1705,9 +909,9 @@ function StatusBar({
             "Context: ",
             Math.round(contextPercentage),
             "% (",
-            (0, import_agent_core5.formatTokenCount)(contextUsedTokens),
+            (0, import_agent_core3.formatTokenCount)(contextUsedTokens),
             "/",
-            (0, import_agent_core5.formatTokenCount)(contextMaxTokens),
+            (0, import_agent_core3.formatTokenCount)(contextMaxTokens),
             ")"
           ] })
         ] }),
@@ -1724,11 +928,11 @@ function StatusBar({
 }
 
 // src/ui/InputArea.tsx
-var import_react10 = __toESM(require("react"), 1);
+var import_react6 = __toESM(require("react"), 1);
 var import_ink7 = require("ink");
 
 // src/ui/CjkTextInput.tsx
-var import_react8 = require("react");
+var import_react4 = require("react");
 var import_ink4 = require("ink");
 var import_chalk = __toESM(require("chalk"), 1);
 var import_string_width = __toESM(require("string-width"), 1);
@@ -1774,11 +978,11 @@ function CjkTextInput({
   showCursor = true,
   availableWidth
 }) {
-  const valueRef = (0, import_react8.useRef)(value);
-  const cursorRef = (0, import_react8.useRef)(value.length);
-  const [, forceRender] = (0, import_react8.useState)(0);
-  const isPastingRef = (0, import_react8.useRef)(false);
-  const pasteBufferRef = (0, import_react8.useRef)("");
+  const valueRef = (0, import_react4.useRef)(value);
+  const cursorRef = (0, import_react4.useRef)(value.length);
+  const [, forceRender] = (0, import_react4.useState)(0);
+  const isPastingRef = (0, import_react4.useRef)(false);
+  const pasteBufferRef = (0, import_react4.useRef)("");
   if (value !== valueRef.current) {
     valueRef.current = value;
     if (cursorRef.current > value.length) {
@@ -1907,15 +1111,15 @@ function renderWithCursor(value, cursorOffset, placeholder, showCursor) {
 }
 
 // src/ui/WaveText.tsx
-var import_react9 = require("react");
+var import_react5 = require("react");
 var import_ink5 = require("ink");
 var import_jsx_runtime5 = require("react/jsx-runtime");
 var WAVE_COLORS = ["#666666", "#888888", "#aaaaaa", "#888888"];
 var INTERVAL_MS = 400;
 var CHARS_PER_GROUP = 4;
 function WaveText({ text }) {
-  const [tick, setTick] = (0, import_react9.useState)(0);
-  (0, import_react9.useEffect)(() => {
+  const [tick, setTick] = (0, import_react5.useState)(0);
+  (0, import_react5.useEffect)(() => {
     const timer = setInterval(() => {
       setTick((prev) => prev + 1);
     }, INTERVAL_MS);
@@ -1987,16 +1191,16 @@ function parseSlashInput(value) {
   return { isSlash: true, parentCommand: parent, filter: rest };
 }
 function useAutocomplete(value, registry) {
-  const [selectedIndex, setSelectedIndex] = (0, import_react10.useState)(0);
-  const [dismissed, setDismissed] = (0, import_react10.useState)(false);
-  const prevValueRef = import_react10.default.useRef(value);
+  const [selectedIndex, setSelectedIndex] = (0, import_react6.useState)(0);
+  const [dismissed, setDismissed] = (0, import_react6.useState)(false);
+  const prevValueRef = import_react6.default.useRef(value);
   if (prevValueRef.current !== value) {
     prevValueRef.current = value;
     if (dismissed) setDismissed(false);
   }
   const parsed = parseSlashInput(value);
   const isSubcommandMode = parsed.isSlash && parsed.parentCommand.length > 0;
-  const filteredCommands = (0, import_react10.useMemo)(() => {
+  const filteredCommands = (0, import_react6.useMemo)(() => {
     if (!registry || !parsed.isSlash || dismissed) return [];
     if (isSubcommandMode) {
       const subs = registry.getSubcommands(parsed.parentCommand);
@@ -2041,12 +1245,12 @@ function InputArea({
   pendingPrompt,
   registry
 }) {
-  const [value, setValue] = (0, import_react10.useState)("");
-  const pasteStore = (0, import_react10.useRef)(/* @__PURE__ */ new Map());
+  const [value, setValue] = (0, import_react6.useState)("");
+  const pasteStore = (0, import_react6.useRef)(/* @__PURE__ */ new Map());
   const { stdout } = (0, import_ink7.useStdout)();
   const terminalColumns = stdout?.columns ?? 80;
   const availableWidth = Math.max(1, terminalColumns - INPUT_AREA_OVERHEAD);
-  const pasteIdRef = (0, import_react10.useRef)(0);
+  const pasteIdRef = (0, import_react6.useRef)(0);
   const {
     showPopup,
     filteredCommands,
@@ -2055,7 +1259,7 @@ function InputArea({
     isSubcommandMode,
     setShowPopup
   } = useAutocomplete(value, registry);
-  const handlePaste = (0, import_react10.useCallback)((text) => {
+  const handlePaste = (0, import_react6.useCallback)((text) => {
     pasteIdRef.current += 1;
     const id = pasteIdRef.current;
     pasteStore.current.set(id, text);
@@ -2063,7 +1267,7 @@ function InputArea({
     const label = `[Pasted text #${id} +${lineCount} lines]`;
     setValue((prev) => prev ? `${prev} ${label}` : label);
   }, []);
-  const handleSubmit = (0, import_react10.useCallback)(
+  const handleSubmit = (0, import_react6.useCallback)(
     (text) => {
       const trimmed = text.trim();
       if (trimmed.length === 0) return;
@@ -2079,7 +1283,7 @@ function InputArea({
     },
     [showPopup, filteredCommands, selectedIndex, onSubmit]
   );
-  const selectCommand = (0, import_react10.useCallback)(
+  const selectCommand = (0, import_react6.useCallback)(
     (cmd) => {
       const parsed = parseSlashInput(value);
       if (parsed.parentCommand) {
@@ -2164,7 +1368,7 @@ function InputArea({
 }
 
 // src/ui/ConfirmPrompt.tsx
-var import_react11 = require("react");
+var import_react7 = require("react");
 var import_ink8 = require("ink");
 var import_jsx_runtime8 = require("react/jsx-runtime");
 function ConfirmPrompt({
@@ -2172,9 +1376,9 @@ function ConfirmPrompt({
   options = ["Yes", "No"],
   onSelect
 }) {
-  const [selected, setSelected] = (0, import_react11.useState)(0);
-  const resolvedRef = (0, import_react11.useRef)(false);
-  const doSelect = (0, import_react11.useCallback)(
+  const [selected, setSelected] = (0, import_react7.useState)(0);
+  const resolvedRef = (0, import_react7.useRef)(false);
+  const doSelect = (0, import_react7.useCallback)(
     (index) => {
       if (resolvedRef.current) return;
       resolvedRef.current = true;
@@ -2207,7 +1411,7 @@ function ConfirmPrompt({
 }
 
 // src/ui/PermissionPrompt.tsx
-var import_react12 = __toESM(require("react"), 1);
+var import_react8 = __toESM(require("react"), 1);
 var import_ink9 = require("ink");
 var import_jsx_runtime9 = require("react/jsx-runtime");
 var OPTIONS = ["Allow", "Allow always (this session)", "Deny"];
@@ -2217,15 +1421,15 @@ function formatArgs(args) {
   return entries.map(([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`).join(", ");
 }
 function PermissionPrompt({ request }) {
-  const [selected, setSelected] = import_react12.default.useState(0);
-  const resolvedRef = import_react12.default.useRef(false);
-  const prevRequestRef = import_react12.default.useRef(request);
+  const [selected, setSelected] = import_react8.default.useState(0);
+  const resolvedRef = import_react8.default.useRef(false);
+  const prevRequestRef = import_react8.default.useRef(request);
   if (prevRequestRef.current !== request) {
     prevRequestRef.current = request;
     resolvedRef.current = false;
     setSelected(0);
   }
-  const doResolve = import_react12.default.useCallback(
+  const doResolve = import_react8.default.useCallback(
     (index) => {
       if (resolvedRef.current) return;
       resolvedRef.current = true;
@@ -2314,10 +1518,10 @@ function StreamingIndicator({ text, activeTools }) {
 }
 
 // src/ui/PluginTUI.tsx
-var import_react15 = require("react");
+var import_react11 = require("react");
 
 // src/ui/MenuSelect.tsx
-var import_react13 = require("react");
+var import_react9 = require("react");
 var import_ink11 = require("ink");
 var import_jsx_runtime11 = require("react/jsx-runtime");
 function MenuSelect({
@@ -2328,10 +1532,10 @@ function MenuSelect({
   loading,
   error
 }) {
-  const [selected, setSelected] = (0, import_react13.useState)(0);
-  const selectedRef = (0, import_react13.useRef)(0);
-  const resolvedRef = (0, import_react13.useRef)(false);
-  const doSelect = (0, import_react13.useCallback)(
+  const [selected, setSelected] = (0, import_react9.useState)(0);
+  const selectedRef = (0, import_react9.useRef)(0);
+  const resolvedRef = (0, import_react9.useRef)(false);
+  const doSelect = (0, import_react9.useCallback)(
     (index) => {
       if (resolvedRef.current || items.length === 0) return;
       resolvedRef.current = true;
@@ -2381,7 +1585,7 @@ function MenuSelect({
 }
 
 // src/ui/TextPrompt.tsx
-var import_react14 = require("react");
+var import_react10 = require("react");
 var import_ink12 = require("ink");
 var import_jsx_runtime12 = require("react/jsx-runtime");
 function TextPrompt({
@@ -2391,11 +1595,11 @@ function TextPrompt({
   onCancel,
   validate
 }) {
-  const [value, setValue] = (0, import_react14.useState)("");
-  const [error, setError] = (0, import_react14.useState)();
-  const resolvedRef = (0, import_react14.useRef)(false);
-  const valueRef = (0, import_react14.useRef)("");
-  const handleSubmit = (0, import_react14.useCallback)(() => {
+  const [value, setValue] = (0, import_react10.useState)("");
+  const [error, setError] = (0, import_react10.useState)();
+  const resolvedRef = (0, import_react10.useRef)(false);
+  const valueRef = (0, import_react10.useRef)("");
+  const handleSubmit = (0, import_react10.useCallback)(() => {
     if (resolvedRef.current) return;
     const trimmed = valueRef.current.trim();
     if (!trimmed) return;
@@ -2539,19 +1743,19 @@ function handleInstalledActionSelect(value, pluginId, callbacks, nav) {
 // src/ui/PluginTUI.tsx
 var import_jsx_runtime13 = require("react/jsx-runtime");
 function PluginTUI({ callbacks, onClose, addMessage }) {
-  const [stack, setStack] = (0, import_react15.useState)([{ screen: "main" }]);
-  const [items, setItems] = (0, import_react15.useState)([]);
-  const [loading, setLoading] = (0, import_react15.useState)(false);
-  const [error, setError] = (0, import_react15.useState)();
-  const [confirm, setConfirm] = (0, import_react15.useState)();
-  const [refreshCounter, setRefreshCounter] = (0, import_react15.useState)(0);
+  const [stack, setStack] = (0, import_react11.useState)([{ screen: "main" }]);
+  const [items, setItems] = (0, import_react11.useState)([]);
+  const [loading, setLoading] = (0, import_react11.useState)(false);
+  const [error, setError] = (0, import_react11.useState)();
+  const [confirm, setConfirm] = (0, import_react11.useState)();
+  const [refreshCounter, setRefreshCounter] = (0, import_react11.useState)(0);
   const current = stack[stack.length - 1] ?? { screen: "main" };
-  const push = (0, import_react15.useCallback)((state) => {
+  const push = (0, import_react11.useCallback)((state) => {
     setStack((prev) => [...prev, state]);
     setItems([]);
     setError(void 0);
   }, []);
-  const pop = (0, import_react15.useCallback)(() => {
+  const pop = (0, import_react11.useCallback)(() => {
     setStack((prev) => {
       if (prev.length <= 1) {
         onClose();
@@ -2562,7 +1766,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     setItems([]);
     setError(void 0);
   }, [onClose]);
-  const popN = (0, import_react15.useCallback)(
+  const popN = (0, import_react11.useCallback)(
     (n) => {
       setStack((prev) => {
         const next = prev.slice(0, Math.max(1, prev.length - n));
@@ -2577,18 +1781,18 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     },
     [onClose]
   );
-  const notify = (0, import_react15.useCallback)(
+  const notify = (0, import_react11.useCallback)(
     (content) => {
       addMessage?.({ role: "system", content });
     },
     [addMessage]
   );
-  const refresh = (0, import_react15.useCallback)(() => {
+  const refresh = (0, import_react11.useCallback)(() => {
     setItems([]);
     setRefreshCounter((c) => c + 1);
   }, []);
   const nav = { push, pop, popN, notify, setConfirm, refresh };
-  (0, import_react15.useEffect)(() => {
+  (0, import_react11.useEffect)(() => {
     const screen2 = current.screen;
     if (screen2 === "marketplace-list") {
       setLoading(true);
@@ -2638,7 +1842,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
       });
     }
   }, [stack.length, current.screen, current.context?.marketplace, callbacks, refreshCounter]);
-  const handleSelect = (0, import_react15.useCallback)(
+  const handleSelect = (0, import_react11.useCallback)(
     (value) => {
       const screen2 = current.screen;
       const ctx = current.context;
@@ -2656,7 +1860,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     },
     [current, items, callbacks, push, pop, popN, notify, setConfirm, refresh]
   );
-  const handleTextSubmit = (0, import_react15.useCallback)(
+  const handleTextSubmit = (0, import_react11.useCallback)(
     (value) => {
       if (current.screen === "marketplace-add") {
         callbacks.marketplaceAdd(value).then((name) => {
@@ -2766,104 +1970,90 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
 
 // src/ui/App.tsx
 var import_jsx_runtime14 = require("react/jsx-runtime");
-var EXIT_DELAY_MS2 = 500;
-function mergeHooksIntoConfig(configHooks, pluginHooks) {
-  const pluginKeys = Object.keys(pluginHooks);
-  if (pluginKeys.length === 0) return configHooks;
-  const merged = {};
-  for (const [event, groups] of Object.entries(pluginHooks)) {
-    merged[event] = [...groups];
-  }
-  if (configHooks) {
-    for (const [event, groups] of Object.entries(configHooks)) {
-      if (!Array.isArray(groups)) continue;
-      if (!merged[event]) merged[event] = [];
-      merged[event].push(...groups);
-    }
-  }
-  return merged;
-}
+var EXIT_DELAY_MS = 500;
 function App(props) {
   const { exit } = (0, import_ink13.useApp)();
-  const { registry, pluginHooks } = useCommandRegistry(props.cwd ?? process.cwd());
-  const configWithPluginHooks = {
-    ...props.config,
-    hooks: mergeHooksIntoConfig(
-      props.config.hooks,
-      pluginHooks
-    )
-  };
-  const { session, permissionRequest, streamingText, clearStreamingText, activeTools } = useSession(
-    { ...props, config: configWithPluginHooks }
-  );
-  const { messages, setMessages, addMessage } = useMessages();
-  const [isThinking, setIsThinking] = (0, import_react16.useState)(false);
-  const initialCtx = session.getContextState();
-  const [contextState, setContextState] = (0, import_react16.useState)({
-    percentage: initialCtx.usedPercentage,
-    usedTokens: initialCtx.usedTokens,
-    maxTokens: initialCtx.maxTokens
-  });
-  const pendingModelChangeRef = (0, import_react16.useRef)(null);
-  const [pendingModelId, setPendingModelId] = (0, import_react16.useState)(null);
-  const [showPluginTUI, setShowPluginTUI] = (0, import_react16.useState)(false);
-  const [isAborting, setIsAborting] = (0, import_react16.useState)(false);
-  const [pendingPrompt, setPendingPrompt] = (0, import_react16.useState)(null);
-  const pendingPromptRef = (0, import_react16.useRef)(null);
-  const pluginCallbacks = usePluginCallbacks(props.cwd ?? process.cwd());
-  const handleSlashCommand = useSlashCommands(
-    session,
-    addMessage,
-    setMessages,
-    exit,
+  const cwd = props.cwd ?? process.cwd();
+  const {
+    interactiveSession,
     registry,
-    pendingModelChangeRef,
-    setPendingModelId,
-    pluginCallbacks,
-    setShowPluginTUI
-  );
-  const executePrompt = useSubmitHandler(
-    session,
+    messages,
     addMessage,
-    handleSlashCommand,
-    clearStreamingText,
-    setIsThinking,
-    setContextState,
-    registry
-  );
-  const handleSubmit = (0, import_react16.useCallback)(
-    async (input) => {
-      if (isThinking) {
-        setPendingPrompt(input);
-        pendingPromptRef.current = input;
-        return;
+    streamingText,
+    activeTools,
+    isThinking,
+    isAborting,
+    pendingPrompt,
+    permissionRequest,
+    contextState,
+    handleSubmit: baseHandleSubmit,
+    handleAbort,
+    handleCancelQueue
+  } = useInteractiveSession({
+    config: props.config,
+    context: props.context,
+    projectInfo: props.projectInfo,
+    sessionStore: props.sessionStore,
+    permissionMode: props.permissionMode,
+    maxTurns: props.maxTurns,
+    cwd
+  });
+  const pluginCallbacks = usePluginCallbacks(cwd);
+  const [pendingModelId, setPendingModelId] = (0, import_react12.useState)(null);
+  const pendingModelChangeRef = (0, import_react12.useRef)(null);
+  const [showPluginTUI, setShowPluginTUI] = (0, import_react12.useState)(false);
+  const handleSubmit = async (input) => {
+    await baseHandleSubmit(input);
+    const sideEffects = interactiveSession;
+    if (sideEffects._pendingModelId) {
+      const modelId = sideEffects._pendingModelId;
+      delete sideEffects._pendingModelId;
+      pendingModelChangeRef.current = modelId;
+      setPendingModelId(modelId);
+      return;
+    }
+    if (sideEffects._pendingLanguage) {
+      const lang = sideEffects._pendingLanguage;
+      delete sideEffects._pendingLanguage;
+      const settingsPath = getUserSettingsPath();
+      const settings = readSettings(settingsPath);
+      settings.language = lang;
+      writeSettings(settingsPath, settings);
+      addMessage((0, import_agent_core4.createSystemMessage)(`Language set to "${lang}". Restarting...`));
+      setTimeout(() => exit(), EXIT_DELAY_MS);
+      return;
+    }
+    if (sideEffects._resetRequested) {
+      delete sideEffects._resetRequested;
+      const settingsPath = getUserSettingsPath();
+      if (deleteSettings(settingsPath)) {
+        addMessage((0, import_agent_core4.createSystemMessage)(`Deleted ${settingsPath}. Exiting...`));
+      } else {
+        addMessage((0, import_agent_core4.createSystemMessage)("No user settings found."));
       }
-      await executePrompt(input);
-    },
-    [isThinking, executePrompt]
-  );
+      setTimeout(() => exit(), EXIT_DELAY_MS);
+      return;
+    }
+    if (sideEffects._exitRequested) {
+      delete sideEffects._exitRequested;
+      setTimeout(() => exit(), EXIT_DELAY_MS);
+      return;
+    }
+    if (sideEffects._triggerPluginTUI) {
+      delete sideEffects._triggerPluginTUI;
+      setShowPluginTUI(true);
+      return;
+    }
+  };
   (0, import_ink13.useInput)(
     (_input, key) => {
       if (key.escape && isThinking) {
-        setIsAborting(true);
-        setPendingPrompt(null);
-        pendingPromptRef.current = null;
-        session.abort();
+        handleAbort();
       }
     },
     { isActive: !permissionRequest && !showPluginTUI }
   );
-  (0, import_react16.useEffect)(() => {
-    if (!isThinking) {
-      setIsAborting(false);
-      if (pendingPromptRef.current) {
-        const prompt = pendingPromptRef.current;
-        setPendingPrompt(null);
-        pendingPromptRef.current = null;
-        setTimeout(() => executePrompt(prompt), 0);
-      }
-    }
-  }, [isThinking, pendingPrompt, executePrompt]);
+  const session = interactiveSession.getSession();
   return /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_ink13.Box, { flexDirection: "column", children: [
     /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_ink13.Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
       /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_ink13.Text, { color: "cyan", bold: true, children: `
@@ -2886,7 +2076,7 @@ function App(props) {
     pendingModelId && /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
       ConfirmPrompt,
       {
-        message: `Change model to ${(0, import_agent_core6.getModelName)(pendingModelId)}? This will restart the session.`,
+        message: `Change model to ${(0, import_agent_core4.getModelName)(pendingModelId)}? This will restart the session.`,
         onSelect: (index) => {
           setPendingModelId(null);
           pendingModelChangeRef.current = null;
@@ -2895,20 +2085,20 @@ function App(props) {
               const settingsPath = getUserSettingsPath();
               updateModelInSettings(settingsPath, pendingModelId);
               addMessage(
-                (0, import_agent_core7.createSystemMessage)(
-                  `Model changed to ${(0, import_agent_core6.getModelName)(pendingModelId)}. Restarting...`
+                (0, import_agent_core4.createSystemMessage)(
+                  `Model changed to ${(0, import_agent_core4.getModelName)(pendingModelId)}. Restarting...`
                 )
               );
-              setTimeout(() => exit(), EXIT_DELAY_MS2);
+              setTimeout(() => exit(), EXIT_DELAY_MS);
             } catch (err) {
               addMessage(
-                (0, import_agent_core7.createSystemMessage)(
+                (0, import_agent_core4.createSystemMessage)(
                   `Failed: ${err instanceof Error ? err.message : String(err)}`
                 )
               );
             }
           } else {
-            addMessage((0, import_agent_core7.createSystemMessage)("Model change cancelled."));
+            addMessage((0, import_agent_core4.createSystemMessage)("Model change cancelled."));
           }
         }
       }
@@ -2918,14 +2108,14 @@ function App(props) {
       {
         callbacks: pluginCallbacks,
         onClose: () => setShowPluginTUI(false),
-        addMessage: (msg) => addMessage((0, import_agent_core7.createSystemMessage)(msg.content))
+        addMessage: (msg) => addMessage((0, import_agent_core4.createSystemMessage)(msg.content))
       }
     ),
     /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
       StatusBar,
       {
         permissionMode: session.getPermissionMode(),
-        modelName: (0, import_agent_core6.getModelName)(props.config.provider.model),
+        modelName: (0, import_agent_core4.getModelName)(props.config.provider.model),
         sessionId: session.getSessionId(),
         messageCount: messages.length,
         isThinking,
@@ -2938,10 +2128,7 @@ function App(props) {
       InputArea,
       {
         onSubmit: handleSubmit,
-        onCancelQueue: () => {
-          setPendingPrompt(null);
-          pendingPromptRef.current = null;
-        },
+        onCancelQueue: handleCancelQueue,
         isDisabled: !!permissionRequest || showPluginTUI || isThinking && !!pendingPrompt,
         isAborting,
         pendingPrompt,
@@ -2988,9 +2175,9 @@ function renderApp(options) {
 // src/cli.ts
 var import_meta = {};
 function checkSettingsFile(filePath) {
-  if (!(0, import_node_fs4.existsSync)(filePath)) return "missing";
+  if (!(0, import_node_fs2.existsSync)(filePath)) return "missing";
   try {
-    const raw = (0, import_node_fs4.readFileSync)(filePath, "utf8").trim();
+    const raw = (0, import_node_fs2.readFileSync)(filePath, "utf8").trim();
     if (raw.length === 0) return "incomplete";
     const parsed = JSON.parse(raw);
     const provider = parsed.provider;
@@ -3007,7 +2194,7 @@ function readVersion() {
     const candidates = [(0, import_node_path5.join)(dir, "..", "..", "package.json"), (0, import_node_path5.join)(dir, "..", "package.json")];
     for (const pkgPath of candidates) {
       try {
-        const raw = (0, import_node_fs4.readFileSync)(pkgPath, "utf-8");
+        const raw = (0, import_node_fs2.readFileSync)(pkgPath, "utf-8");
         const pkg = JSON.parse(raw);
         if (pkg.version !== void 0 && pkg.name !== void 0) {
           return pkg.version;
@@ -3095,7 +2282,7 @@ async function ensureConfig(cwd) {
   }
   const language = await promptInput("  Response language (ko/en/ja/zh, default: en): ");
   const settingsDir = (0, import_node_path5.dirname)(userPath);
-  (0, import_node_fs4.mkdirSync)(settingsDir, { recursive: true });
+  (0, import_node_fs2.mkdirSync)(settingsDir, { recursive: true });
   const settings = {
     provider: {
       name: "anthropic",
@@ -3106,7 +2293,7 @@ async function ensureConfig(cwd) {
   if (language) {
     settings.language = language;
   }
-  (0, import_node_fs4.writeFileSync)(userPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  (0, import_node_fs2.writeFileSync)(userPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
   process.stdout.write(`
   Config saved to ${userPath}
 
@@ -3135,9 +2322,9 @@ async function startCli() {
   const cwd = process.cwd();
   await ensureConfig(cwd);
   const [config, context, projectInfo] = await Promise.all([
-    (0, import_agent_sdk5.loadConfig)(cwd),
-    (0, import_agent_sdk5.loadContext)(cwd),
-    (0, import_agent_sdk5.detectProject)(cwd)
+    (0, import_agent_sdk3.loadConfig)(cwd),
+    (0, import_agent_sdk3.loadContext)(cwd),
+    (0, import_agent_sdk3.detectProject)(cwd)
   ]);
   if (args.model !== void 0) {
     config.provider.model = args.model;
@@ -3145,7 +2332,7 @@ async function startCli() {
   if (args.language !== void 0) {
     config.language = args.language;
   }
-  const sessionStore = new import_agent_sdk5.SessionStore();
+  const sessionStore = new import_agent_sdk3.SessionStore();
   if (args.printMode) {
     const prompt = args.positional.join(" ").trim();
     if (prompt.length === 0) {
@@ -3153,15 +2340,15 @@ async function startCli() {
       process.exit(1);
     }
     const terminal = new PrintTerminal();
-    const paths = (0, import_agent_sdk5.projectPaths)(cwd);
-    const session = (0, import_agent_sdk5.createSession)({
+    const paths = (0, import_agent_sdk3.projectPaths)(cwd);
+    const session = (0, import_agent_sdk3.createSession)({
       config,
       context,
       terminal,
-      sessionLogger: new import_agent_sdk5.FileSessionLogger(paths.logs),
+      sessionLogger: new import_agent_sdk3.FileSessionLogger(paths.logs),
       projectInfo,
       permissionMode: args.permissionMode,
-      promptForApproval: import_agent_sdk6.promptForApproval
+      promptForApproval: import_agent_sdk4.promptForApproval
     });
     const response = await session.run(prompt);
     process.stdout.write(response + "\n");