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

package/dist/node/chunk-CRPNSO52.js

@@ -0,0 +1,3163 @@
+// src/cli.ts
+import { readFileSync as readFileSync4, existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5, dirname as dirname3 } from "path";
+import { fileURLToPath } from "url";
+import {
+  loadConfig,
+  loadContext,
+  detectProject,
+  createSession as createSession2,
+  SessionStore,
+  FileSessionLogger as FileSessionLogger2,
+  projectPaths as projectPaths2
+} from "@robota-sdk/agent-sdk";
+import { promptForApproval } from "@robota-sdk/agent-sdk";
+
+// src/utils/cli-args.ts
+import { parseArgs } from "util";
+var VALID_MODES = ["plan", "default", "acceptEdits", "bypassPermissions"];
+function parsePermissionMode(raw) {
+  if (raw === void 0) return void 0;
+  if (!VALID_MODES.includes(raw)) {
+    process.stderr.write(`Invalid --permission-mode "${raw}". Valid: ${VALID_MODES.join(" | ")}
+`);
+    process.exit(1);
+  }
+  return raw;
+}
+function parseMaxTurns(raw) {
+  if (raw === void 0) return void 0;
+  const n = parseInt(raw, 10);
+  if (isNaN(n) || n <= 0) {
+    process.stderr.write(`Invalid --max-turns "${raw}". Must be a positive integer.
+`);
+    process.exit(1);
+  }
+  return n;
+}
+function parseCliArgs() {
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+      p: { type: "boolean", short: "p", default: false },
+      c: { type: "boolean", short: "c", default: false },
+      r: { type: "string", short: "r" },
+      model: { type: "string" },
+      language: { type: "string" },
+      "permission-mode": { type: "string" },
+      "max-turns": { type: "string" },
+      version: { type: "boolean", default: false },
+      reset: { type: "boolean", default: false }
+    }
+  });
+  return {
+    positional: positionals,
+    printMode: values["p"] ?? false,
+    continueMode: values["c"] ?? false,
+    resumeId: values["r"],
+    model: values["model"],
+    language: values["language"],
+    permissionMode: parsePermissionMode(values["permission-mode"]),
+    maxTurns: parseMaxTurns(values["max-turns"]),
+    version: values["version"] ?? false,
+    reset: values["reset"] ?? false
+  };
+}
+
+// src/utils/settings-io.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from "fs";
+import { join, dirname } from "path";
+function getUserSettingsPath() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "/";
+  return join(home, ".robota", "settings.json");
+}
+function readSettings(path) {
+  if (!existsSync(path)) return {};
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+function writeSettings(path, settings) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(settings, null, 2) + "\n", "utf8");
+}
+function updateModelInSettings(settingsPath, modelId) {
+  const settings = readSettings(settingsPath);
+  const provider = settings.provider ?? {};
+  provider.model = modelId;
+  settings.provider = provider;
+  writeSettings(settingsPath, settings);
+}
+function deleteSettings(path) {
+  if (existsSync(path)) {
+    unlinkSync(path);
+    return true;
+  }
+  return false;
+}
+
+// src/print-terminal.ts
+import * as readline from "readline";
+var PrintTerminal = class {
+  write(text) {
+    process.stdout.write(text);
+  }
+  writeLine(text) {
+    process.stdout.write(text + "\n");
+  }
+  writeMarkdown(md) {
+    process.stdout.write(md);
+  }
+  writeError(text) {
+    process.stderr.write(text + "\n");
+  }
+  prompt(question) {
+    return new Promise((resolve) => {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: false,
+        historySize: 0
+      });
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    });
+  }
+  async select(options, initialIndex = 0) {
+    for (let i = 0; i < options.length; i++) {
+      const marker = i === initialIndex ? ">" : " ";
+      process.stdout.write(`  ${marker} ${i + 1}) ${options[i]}
+`);
+    }
+    const answer = await this.prompt(
+      `  Choose [1-${options.length}] (default: ${options[initialIndex]}): `
+    );
+    const trimmed = answer.trim().toLowerCase();
+    if (trimmed === "") return initialIndex;
+    const num = parseInt(trimmed, 10);
+    if (!isNaN(num) && num >= 1 && num <= options.length) return num - 1;
+    return initialIndex;
+  }
+  spinner(_message) {
+    return { stop() {
+    }, update() {
+    } };
+  }
+};
+
+// src/ui/render.tsx
+import { render } from "ink";
+
+// src/ui/App.tsx
+import { useState as useState10, useRef as useRef8, useEffect as useEffect3, useCallback as useCallback10 } from "react";
+import { Box as Box11, Text as Text13, useApp, useInput as useInput7 } from "ink";
+import { getModelName } from "@robota-sdk/agent-core";
+import { createSystemMessage as createSystemMessage3 } from "@robota-sdk/agent-core";
+
+// src/ui/hooks/useSession.ts
+import { useState, useCallback, useRef } from "react";
+import { createSession, FileSessionLogger, projectPaths } from "@robota-sdk/agent-sdk";
+
+// src/utils/edit-diff.ts
+import { readFileSync as readFileSync2 } from "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 = readFileSync2(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 = readFileSync2(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] = useState(null);
+  const [streamingText, setStreamingText] = useState("");
+  const streamingTextRef = useRef("");
+  const [activeTools, setActiveTools] = useState([]);
+  const permissionQueueRef = useRef([]);
+  const processingRef = useRef(false);
+  const processNextPermission = 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 = 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 = projectPaths(props.cwd ?? process.cwd());
+    sessionRef.current = createSession({
+      config: props.config,
+      context: props.context,
+      terminal: NOOP_TERMINAL,
+      sessionLogger: new FileSessionLogger(paths.logs),
+      projectInfo: props.projectInfo,
+      sessionStore: props.sessionStore,
+      permissionMode: props.permissionMode,
+      maxTurns: props.maxTurns,
+      permissionHandler,
+      onTextDelta,
+      onToolExecution
+    });
+  }
+  const clearStreamingText = useCallback(() => {
+    setStreamingText("");
+    streamingTextRef.current = "";
+    setActiveTools([]);
+  }, []);
+  return {
+    session: sessionRef.current,
+    permissionRequest,
+    streamingText,
+    clearStreamingText,
+    activeTools
+  };
+}
+
+// src/ui/hooks/useMessages.ts
+import { useState as useState2, useCallback as useCallback2 } from "react";
+var MAX_RENDERED_MESSAGES = 100;
+function useMessages() {
+  const [messages, setMessages] = useState2([]);
+  const addMessage = useCallback2((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
+import { useCallback as useCallback3 } from "react";
+import { createSystemMessage } from "@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/ui/hooks/useSlashCommands.ts
+var EXIT_DELAY_MS = 500;
+function useSlashCommands(session, addMessage, setMessages, exit, registry, pendingModelChangeRef, setPendingModelId, pluginCallbacks, setShowPluginTUI) {
+  return useCallback3(
+    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(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);
+      }
+      return result.handled;
+    },
+    [
+      session,
+      addMessage,
+      setMessages,
+      exit,
+      registry,
+      pendingModelChangeRef,
+      setPendingModelId,
+      pluginCallbacks,
+      setShowPluginTUI
+    ]
+  );
+}
+
+// src/ui/hooks/useSubmitHandler.ts
+import { useCallback as useCallback4 } from "react";
+import { randomUUID } from "crypto";
+import {
+  createSubagentSession,
+  getBuiltInAgent,
+  retrieveAgentToolDeps
+} from "@robota-sdk/agent-sdk";
+import {
+  createUserMessage,
+  createAssistantMessage,
+  createSystemMessage as createSystemMessage2,
+  createToolMessage
+} from "@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);
+      }
+    }
+  }
+  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
+import { execSync } 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 = 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(
+        createToolMessage(JSON.stringify(toolSummaries), {
+          toolCallId: randomUUID(),
+          name: `${toolSummaries.length} tools`
+        })
+      );
+    }
+    addMessage(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(
+          createToolMessage(JSON.stringify(toolSummaries), {
+            toolCallId: 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(
+          createAssistantMessage(assistantParts.join("\n\n"), { state: lastAssistantState })
+        );
+      }
+      addMessage(createSystemMessage2("Interrupted by user."));
+    } else {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      addMessage(createSystemMessage2(`Error: ${errMsg}`));
+    }
+  } finally {
+    setIsThinking(false);
+  }
+}
+function createForkRunner(sessionKey) {
+  const deps = retrieveAgentToolDeps(sessionKey);
+  if (!deps) return void 0;
+  return async (content, options) => {
+    const agentType = options.agent ?? "general-purpose";
+    const agentDef = 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 = 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 useCallback4(
+    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(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(createUserMessage(input));
+      return runSessionPrompt(
+        input,
+        session,
+        addMessage,
+        clearStreamingText,
+        setIsThinking,
+        setContextState
+      );
+    },
+    [
+      session,
+      addMessage,
+      handleSlashCommand,
+      clearStreamingText,
+      setIsThinking,
+      setContextState,
+      registry
+    ]
+  );
+}
+
+// src/ui/hooks/useCommandRegistry.ts
+import { useRef as useRef2 } from "react";
+import { homedir as homedir2 } from "os";
+import { join as join3, dirname as dirname2 } from "path";
+import { BundlePluginLoader } from "@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
+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, readFileSync as readFileSync3, existsSync as existsSync2 } from "fs";
+import { join as join2, basename } from "path";
+import { homedir } from "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 (!existsSync2(skillsDir)) return [];
+  const commands = [];
+  const entries = readdirSync(skillsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillFile = join2(skillsDir, entry.name, "SKILL.md");
+    if (!existsSync2(skillFile)) continue;
+    const content = readFileSync3(skillFile, "utf-8");
+    const frontmatter = parseFrontmatter(content);
+    commands.push(buildCommand(frontmatter, content, entry.name));
+  }
+  return commands;
+}
+function scanCommandsDir(commandsDir) {
+  if (!existsSync2(commandsDir)) return [];
+  const commands = [];
+  const entries = readdirSync(commandsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+    const filePath = join2(commandsDir, entry.name);
+    const content = readFileSync3(filePath, "utf-8");
+    const frontmatter = parseFrontmatter(content);
+    const fallbackName = 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 ?? homedir();
+  }
+  getCommands() {
+    if (this.cachedCommands) return this.cachedCommands;
+    const sources = [
+      scanSkillsDir(join2(this.cwd, ".claude", "skills")),
+      // 1. project .claude/skills
+      scanCommandsDir(join2(this.cwd, ".claude", "commands")),
+      // 2. project .claude/commands (legacy)
+      scanSkillsDir(join2(this.home, ".robota", "skills")),
+      // 3. user ~/.robota/skills
+      scanSkillsDir(join2(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);
+        }
+      }
+    }
+    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);
+  }
+};
+
+// 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/ui/hooks/useCommandRegistry.ts
+function buildPluginEnv(plugin) {
+  const dataDir = join3(dirname2(dirname2(plugin.pluginDir)), "data", plugin.manifest.name);
+  return {
+    CLAUDE_PLUGIN_ROOT: plugin.pluginDir,
+    CLAUDE_PLUGIN_PATH: plugin.pluginDir,
+    CLAUDE_PLUGIN_DATA: dataDir
+  };
+}
+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 resolved2 = resolvePluginRoot(group, plugin.pluginDir);
+        if (typeof resolved2 === "object" && resolved2 !== null) {
+          resolved2.env = pluginEnv;
+        }
+        return resolved2;
+      });
+      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;
+      })
+    };
+  }
+  return group;
+}
+function useCommandRegistry(cwd) {
+  const resultRef = useRef2(null);
+  if (resultRef.current === null) {
+    const registry = new CommandRegistry();
+    registry.addSource(new BuiltinCommandSource());
+    registry.addSource(new SkillCommandSource(cwd));
+    let pluginHooks = {};
+    const pluginsDir = join3(homedir2(), ".robota", "plugins");
+    const loader = new BundlePluginLoader(pluginsDir);
+    try {
+      const plugins = loader.loadPluginsSync();
+      if (plugins.length > 0) {
+        registry.addSource(new PluginCommandSource(plugins));
+        pluginHooks = mergePluginHooks(plugins);
+      }
+    } catch {
+    }
+    resultRef.current = { registry, pluginHooks };
+  }
+  return resultRef.current;
+}
+
+// src/ui/hooks/usePluginCallbacks.ts
+import { useMemo } from "react";
+import { homedir as homedir3 } from "os";
+import { join as join4 } from "path";
+import {
+  PluginSettingsStore,
+  BundlePluginLoader as BundlePluginLoader2,
+  BundlePluginInstaller,
+  MarketplaceClient
+} from "@robota-sdk/agent-sdk";
+function usePluginCallbacks(cwd) {
+  return useMemo(() => {
+    const home = homedir3();
+    const pluginsDir = join4(home, ".robota", "plugins");
+    const userSettingsPath = join4(home, ".robota", "settings.json");
+    const settingsStore = new PluginSettingsStore(userSettingsPath);
+    const marketplace = new MarketplaceClient({ pluginsDir });
+    const installer = new BundlePluginInstaller({
+      pluginsDir,
+      settingsStore,
+      marketplaceClient: marketplace
+    });
+    const loader = new BundlePluginLoader2(pluginsDir);
+    return {
+      listInstalled: async () => {
+        const plugins = await loader.loadAll();
+        const enabledMap = settingsStore.getEnabledPlugins();
+        return plugins.map((p) => {
+          const parts = p.pluginDir.split("/");
+          const cacheIdx = parts.indexOf("cache");
+          const marketplaceName = cacheIdx >= 0 ? parts[cacheIdx + 1] : "";
+          const fullId = marketplaceName ? `${p.manifest.name}@${marketplaceName}` : p.manifest.name;
+          return {
+            name: fullId,
+            description: p.manifest.description,
+            enabled: enabledMap[fullId] !== false && enabledMap[p.manifest.name] !== false
+          };
+        });
+      },
+      listAvailablePlugins: async (marketplaceName) => {
+        let manifest;
+        try {
+          manifest = marketplace.fetchManifest(marketplaceName);
+        } catch {
+          return [];
+        }
+        const installed = installer.getInstalledPlugins();
+        const installedNames = new Set(Object.values(installed).map((r) => r.pluginName));
+        return manifest.plugins.map((p) => ({
+          name: p.name,
+          description: p.description,
+          installed: installedNames.has(p.name)
+        }));
+      },
+      install: async (pluginId, scope) => {
+        const [name, marketplaceName] = pluginId.split("@");
+        if (!name || !marketplaceName) {
+          throw new Error("Plugin ID must be in format: name@marketplace");
+        }
+        if (scope === "project") {
+          const projectPluginsDir = join4(cwd, ".robota", "plugins");
+          const projectInstaller = new BundlePluginInstaller({
+            pluginsDir: projectPluginsDir,
+            settingsStore,
+            marketplaceClient: marketplace
+          });
+          await projectInstaller.install(name, marketplaceName);
+        } else {
+          await installer.install(name, marketplaceName);
+        }
+      },
+      uninstall: async (pluginId) => {
+        await installer.uninstall(pluginId);
+      },
+      enable: async (pluginId) => {
+        await installer.enable(pluginId);
+      },
+      disable: async (pluginId) => {
+        await installer.disable(pluginId);
+      },
+      marketplaceAdd: async (source) => {
+        if (source.includes("/") && !source.includes(":")) {
+          return marketplace.addMarketplace({ type: "github", repo: source });
+        } else {
+          return marketplace.addMarketplace({ type: "git", url: source });
+        }
+      },
+      marketplaceRemove: async (name) => {
+        const installedFromMarketplace = installer.getPluginsByMarketplace(name);
+        for (const record of installedFromMarketplace) {
+          await installer.uninstall(`${record.pluginName}@${record.marketplace}`);
+        }
+        marketplace.removeMarketplace(name);
+      },
+      marketplaceUpdate: async (name) => {
+        marketplace.updateMarketplace(name);
+      },
+      marketplaceList: async () => {
+        return marketplace.listMarketplaces().map((m) => ({
+          name: m.name,
+          type: m.source.type
+        }));
+      },
+      reloadPlugins: async () => {
+      }
+    };
+  }, [cwd]);
+}
+
+// src/ui/MessageList.tsx
+import React2 from "react";
+import { Box as Box2, Text as Text2 } from "ink";
+import { isToolMessage, isAssistantMessage } from "@robota-sdk/agent-core";
+
+// src/ui/render-markdown.ts
+import { marked } from "marked";
+import TerminalRenderer from "marked-terminal";
+marked.setOptions({
+  renderer: new TerminalRenderer()
+});
+function renderMarkdown(md) {
+  const result = marked.parse(md);
+  return typeof result === "string" ? result.trimEnd() : md;
+}
+
+// src/ui/DiffBlock.tsx
+import { Box, Text } from "ink";
+import { jsxs } from "react/jsx-runtime";
+var MAX_DIFF_LINES = 12;
+var TRUNCATED_SHOW = 10;
+function DiffBlock({ file, lines }) {
+  const truncated = lines.length > MAX_DIFF_LINES;
+  const visible = truncated ? lines.slice(0, TRUNCATED_SHOW) : lines;
+  const remaining = lines.length - TRUNCATED_SHOW;
+  const maxLineNum = Math.max(...visible.map((l) => l.lineNumber), 0);
+  const numWidth = String(maxLineNum).length;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", marginLeft: 4, children: [
+    file && /* @__PURE__ */ jsxs(Text, { color: "white", dimColor: true, children: [
+      "\u2502 ",
+      file
+    ] }),
+    visible.map((line, i) => {
+      const lineNum = String(line.lineNumber).padStart(numWidth, " ");
+      if (line.type === "context") {
+        return /* @__PURE__ */ jsxs(Text, { color: "white", dimColor: true, children: [
+          "\u2502 ",
+          lineNum,
+          " ",
+          line.text
+        ] }, i);
+      }
+      const prefix = line.type === "remove" ? "-" : "+";
+      const bgColor = line.type === "remove" ? "#5c1a1a" : "#1a3d1a";
+      const fgColor = line.type === "remove" ? "#ff9999" : "#99ff99";
+      return /* @__PURE__ */ jsxs(Text, { color: fgColor, backgroundColor: bgColor, children: [
+        "\u2502 ",
+        lineNum,
+        " ",
+        prefix,
+        " ",
+        line.text
+      ] }, i);
+    }),
+    truncated && /* @__PURE__ */ jsxs(Text, { color: "white", dimColor: true, children: [
+      "\u2502 ... and ",
+      remaining,
+      " more lines"
+    ] })
+  ] });
+}
+
+// src/ui/MessageList.tsx
+import { Fragment, jsx, jsxs as jsxs2 } from "react/jsx-runtime";
+function RoleLabel({ role }) {
+  switch (role) {
+    case "user":
+      return /* @__PURE__ */ jsxs2(Text2, { color: "green", bold: true, children: [
+        "You:",
+        " "
+      ] });
+    case "assistant":
+      return /* @__PURE__ */ jsxs2(Text2, { color: "cyan", bold: true, children: [
+        "Robota:",
+        " "
+      ] });
+    case "system":
+      return /* @__PURE__ */ jsxs2(Text2, { color: "yellow", bold: true, children: [
+        "System:",
+        " "
+      ] });
+    case "tool":
+      return /* @__PURE__ */ jsxs2(Text2, { color: "white", bold: true, children: [
+        "Tool:",
+        " "
+      ] });
+  }
+}
+function ToolMessage({ message }) {
+  if (!isToolMessage(message)) {
+    return /* @__PURE__ */ jsx(Fragment, {});
+  }
+  const toolName = message.name;
+  const content = message.content;
+  let summaries = null;
+  try {
+    const parsed = JSON.parse(content);
+    if (Array.isArray(parsed) && parsed.length > 0 && typeof parsed[0].line === "string") {
+      summaries = parsed;
+    }
+  } catch {
+  }
+  if (summaries) {
+    return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsxs2(Box2, { children: [
+        /* @__PURE__ */ jsxs2(Text2, { color: "white", bold: true, children: [
+          "Tool:",
+          " "
+        ] }),
+        toolName && /* @__PURE__ */ jsxs2(Text2, { color: "white", dimColor: true, children: [
+          "[",
+          toolName,
+          "]"
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx(Text2, { children: " " }),
+      summaries.map((s, i) => /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs2(Text2, { color: "green", children: [
+          "  ",
+          "\u2713",
+          " ",
+          s.line
+        ] }),
+        s.diffLines && s.diffLines.length > 0 && /* @__PURE__ */ jsx(DiffBlock, { file: s.diffFile, lines: s.diffLines })
+      ] }, i))
+    ] });
+  }
+  const lines = content.split("\n").filter((l) => l.trim());
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsxs2(Box2, { children: [
+      /* @__PURE__ */ jsxs2(Text2, { color: "white", bold: true, children: [
+        "Tool:",
+        " "
+      ] }),
+      toolName && /* @__PURE__ */ jsxs2(Text2, { color: "white", dimColor: true, children: [
+        "[",
+        toolName,
+        "]"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(Text2, { children: " " }),
+    lines.map((line, i) => /* @__PURE__ */ jsxs2(Text2, { color: "green", children: [
+      "  ",
+      "\u2713",
+      " ",
+      line
+    ] }, i))
+  ] });
+}
+var MessageItem = React2.memo(function MessageItem2({
+  message
+}) {
+  if (isToolMessage(message)) {
+    return /* @__PURE__ */ jsx(ToolMessage, { message });
+  }
+  const content = message.content ?? "";
+  const isInterrupted = message.state === "interrupted";
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Box2, { children: /* @__PURE__ */ jsx(RoleLabel, { role: message.role }) }),
+    /* @__PURE__ */ jsx(Text2, { children: " " }),
+    /* @__PURE__ */ jsx(Box2, { marginLeft: 2, children: /* @__PURE__ */ jsx(Text2, { wrap: "wrap", children: isAssistantMessage(message) ? renderMarkdown(content + (isInterrupted ? "\n\n_(interrupted)_" : "")) : content }) })
+  ] });
+});
+function MessageList({ messages }) {
+  return /* @__PURE__ */ jsx(Box2, { flexDirection: "column", children: messages.map((msg) => /* @__PURE__ */ jsx(MessageItem, { message: msg }, msg.id)) });
+}
+
+// src/ui/StatusBar.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { formatTokenCount as formatTokenCount2 } from "@robota-sdk/agent-core";
+import { jsx as jsx2, jsxs as jsxs3 } from "react/jsx-runtime";
+var CONTEXT_YELLOW_THRESHOLD = 70;
+var CONTEXT_RED_THRESHOLD = 90;
+function getContextColor(percentage) {
+  if (percentage >= CONTEXT_RED_THRESHOLD) return "red";
+  if (percentage >= CONTEXT_YELLOW_THRESHOLD) return "yellow";
+  return "green";
+}
+function StatusBar({
+  permissionMode,
+  modelName,
+  sessionId: _sessionId,
+  messageCount,
+  isThinking,
+  contextPercentage,
+  contextUsedTokens,
+  contextMaxTokens
+}) {
+  const contextColor = getContextColor(contextPercentage);
+  return /* @__PURE__ */ jsxs3(
+    Box3,
+    {
+      borderStyle: "single",
+      borderColor: "gray",
+      paddingLeft: 1,
+      paddingRight: 1,
+      justifyContent: "space-between",
+      children: [
+        /* @__PURE__ */ jsxs3(Text3, { children: [
+          /* @__PURE__ */ jsx2(Text3, { color: "cyan", bold: true, children: "Mode:" }),
+          " ",
+          /* @__PURE__ */ jsx2(Text3, { children: permissionMode }),
+          "  |  ",
+          /* @__PURE__ */ jsx2(Text3, { dimColor: true, children: modelName }),
+          "  |  ",
+          /* @__PURE__ */ jsxs3(Text3, { color: contextColor, children: [
+            "Context: ",
+            Math.round(contextPercentage),
+            "% (",
+            formatTokenCount2(contextUsedTokens),
+            "/",
+            formatTokenCount2(contextMaxTokens),
+            ")"
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs3(Text3, { children: [
+          isThinking && /* @__PURE__ */ jsx2(Text3, { color: "yellow", children: "Thinking... " }),
+          /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+            "msgs: ",
+            messageCount
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/ui/InputArea.tsx
+import React5, { useState as useState5, useCallback as useCallback5, useMemo as useMemo2, useRef as useRef4 } from "react";
+import { Box as Box5, Text as Text7, useInput as useInput2, useStdout } from "ink";
+
+// src/ui/CjkTextInput.tsx
+import { useRef as useRef3, useState as useState3 } from "react";
+import { Text as Text4, useInput } from "ink";
+import chalk from "chalk";
+import stringWidth from "string-width";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var PASTE_START = "[200~";
+var PASTE_END = "[201~";
+function filterPrintable(input) {
+  if (!input || input.length === 0) return "";
+  return input.replace(/[\x00-\x1f\x7f]/g, "");
+}
+function insertAtCursor(value, cursor, input) {
+  const next = value.slice(0, cursor) + input + value.slice(cursor);
+  return { value: next, cursor: cursor + input.length };
+}
+function displayOffset(chars, charIndex, width) {
+  let offset = 0;
+  for (let i = 0; i < charIndex && i < chars.length; i++) {
+    const w = stringWidth(chars[i]);
+    const col = offset % width;
+    if (col + w > width) offset += width - col;
+    offset += w;
+  }
+  return offset;
+}
+function charIndexAtDisplayOffset(chars, target, width) {
+  let offset = 0;
+  for (let i = 0; i < chars.length; i++) {
+    if (offset >= target) return i;
+    const w = stringWidth(chars[i]);
+    const col = offset % width;
+    if (col + w > width) offset += width - col;
+    offset += w;
+  }
+  return chars.length;
+}
+function CjkTextInput({
+  value,
+  onChange,
+  onSubmit,
+  onPaste,
+  placeholder = "",
+  focus = true,
+  showCursor = true,
+  availableWidth
+}) {
+  const valueRef = useRef3(value);
+  const cursorRef = useRef3(value.length);
+  const [, forceRender] = useState3(0);
+  const isPastingRef = useRef3(false);
+  const pasteBufferRef = useRef3("");
+  if (value !== valueRef.current) {
+    valueRef.current = value;
+    if (cursorRef.current > value.length) {
+      cursorRef.current = value.length;
+    }
+  }
+  useInput(
+    (input, key) => {
+      try {
+        if (input === PASTE_START || input.startsWith(PASTE_START)) {
+          isPastingRef.current = true;
+          const afterMarker = input.slice(PASTE_START.length);
+          if (afterMarker.length > 0) {
+            pasteBufferRef.current += afterMarker;
+          }
+          return;
+        }
+        if (isPastingRef.current) {
+          if (input === PASTE_END || input.includes(PASTE_END)) {
+            const beforeMarker = input.split(PASTE_END)[0] ?? "";
+            pasteBufferRef.current += beforeMarker;
+            const text = pasteBufferRef.current.replace(/\r\n?/g, "\n");
+            pasteBufferRef.current = "";
+            isPastingRef.current = false;
+            if (text.length > 0) {
+              if (text.includes("\n") && onPaste) {
+                onPaste(text);
+              } else {
+                const printable2 = filterPrintable(text);
+                if (printable2.length > 0) {
+                  const result2 = insertAtCursor(valueRef.current, cursorRef.current, printable2);
+                  cursorRef.current = result2.cursor;
+                  valueRef.current = result2.value;
+                  onChange(result2.value);
+                }
+              }
+            }
+          } else {
+            pasteBufferRef.current += input;
+          }
+          return;
+        }
+        if (key.ctrl && input === "c" || key.tab || key.shift && key.tab) {
+          return;
+        }
+        if (key.upArrow || key.downArrow) {
+          if (availableWidth && availableWidth > 0) {
+            const chars = [...valueRef.current];
+            const offset = displayOffset(chars, cursorRef.current, availableWidth);
+            const target = key.upArrow ? offset - availableWidth : offset + availableWidth;
+            if (target >= 0) {
+              const newCursor = charIndexAtDisplayOffset(chars, target, availableWidth);
+              if (newCursor !== cursorRef.current) {
+                cursorRef.current = newCursor;
+                forceRender((n) => n + 1);
+              }
+            }
+          }
+          return;
+        }
+        if (key.return) {
+          onSubmit?.(valueRef.current);
+          return;
+        }
+        if (input.length > 1 && (input.includes("\n") || input.includes("\r")) && onPaste) {
+          onPaste(input.replace(/\r\n?/g, "\n"));
+          return;
+        }
+        if (key.leftArrow) {
+          if (cursorRef.current > 0) {
+            cursorRef.current -= 1;
+            forceRender((n) => n + 1);
+          }
+          return;
+        }
+        if (key.rightArrow) {
+          if (cursorRef.current < valueRef.current.length) {
+            cursorRef.current += 1;
+            forceRender((n) => n + 1);
+          }
+          return;
+        }
+        if (key.backspace || key.delete) {
+          if (cursorRef.current > 0) {
+            const v = valueRef.current;
+            const next = v.slice(0, cursorRef.current - 1) + v.slice(cursorRef.current);
+            cursorRef.current -= 1;
+            valueRef.current = next;
+            onChange(next);
+          }
+          return;
+        }
+        const printable = filterPrintable(input);
+        if (printable.length === 0) return;
+        const result = insertAtCursor(valueRef.current, cursorRef.current, printable);
+        cursorRef.current = result.cursor;
+        valueRef.current = result.value;
+        onChange(result.value);
+      } catch {
+      }
+    },
+    { isActive: focus }
+  );
+  return /* @__PURE__ */ jsx3(Text4, { children: renderWithCursor(valueRef.current, cursorRef.current, placeholder, showCursor && focus) });
+}
+function renderWithCursor(value, cursorOffset, placeholder, showCursor) {
+  if (!showCursor) {
+    return value.length > 0 ? value : placeholder ? chalk.gray(placeholder) : "";
+  }
+  if (value.length === 0) {
+    if (placeholder.length > 0) {
+      return chalk.inverse(placeholder[0]) + chalk.gray(placeholder.slice(1));
+    }
+    return chalk.inverse(" ");
+  }
+  const chars = [...value];
+  let rendered = "";
+  for (let i = 0; i < chars.length; i++) {
+    const char = chars[i] ?? "";
+    rendered += i === cursorOffset ? chalk.inverse(char) : char;
+  }
+  if (cursorOffset >= chars.length) {
+    rendered += chalk.inverse(" ");
+  }
+  return rendered;
+}
+
+// src/ui/WaveText.tsx
+import { useState as useState4, useEffect } from "react";
+import { Text as Text5 } from "ink";
+import { jsx as jsx4 } from "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] = useState4(0);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setTick((prev) => prev + 1);
+    }, INTERVAL_MS);
+    return () => clearInterval(timer);
+  }, []);
+  const chars = [...text];
+  return /* @__PURE__ */ jsx4(Text5, { children: chars.map((char, i) => {
+    const group = Math.floor(i / CHARS_PER_GROUP);
+    const colorIndex = (tick + group) % WAVE_COLORS.length;
+    return /* @__PURE__ */ jsx4(Text5, { color: WAVE_COLORS[colorIndex], children: char }, i);
+  }) });
+}
+
+// src/ui/SlashAutocomplete.tsx
+import { Box as Box4, Text as Text6 } from "ink";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var MAX_VISIBLE = 8;
+function CommandRow(props) {
+  const { cmd, isSelected, showSlash } = props;
+  const indicator = isSelected ? "\u25B8 " : "  ";
+  const nameColor = isSelected ? "cyan" : void 0;
+  const dimmed = !isSelected;
+  return /* @__PURE__ */ jsx5(Box4, { children: /* @__PURE__ */ jsxs4(Text6, { color: nameColor, dimColor: dimmed, children: [
+    indicator,
+    showSlash ? `/${cmd.name}  ${cmd.description}` : cmd.description
+  ] }) });
+}
+function SlashAutocomplete({
+  commands,
+  selectedIndex,
+  visible,
+  isSubcommandMode
+}) {
+  if (!visible || commands.length === 0) return null;
+  const scrollOffset = computeScrollOffset(selectedIndex, commands.length);
+  const visibleCommands = commands.slice(scrollOffset, scrollOffset + MAX_VISIBLE);
+  return /* @__PURE__ */ jsx5(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: visibleCommands.map((cmd, i) => /* @__PURE__ */ jsx5(
+    CommandRow,
+    {
+      cmd,
+      isSelected: scrollOffset + i === selectedIndex,
+      showSlash: !isSubcommandMode
+    },
+    cmd.name
+  )) });
+}
+function computeScrollOffset(selectedIndex, total) {
+  if (total <= MAX_VISIBLE) return 0;
+  if (selectedIndex < MAX_VISIBLE) return 0;
+  const maxOffset = total - MAX_VISIBLE;
+  return Math.min(selectedIndex - MAX_VISIBLE + 1, maxOffset);
+}
+
+// src/utils/paste-labels.ts
+var PASTE_LABEL_RE = /\[Pasted text #(\d+)(?: \+\d+ lines)?\]/g;
+function expandPasteLabels(text, store) {
+  return text.replace(PASTE_LABEL_RE, (_, id) => store.get(Number(id)) ?? "");
+}
+
+// src/ui/InputArea.tsx
+import { jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function parseSlashInput(value) {
+  if (!value.startsWith("/")) return { isSlash: false, parentCommand: "", filter: "" };
+  const afterSlash = value.slice(1);
+  const spaceIndex = afterSlash.indexOf(" ");
+  if (spaceIndex === -1) return { isSlash: true, parentCommand: "", filter: afterSlash };
+  const parent = afterSlash.slice(0, spaceIndex);
+  const rest = afterSlash.slice(spaceIndex + 1);
+  return { isSlash: true, parentCommand: parent, filter: rest };
+}
+function useAutocomplete(value, registry) {
+  const [selectedIndex, setSelectedIndex] = useState5(0);
+  const [dismissed, setDismissed] = useState5(false);
+  const prevValueRef = React5.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 = useMemo2(() => {
+    if (!registry || !parsed.isSlash || dismissed) return [];
+    if (isSubcommandMode) {
+      const subs = registry.getSubcommands(parsed.parentCommand);
+      if (subs.length === 0) return [];
+      if (!parsed.filter) return subs;
+      const lower = parsed.filter.toLowerCase();
+      return subs.filter((c) => c.name.toLowerCase().startsWith(lower));
+    }
+    return registry.getCommands(parsed.filter);
+  }, [registry, parsed.isSlash, parsed.parentCommand, parsed.filter, dismissed, isSubcommandMode]);
+  const showPopup = parsed.isSlash && filteredCommands.length > 0 && !dismissed;
+  if (selectedIndex >= filteredCommands.length && filteredCommands.length > 0) {
+    setSelectedIndex(filteredCommands.length - 1);
+  }
+  return {
+    showPopup,
+    filteredCommands,
+    selectedIndex,
+    setSelectedIndex,
+    isSubcommandMode,
+    setShowPopup: (val) => {
+      if (typeof val === "function") {
+        setDismissed((prev) => {
+          const nextVal = val(!prev);
+          return !nextVal;
+        });
+      } else {
+        setDismissed(!val);
+      }
+    }
+  };
+}
+var BORDER_HORIZONTAL = 2;
+var PADDING_LEFT = 1;
+var PROMPT_WIDTH = 2;
+var INPUT_AREA_OVERHEAD = BORDER_HORIZONTAL + PADDING_LEFT + PROMPT_WIDTH;
+function InputArea({
+  onSubmit,
+  onCancelQueue,
+  isDisabled,
+  isAborting,
+  pendingPrompt,
+  registry
+}) {
+  const [value, setValue] = useState5("");
+  const pasteStore = useRef4(/* @__PURE__ */ new Map());
+  const { stdout } = useStdout();
+  const terminalColumns = stdout?.columns ?? 80;
+  const availableWidth = Math.max(1, terminalColumns - INPUT_AREA_OVERHEAD);
+  const pasteIdRef = useRef4(0);
+  const {
+    showPopup,
+    filteredCommands,
+    selectedIndex,
+    setSelectedIndex,
+    isSubcommandMode,
+    setShowPopup
+  } = useAutocomplete(value, registry);
+  const handlePaste = useCallback5((text) => {
+    pasteIdRef.current += 1;
+    const id = pasteIdRef.current;
+    pasteStore.current.set(id, text);
+    const lineCount = text.split("\n").length;
+    const label = `[Pasted text #${id} +${lineCount} lines]`;
+    setValue((prev) => prev ? `${prev} ${label}` : label);
+  }, []);
+  const handleSubmit = useCallback5(
+    (text) => {
+      const trimmed = text.trim();
+      if (trimmed.length === 0) return;
+      if (showPopup && filteredCommands[selectedIndex]) {
+        selectCommand(filteredCommands[selectedIndex]);
+        return;
+      }
+      const expanded = expandPasteLabels(trimmed, pasteStore.current);
+      setValue("");
+      pasteStore.current.clear();
+      pasteIdRef.current = 0;
+      onSubmit(expanded);
+    },
+    [showPopup, filteredCommands, selectedIndex, onSubmit]
+  );
+  const selectCommand = useCallback5(
+    (cmd) => {
+      const parsed = parseSlashInput(value);
+      if (parsed.parentCommand) {
+        const fullCommand = `/${parsed.parentCommand} ${cmd.name}`;
+        setValue("");
+        onSubmit(fullCommand);
+        return;
+      }
+      if (cmd.subcommands && cmd.subcommands.length > 0) {
+        setValue(`/${cmd.name} `);
+        setSelectedIndex(0);
+        return;
+      }
+      setValue("");
+      onSubmit(`/${cmd.name}`);
+    },
+    [value, onSubmit, setSelectedIndex]
+  );
+  useInput2(
+    (_input, key) => {
+      if (!showPopup) return;
+      if (key.upArrow) {
+        setSelectedIndex((prev) => prev > 0 ? prev - 1 : filteredCommands.length - 1);
+      } else if (key.downArrow) {
+        setSelectedIndex((prev) => prev < filteredCommands.length - 1 ? prev + 1 : 0);
+      } else if (key.escape) {
+        setShowPopup(false);
+      } else if (key.tab) {
+        const cmd = filteredCommands[selectedIndex];
+        if (cmd) selectCommand(cmd);
+      }
+    },
+    { isActive: showPopup && !isDisabled }
+  );
+  useInput2(
+    (_input, key) => {
+      if ((key.backspace || key.delete) && pendingPrompt) {
+        onCancelQueue?.();
+      }
+    },
+    { isActive: !!pendingPrompt }
+  );
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+    showPopup && /* @__PURE__ */ jsx6(
+      SlashAutocomplete,
+      {
+        commands: filteredCommands,
+        selectedIndex,
+        visible: showPopup,
+        isSubcommandMode
+      }
+    ),
+    /* @__PURE__ */ jsx6(
+      Box5,
+      {
+        borderStyle: "single",
+        borderColor: isAborting ? "yellow" : pendingPrompt ? "cyan" : isDisabled ? "gray" : "green",
+        paddingLeft: 1,
+        children: isAborting ? /* @__PURE__ */ jsx6(Text7, { color: "yellow", children: " Interrupting..." }) : pendingPrompt ? /* @__PURE__ */ jsxs5(Text7, { color: "cyan", children: [
+          " ",
+          "Queued: ",
+          pendingPrompt.length > 50 ? pendingPrompt.slice(0, 47) + "..." : pendingPrompt,
+          " ",
+          /* @__PURE__ */ jsx6(Text7, { dimColor: true, children: "(Backspace to cancel)" })
+        ] }) : isDisabled ? /* @__PURE__ */ jsx6(WaveText, { text: "  Waiting for response... (ESC to interrupt)" }) : /* @__PURE__ */ jsxs5(Box5, { children: [
+          /* @__PURE__ */ jsx6(Text7, { color: "green", bold: true, children: "> " }),
+          /* @__PURE__ */ jsx6(
+            CjkTextInput,
+            {
+              value,
+              onChange: setValue,
+              onSubmit: handleSubmit,
+              onPaste: handlePaste,
+              placeholder: "Type a message or /help",
+              availableWidth
+            }
+          )
+        ] })
+      }
+    )
+  ] });
+}
+
+// src/ui/ConfirmPrompt.tsx
+import { useState as useState6, useCallback as useCallback6, useRef as useRef5 } from "react";
+import { Box as Box6, Text as Text8, useInput as useInput3 } from "ink";
+import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
+function ConfirmPrompt({
+  message,
+  options = ["Yes", "No"],
+  onSelect
+}) {
+  const [selected, setSelected] = useState6(0);
+  const resolvedRef = useRef5(false);
+  const doSelect = useCallback6(
+    (index) => {
+      if (resolvedRef.current) return;
+      resolvedRef.current = true;
+      onSelect(index);
+    },
+    [onSelect]
+  );
+  useInput3((input, key) => {
+    if (resolvedRef.current) return;
+    if (key.leftArrow || key.upArrow) {
+      setSelected((prev) => prev > 0 ? prev - 1 : prev);
+    } else if (key.rightArrow || key.downArrow) {
+      setSelected((prev) => prev < options.length - 1 ? prev + 1 : prev);
+    } else if (key.return) {
+      doSelect(selected);
+    } else if (input === "y" && options.length === 2) {
+      doSelect(0);
+    } else if (input === "n" && options.length === 2) {
+      doSelect(1);
+    }
+  });
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx7(Text8, { color: "yellow", children: message }),
+    /* @__PURE__ */ jsx7(Box6, { marginTop: 1, children: options.map((opt, i) => /* @__PURE__ */ jsx7(Box6, { marginRight: 2, children: /* @__PURE__ */ jsxs6(Text8, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
+      i === selected ? "> " : "  ",
+      opt
+    ] }) }, opt)) }),
+    /* @__PURE__ */ jsx7(Text8, { dimColor: true, children: " arrow keys to select, Enter to confirm" })
+  ] });
+}
+
+// src/ui/PermissionPrompt.tsx
+import React7 from "react";
+import { Box as Box7, Text as Text9, useInput as useInput4 } from "ink";
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+var OPTIONS = ["Allow", "Allow always (this session)", "Deny"];
+function formatArgs(args) {
+  const entries = Object.entries(args);
+  if (entries.length === 0) return "(no arguments)";
+  return entries.map(([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`).join(", ");
+}
+function PermissionPrompt({ request }) {
+  const [selected, setSelected] = React7.useState(0);
+  const resolvedRef = React7.useRef(false);
+  const prevRequestRef = React7.useRef(request);
+  if (prevRequestRef.current !== request) {
+    prevRequestRef.current = request;
+    resolvedRef.current = false;
+    setSelected(0);
+  }
+  const doResolve = React7.useCallback(
+    (index) => {
+      if (resolvedRef.current) return;
+      resolvedRef.current = true;
+      if (index === 0) request.resolve(true);
+      else if (index === 1) request.resolve("allow-session");
+      else request.resolve(false);
+    },
+    [request]
+  );
+  useInput4((input, key) => {
+    if (resolvedRef.current) return;
+    if (key.upArrow || key.leftArrow) {
+      setSelected((prev) => prev > 0 ? prev - 1 : prev);
+    } else if (key.downArrow || key.rightArrow) {
+      setSelected((prev) => prev < OPTIONS.length - 1 ? prev + 1 : prev);
+    } else if (key.return) {
+      doResolve(selected);
+    } else if (input === "y" || input === "1") {
+      doResolve(0);
+    } else if (input === "a" || input === "2") {
+      doResolve(1);
+    } else if (input === "n" || input === "d" || input === "3") {
+      doResolve(2);
+    }
+  });
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Text9, { color: "yellow", bold: true, children: "[Permission Required]" }),
+    /* @__PURE__ */ jsxs7(Text9, { children: [
+      "Tool:",
+      " ",
+      /* @__PURE__ */ jsx8(Text9, { color: "cyan", bold: true, children: request.toolName })
+    ] }),
+    /* @__PURE__ */ jsxs7(Text9, { dimColor: true, children: [
+      " ",
+      formatArgs(request.toolArgs)
+    ] }),
+    /* @__PURE__ */ jsx8(Box7, { marginTop: 1, children: OPTIONS.map((opt, i) => /* @__PURE__ */ jsx8(Box7, { marginRight: 2, children: /* @__PURE__ */ jsxs7(Text9, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
+      i === selected ? "> " : "  ",
+      opt
+    ] }) }, opt)) }),
+    /* @__PURE__ */ jsx8(Text9, { dimColor: true, children: " left/right to select, Enter to confirm" })
+  ] });
+}
+
+// src/ui/StreamingIndicator.tsx
+import { Box as Box8, Text as Text10 } from "ink";
+import { Fragment as Fragment2, jsx as jsx9, jsxs as jsxs8 } from "react/jsx-runtime";
+function getToolStyle(t) {
+  if (t.isRunning) return { color: "yellow", icon: "\u27F3", strikethrough: false };
+  if (t.result === "error") return { color: "red", icon: "\u2717", strikethrough: true };
+  if (t.result === "denied") return { color: "yellowBright", icon: "\u2298", strikethrough: true };
+  return { color: "green", icon: "\u2713", strikethrough: false };
+}
+function StreamingIndicator({ text, activeTools }) {
+  const hasTools = activeTools.length > 0;
+  const hasText = text.length > 0;
+  if (!hasTools && !hasText) {
+    return /* @__PURE__ */ jsx9(Fragment2, {});
+  }
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+    hasTools && /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx9(Text10, { color: "white", bold: true, children: "Tools:" }),
+      /* @__PURE__ */ jsx9(Text10, { children: " " }),
+      activeTools.map((t, i) => {
+        const { color, icon, strikethrough } = getToolStyle(t);
+        return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs8(Text10, { color, strikethrough, children: [
+            "  ",
+            icon,
+            " ",
+            t.toolName,
+            "(",
+            t.firstArg,
+            ")"
+          ] }),
+          t.diffLines && t.diffLines.length > 0 && /* @__PURE__ */ jsx9(DiffBlock, { file: t.diffFile, lines: t.diffLines })
+        ] }, `${t.toolName}-${i}`);
+      })
+    ] }),
+    hasText && /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx9(Text10, { color: "cyan", bold: true, children: "Robota:" }),
+      /* @__PURE__ */ jsx9(Text10, { children: " " }),
+      /* @__PURE__ */ jsx9(Box8, { marginLeft: 2, children: /* @__PURE__ */ jsx9(Text10, { wrap: "wrap", children: renderMarkdown(text) }) })
+    ] })
+  ] });
+}
+
+// src/ui/PluginTUI.tsx
+import { useState as useState9, useEffect as useEffect2, useCallback as useCallback9 } from "react";
+
+// src/ui/MenuSelect.tsx
+import { useState as useState7, useCallback as useCallback7, useRef as useRef6 } from "react";
+import { Box as Box9, Text as Text11, useInput as useInput5 } from "ink";
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+function MenuSelect({
+  title,
+  items,
+  onSelect,
+  onBack,
+  loading,
+  error
+}) {
+  const [selected, setSelected] = useState7(0);
+  const selectedRef = useRef6(0);
+  const resolvedRef = useRef6(false);
+  const doSelect = useCallback7(
+    (index) => {
+      if (resolvedRef.current || items.length === 0) return;
+      resolvedRef.current = true;
+      onSelect(items[index].value);
+    },
+    [items, onSelect]
+  );
+  useInput5((input, key) => {
+    if (resolvedRef.current) return;
+    if (key.escape) {
+      resolvedRef.current = true;
+      onBack();
+      return;
+    }
+    if (loading || error || items.length === 0) return;
+    if (key.upArrow) {
+      const next = selectedRef.current > 0 ? selectedRef.current - 1 : selectedRef.current;
+      selectedRef.current = next;
+      setSelected(next);
+    } else if (key.downArrow) {
+      const next = selectedRef.current < items.length - 1 ? selectedRef.current + 1 : selectedRef.current;
+      selectedRef.current = next;
+      setSelected(next);
+    } else if (key.return) {
+      doSelect(selectedRef.current);
+    }
+  });
+  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx10(Text11, { color: "yellow", bold: true, children: title }),
+    loading && /* @__PURE__ */ jsx10(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx10(Text11, { dimColor: true, children: "Loading..." }) }),
+    error && /* @__PURE__ */ jsxs9(Box9, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx10(Text11, { color: "red", children: error }),
+      /* @__PURE__ */ jsx10(Text11, { dimColor: true, children: "Press Esc to go back" })
+    ] }),
+    !loading && !error && /* @__PURE__ */ jsx10(Box9, { flexDirection: "column", marginTop: 1, children: items.map((item, i) => /* @__PURE__ */ jsxs9(Box9, { children: [
+      /* @__PURE__ */ jsxs9(Text11, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
+        i === selected ? "> " : "  ",
+        item.label
+      ] }),
+      item.hint && /* @__PURE__ */ jsxs9(Text11, { dimColor: true, children: [
+        " ",
+        item.hint
+      ] })
+    ] }, item.value)) }),
+    /* @__PURE__ */ jsx10(Text11, { dimColor: true, children: loading || error ? "" : " \u2191\u2193 Navigate  Enter Select  Esc Back" })
+  ] });
+}
+
+// src/ui/TextPrompt.tsx
+import { useState as useState8, useRef as useRef7, useCallback as useCallback8 } from "react";
+import { Box as Box10, Text as Text12, useInput as useInput6 } from "ink";
+import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
+function TextPrompt({
+  title,
+  placeholder,
+  onSubmit,
+  onCancel,
+  validate
+}) {
+  const [value, setValue] = useState8("");
+  const [error, setError] = useState8();
+  const resolvedRef = useRef7(false);
+  const valueRef = useRef7("");
+  const handleSubmit = useCallback8(() => {
+    if (resolvedRef.current) return;
+    const trimmed = valueRef.current.trim();
+    if (!trimmed) return;
+    if (validate) {
+      const err = validate(trimmed);
+      if (err) {
+        setError(err);
+        return;
+      }
+    }
+    resolvedRef.current = true;
+    onSubmit(trimmed);
+  }, [validate, onSubmit]);
+  useInput6((input, key) => {
+    if (resolvedRef.current) return;
+    if (key.escape) {
+      resolvedRef.current = true;
+      onCancel();
+      return;
+    }
+    if (key.return) {
+      handleSubmit();
+      return;
+    }
+    if (key.backspace || key.delete) {
+      valueRef.current = valueRef.current.slice(0, -1);
+      setValue(valueRef.current);
+      setError(void 0);
+      return;
+    }
+    if (input && !key.ctrl && !key.meta) {
+      valueRef.current = valueRef.current + input;
+      setValue(valueRef.current);
+      setError(void 0);
+    }
+  });
+  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx11(Text12, { color: "yellow", bold: true, children: title }),
+    /* @__PURE__ */ jsxs10(Box10, { marginTop: 1, children: [
+      /* @__PURE__ */ jsx11(Text12, { color: "cyan", children: "> " }),
+      value ? /* @__PURE__ */ jsx11(Text12, { children: value }) : placeholder ? /* @__PURE__ */ jsx11(Text12, { dimColor: true, children: placeholder }) : null,
+      /* @__PURE__ */ jsx11(Text12, { color: "cyan", children: "\u2588" })
+    ] }),
+    error && /* @__PURE__ */ jsx11(Text12, { color: "red", children: error }),
+    /* @__PURE__ */ jsx11(Text12, { dimColor: true, children: " Enter Submit Esc Cancel" })
+  ] });
+}
+
+// src/ui/plugin-tui-handlers.ts
+function handleMainSelect(value, nav) {
+  if (value === "marketplace") {
+    nav.push({ screen: "marketplace-list" });
+  } else if (value === "installed") {
+    nav.push({ screen: "installed-list" });
+  }
+}
+function handleMarketplaceListSelect(value, nav) {
+  if (value === "__add__") {
+    nav.push({ screen: "marketplace-add" });
+  } else {
+    nav.push({ screen: "marketplace-action", context: { marketplace: value } });
+  }
+}
+function handleMarketplaceActionSelect(value, marketplace, callbacks, nav) {
+  if (value === "browse") {
+    nav.push({ screen: "marketplace-browse", context: { marketplace } });
+  } else if (value === "update") {
+    callbacks.marketplaceUpdate(marketplace).then(() => {
+      nav.notify(`Updated marketplace "${marketplace}".`);
+      nav.pop();
+    }).catch((err) => {
+      nav.notify(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    });
+  } else if (value === "remove") {
+    nav.setConfirm({
+      message: `Remove marketplace "${marketplace}" and all its plugins?`,
+      onConfirm: () => {
+        nav.setConfirm(void 0);
+        callbacks.marketplaceRemove(marketplace).then(() => {
+          nav.notify(`Removed marketplace "${marketplace}".`);
+          nav.popN(2);
+        }).catch((err) => {
+          nav.notify(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        });
+      },
+      onCancel: () => nav.setConfirm(void 0)
+    });
+  }
+}
+function handleMarketplaceBrowseSelect(value, marketplace, items, nav) {
+  const fullId = `${value}@${marketplace}`;
+  const item = items.find((i) => i.value === value);
+  if (item?.hint === "installed") {
+    nav.push({ screen: "installed-action", context: { pluginId: fullId } });
+  } else {
+    nav.push({ screen: "marketplace-install-scope", context: { marketplace, pluginId: fullId } });
+  }
+}
+function handleInstallScopeSelect(value, pluginId, callbacks, nav) {
+  const scope = value;
+  callbacks.install(pluginId, scope).then(() => {
+    nav.notify(`Installed plugin "${pluginId}" (${scope} scope).`);
+    nav.popN(2);
+  }).catch((err) => {
+    nav.notify(`Error: ${err instanceof Error ? err.message : String(err)}`);
+  });
+}
+function handleInstalledListSelect(value, callbacks, nav) {
+  nav.setConfirm({
+    message: `Uninstall plugin "${value}"?`,
+    onConfirm: () => {
+      nav.setConfirm(void 0);
+      callbacks.uninstall(value).then(() => {
+        nav.notify(`Uninstalled plugin "${value}".`);
+        nav.refresh();
+      }).catch((err) => {
+        nav.notify(`Error: ${err instanceof Error ? err.message : String(err)}`);
+      });
+    },
+    onCancel: () => nav.setConfirm(void 0)
+  });
+}
+function handleInstalledActionSelect(value, pluginId, callbacks, nav) {
+  if (value === "uninstall") {
+    nav.setConfirm({
+      message: `Uninstall plugin "${pluginId}"?`,
+      onConfirm: () => {
+        nav.setConfirm(void 0);
+        callbacks.uninstall(pluginId).then(() => {
+          nav.notify(`Uninstalled plugin "${pluginId}".`);
+          nav.popN(2);
+        }).catch((err) => {
+          nav.notify(`Error: ${err instanceof Error ? err.message : String(err)}`);
+        });
+      },
+      onCancel: () => nav.setConfirm(void 0)
+    });
+  }
+}
+
+// src/ui/PluginTUI.tsx
+import { jsx as jsx12 } from "react/jsx-runtime";
+function PluginTUI({ callbacks, onClose, addMessage }) {
+  const [stack, setStack] = useState9([{ screen: "main" }]);
+  const [items, setItems] = useState9([]);
+  const [loading, setLoading] = useState9(false);
+  const [error, setError] = useState9();
+  const [confirm, setConfirm] = useState9();
+  const [refreshCounter, setRefreshCounter] = useState9(0);
+  const current = stack[stack.length - 1] ?? { screen: "main" };
+  const push = useCallback9((state) => {
+    setStack((prev) => [...prev, state]);
+    setItems([]);
+    setError(void 0);
+  }, []);
+  const pop = useCallback9(() => {
+    setStack((prev) => {
+      if (prev.length <= 1) {
+        onClose();
+        return prev;
+      }
+      return prev.slice(0, -1);
+    });
+    setItems([]);
+    setError(void 0);
+  }, [onClose]);
+  const popN = useCallback9(
+    (n) => {
+      setStack((prev) => {
+        const next = prev.slice(0, Math.max(1, prev.length - n));
+        if (next.length === 0) {
+          onClose();
+          return prev;
+        }
+        return next;
+      });
+      setItems([]);
+      setError(void 0);
+    },
+    [onClose]
+  );
+  const notify = useCallback9(
+    (content) => {
+      addMessage?.({ role: "system", content });
+    },
+    [addMessage]
+  );
+  const refresh = useCallback9(() => {
+    setItems([]);
+    setRefreshCounter((c) => c + 1);
+  }, []);
+  const nav = { push, pop, popN, notify, setConfirm, refresh };
+  useEffect2(() => {
+    const screen2 = current.screen;
+    if (screen2 === "marketplace-list") {
+      setLoading(true);
+      callbacks.marketplaceList().then((sources) => {
+        const baseItems = [{ label: "Add Marketplace", value: "__add__" }];
+        const sourceItems = sources.map((s) => ({
+          label: s.name,
+          value: s.name,
+          hint: s.type
+        }));
+        setItems([...baseItems, ...sourceItems]);
+        setLoading(false);
+      }).catch((err) => {
+        setError(err instanceof Error ? err.message : String(err));
+        setLoading(false);
+      });
+    } else if (screen2 === "marketplace-browse") {
+      const marketplace = current.context?.marketplace ?? "";
+      setLoading(true);
+      callbacks.listAvailablePlugins(marketplace).then((plugins) => {
+        setItems(
+          plugins.map((p) => ({
+            label: p.name,
+            value: p.name,
+            hint: p.installed ? "installed" : p.description
+          }))
+        );
+        setLoading(false);
+      }).catch((err) => {
+        setError(err instanceof Error ? err.message : String(err));
+        setLoading(false);
+      });
+    } else if (screen2 === "installed-list") {
+      setLoading(true);
+      callbacks.listInstalled().then((plugins) => {
+        setItems(
+          plugins.map((p) => ({
+            label: p.name,
+            value: p.name,
+            hint: p.description
+          }))
+        );
+        setLoading(false);
+      }).catch((err) => {
+        setError(err instanceof Error ? err.message : String(err));
+        setLoading(false);
+      });
+    }
+  }, [stack.length, current.screen, current.context?.marketplace, callbacks, refreshCounter]);
+  const handleSelect = useCallback9(
+    (value) => {
+      const screen2 = current.screen;
+      const ctx = current.context;
+      if (screen2 === "main") handleMainSelect(value, nav);
+      else if (screen2 === "marketplace-list") handleMarketplaceListSelect(value, nav);
+      else if (screen2 === "marketplace-action")
+        handleMarketplaceActionSelect(value, ctx?.marketplace ?? "", callbacks, nav);
+      else if (screen2 === "marketplace-browse")
+        handleMarketplaceBrowseSelect(value, ctx?.marketplace ?? "", items, nav);
+      else if (screen2 === "marketplace-install-scope")
+        handleInstallScopeSelect(value, ctx?.pluginId ?? "", callbacks, nav);
+      else if (screen2 === "installed-list") handleInstalledListSelect(value, callbacks, nav);
+      else if (screen2 === "installed-action")
+        handleInstalledActionSelect(value, ctx?.pluginId ?? "", callbacks, nav);
+    },
+    [current, items, callbacks, push, pop, popN, notify, setConfirm, refresh]
+  );
+  const handleTextSubmit = useCallback9(
+    (value) => {
+      if (current.screen === "marketplace-add") {
+        callbacks.marketplaceAdd(value).then((name) => {
+          notify(`Added marketplace "${name}" from ${value}.`);
+          pop();
+        }).catch((err) => {
+          notify(`Error: ${err instanceof Error ? err.message : String(err)}`);
+          pop();
+        });
+      }
+    },
+    [current.screen, callbacks, notify, pop]
+  );
+  if (confirm) {
+    return /* @__PURE__ */ jsx12(
+      ConfirmPrompt,
+      {
+        message: confirm.message,
+        onSelect: (index) => {
+          if (index === 0) confirm.onConfirm();
+          else confirm.onCancel();
+        }
+      }
+    );
+  }
+  const screen = current.screen;
+  if (screen === "marketplace-add") {
+    return /* @__PURE__ */ jsx12(
+      TextPrompt,
+      {
+        title: "Add Marketplace Source",
+        placeholder: "owner/repo or git URL",
+        onSubmit: handleTextSubmit,
+        onCancel: pop,
+        validate: (v) => !v.includes("/") ? "Must be owner/repo or a git URL" : void 0
+      }
+    );
+  }
+  if (screen === "marketplace-action") {
+    return /* @__PURE__ */ jsx12(
+      MenuSelect,
+      {
+        title: `Marketplace: ${current.context?.marketplace ?? ""}`,
+        items: [
+          { label: "Browse plugins", value: "browse" },
+          { label: "Update", value: "update" },
+          { label: "Remove", value: "remove" }
+        ],
+        onSelect: handleSelect,
+        onBack: pop
+      },
+      stack.length
+    );
+  }
+  if (screen === "marketplace-install-scope") {
+    return /* @__PURE__ */ jsx12(
+      MenuSelect,
+      {
+        title: `Install scope for "${current.context?.pluginId ?? ""}"`,
+        items: [
+          { label: "User scope", value: "user" },
+          { label: "Project scope", value: "project" }
+        ],
+        onSelect: handleSelect,
+        onBack: pop
+      },
+      stack.length
+    );
+  }
+  if (screen === "installed-action") {
+    return /* @__PURE__ */ jsx12(
+      MenuSelect,
+      {
+        title: `Plugin: ${current.context?.pluginId ?? ""}`,
+        items: [{ label: "Uninstall", value: "uninstall" }],
+        onSelect: handleSelect,
+        onBack: pop
+      },
+      stack.length
+    );
+  }
+  const titleMap = {
+    main: "Plugin Management",
+    "marketplace-list": "Marketplace",
+    "marketplace-browse": `Browse: ${current.context?.marketplace ?? ""}`,
+    "installed-list": "Installed Plugins"
+  };
+  const staticItemsMap = {
+    main: [
+      { label: "Marketplace", value: "marketplace" },
+      { label: "Installed Plugins", value: "installed" }
+    ]
+  };
+  return /* @__PURE__ */ jsx12(
+    MenuSelect,
+    {
+      title: titleMap[screen] ?? "Plugin Management",
+      items: staticItemsMap[screen] ?? items,
+      onSelect: handleSelect,
+      onBack: pop,
+      loading,
+      error
+    },
+    `${screen}-${stack.length}-${refreshCounter}`
+  );
+}
+
+// src/ui/App.tsx
+import { jsx as jsx13, jsxs as jsxs11 } from "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;
+}
+function App(props) {
+  const { exit } = 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] = useState10(false);
+  const initialCtx = session.getContextState();
+  const [contextState, setContextState] = useState10({
+    percentage: initialCtx.usedPercentage,
+    usedTokens: initialCtx.usedTokens,
+    maxTokens: initialCtx.maxTokens
+  });
+  const pendingModelChangeRef = useRef8(null);
+  const [pendingModelId, setPendingModelId] = useState10(null);
+  const [showPluginTUI, setShowPluginTUI] = useState10(false);
+  const [isAborting, setIsAborting] = useState10(false);
+  const [pendingPrompt, setPendingPrompt] = useState10(null);
+  const pendingPromptRef = useRef8(null);
+  const pluginCallbacks = usePluginCallbacks(props.cwd ?? process.cwd());
+  const handleSlashCommand = useSlashCommands(
+    session,
+    addMessage,
+    setMessages,
+    exit,
+    registry,
+    pendingModelChangeRef,
+    setPendingModelId,
+    pluginCallbacks,
+    setShowPluginTUI
+  );
+  const executePrompt = useSubmitHandler(
+    session,
+    addMessage,
+    handleSlashCommand,
+    clearStreamingText,
+    setIsThinking,
+    setContextState,
+    registry
+  );
+  const handleSubmit = useCallback10(
+    async (input) => {
+      if (isThinking) {
+        setPendingPrompt(input);
+        pendingPromptRef.current = input;
+        return;
+      }
+      await executePrompt(input);
+    },
+    [isThinking, executePrompt]
+  );
+  useInput7(
+    (_input, key) => {
+      if (key.escape && isThinking) {
+        setIsAborting(true);
+        setPendingPrompt(null);
+        pendingPromptRef.current = null;
+        session.abort();
+      }
+    },
+    { isActive: !permissionRequest && !showPluginTUI }
+  );
+  useEffect3(() => {
+    if (!isThinking) {
+      setIsAborting(false);
+      if (pendingPromptRef.current) {
+        const prompt = pendingPromptRef.current;
+        setPendingPrompt(null);
+        pendingPromptRef.current = null;
+        setTimeout(() => executePrompt(prompt), 0);
+      }
+    }
+  }, [isThinking, pendingPrompt, executePrompt]);
+  return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ jsx13(Text13, { color: "cyan", bold: true, children: `
+  ____   ___  ____   ___ _____  _
+ |  _ \\ / _ \\| __ ) / _ \\_   _|/ \\
+ | |_) | | | |  _ \\| | | || | / _ \\
+ |  _ <| |_| | |_) | |_| || |/ ___ \\
+ |_| \\_\\\\___/|____/ \\___/ |_/_/   \\_\\
+` }),
+      /* @__PURE__ */ jsxs11(Text13, { dimColor: true, children: [
+        " v",
+        props.version ?? "0.0.0"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+      /* @__PURE__ */ jsx13(MessageList, { messages }),
+      isThinking && /* @__PURE__ */ jsx13(Box11, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsx13(StreamingIndicator, { text: streamingText, activeTools }) })
+    ] }),
+    permissionRequest && /* @__PURE__ */ jsx13(PermissionPrompt, { request: permissionRequest }),
+    pendingModelId && /* @__PURE__ */ jsx13(
+      ConfirmPrompt,
+      {
+        message: `Change model to ${getModelName(pendingModelId)}? This will restart the session.`,
+        onSelect: (index) => {
+          setPendingModelId(null);
+          pendingModelChangeRef.current = null;
+          if (index === 0) {
+            try {
+              const settingsPath = getUserSettingsPath();
+              updateModelInSettings(settingsPath, pendingModelId);
+              addMessage(
+                createSystemMessage3(
+                  `Model changed to ${getModelName(pendingModelId)}. Restarting...`
+                )
+              );
+              setTimeout(() => exit(), EXIT_DELAY_MS2);
+            } catch (err) {
+              addMessage(
+                createSystemMessage3(
+                  `Failed: ${err instanceof Error ? err.message : String(err)}`
+                )
+              );
+            }
+          } else {
+            addMessage(createSystemMessage3("Model change cancelled."));
+          }
+        }
+      }
+    ),
+    showPluginTUI && /* @__PURE__ */ jsx13(
+      PluginTUI,
+      {
+        callbacks: pluginCallbacks,
+        onClose: () => setShowPluginTUI(false),
+        addMessage: (msg) => addMessage(createSystemMessage3(msg.content))
+      }
+    ),
+    /* @__PURE__ */ jsx13(
+      StatusBar,
+      {
+        permissionMode: session.getPermissionMode(),
+        modelName: getModelName(props.config.provider.model),
+        sessionId: session.getSessionId(),
+        messageCount: messages.length,
+        isThinking,
+        contextPercentage: contextState.percentage,
+        contextUsedTokens: contextState.usedTokens,
+        contextMaxTokens: contextState.maxTokens
+      }
+    ),
+    /* @__PURE__ */ jsx13(
+      InputArea,
+      {
+        onSubmit: handleSubmit,
+        onCancelQueue: () => {
+          setPendingPrompt(null);
+          pendingPromptRef.current = null;
+        },
+        isDisabled: !!permissionRequest || showPluginTUI || isThinking && !!pendingPrompt,
+        isAborting,
+        pendingPrompt,
+        registry
+      }
+    ),
+    /* @__PURE__ */ jsx13(Text13, { children: " " })
+  ] });
+}
+
+// src/ui/render.tsx
+import { jsx as jsx14 } from "react/jsx-runtime";
+function renderApp(options) {
+  process.on("unhandledRejection", (reason) => {
+    process.stderr.write(`
+[UNHANDLED REJECTION] ${reason}
+`);
+    if (reason instanceof Error) {
+      process.stderr.write(`${reason.stack}
+`);
+    }
+  });
+  if (process.stdin.isTTY && process.stdout.isTTY) {
+    process.stdout.write("\x1B[?2004h");
+  }
+  const instance = render(/* @__PURE__ */ jsx14(App, { ...options }), {
+    exitOnCtrlC: true
+  });
+  instance.waitUntilExit().then(() => {
+    if (process.stdout.isTTY) {
+      process.stdout.write("\x1B[?2004l");
+    }
+    process.exit(0);
+  }).catch((err) => {
+    if (err) {
+      process.stderr.write(`
+[EXIT ERROR] ${err}
+`);
+    }
+    process.exit(1);
+  });
+}
+
+// src/cli.ts
+function checkSettingsFile(filePath) {
+  if (!existsSync3(filePath)) return "missing";
+  try {
+    const raw = readFileSync4(filePath, "utf8").trim();
+    if (raw.length === 0) return "incomplete";
+    const parsed = JSON.parse(raw);
+    const provider = parsed.provider;
+    if (!provider?.apiKey) return "incomplete";
+    return "valid";
+  } catch {
+    return "corrupt";
+  }
+}
+function readVersion() {
+  try {
+    const thisFile = fileURLToPath(import.meta.url);
+    const dir = dirname3(thisFile);
+    const candidates = [join5(dir, "..", "..", "package.json"), join5(dir, "..", "package.json")];
+    for (const pkgPath of candidates) {
+      try {
+        const raw = readFileSync4(pkgPath, "utf-8");
+        const pkg = JSON.parse(raw);
+        if (pkg.version !== void 0 && pkg.name !== void 0) {
+          return pkg.version;
+        }
+      } catch {
+      }
+    }
+    return "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function promptInput(label, masked = false) {
+  return new Promise((resolve) => {
+    process.stdout.write(label);
+    let input = "";
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    const onData = (data) => {
+      for (const ch of data) {
+        if (ch === "\r" || ch === "\n") {
+          stdin.removeListener("data", onData);
+          stdin.setRawMode(wasRaw ?? false);
+          stdin.pause();
+          process.stdout.write("\n");
+          resolve(input.trim());
+          return;
+        } else if (ch === "\x7F" || ch === "\b") {
+          if (input.length > 0) {
+            input = input.slice(0, -1);
+            process.stdout.write("\b \b");
+          }
+        } else if (ch === "") {
+          process.stdout.write("\n");
+          process.exit(0);
+        } else if (ch.charCodeAt(0) >= 32) {
+          input += ch;
+          process.stdout.write(masked ? "*" : ch);
+        }
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+async function ensureConfig(cwd) {
+  const userPath = getUserSettingsPath();
+  const projectPath = join5(cwd, ".robota", "settings.json");
+  const localPath = join5(cwd, ".robota", "settings.local.json");
+  const paths = [userPath, projectPath, localPath];
+  const checks = paths.map((p) => ({ path: p, status: checkSettingsFile(p) }));
+  if (checks.some((c) => c.status === "valid")) {
+    return;
+  }
+  const corrupt = checks.filter((c) => c.status === "corrupt");
+  const incomplete = checks.filter((c) => c.status === "incomplete");
+  process.stdout.write("\n");
+  if (corrupt.length > 0) {
+    for (const c of corrupt) {
+      process.stderr.write(`  ERROR: Settings file is corrupt (invalid JSON): ${c.path}
+`);
+    }
+    process.stdout.write("\n");
+  }
+  if (incomplete.length > 0) {
+    for (const c of incomplete) {
+      process.stderr.write(`  WARNING: Settings file is missing provider.apiKey: ${c.path}
+`);
+    }
+    process.stdout.write("\n");
+  }
+  if (corrupt.length === 0 && incomplete.length === 0) {
+    process.stdout.write("  Welcome to Robota CLI!\n");
+    process.stdout.write("  No configuration found. Let's set up.\n");
+  } else {
+    process.stdout.write("  Reconfiguring...\n");
+  }
+  process.stdout.write("\n");
+  const apiKey = await promptInput("  Anthropic API key: ", true);
+  if (!apiKey) {
+    process.stderr.write("\n  No API key provided. Exiting.\n");
+    process.exit(1);
+  }
+  const language = await promptInput("  Response language (ko/en/ja/zh, default: en): ");
+  const settingsDir = dirname3(userPath);
+  mkdirSync2(settingsDir, { recursive: true });
+  const settings = {
+    provider: {
+      name: "anthropic",
+      model: "claude-sonnet-4-6",
+      apiKey
+    }
+  };
+  if (language) {
+    settings.language = language;
+  }
+  writeFileSync2(userPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  process.stdout.write(`
+  Config saved to ${userPath}
+
+`);
+}
+function resetConfig() {
+  const userPath = getUserSettingsPath();
+  if (deleteSettings(userPath)) {
+    process.stdout.write(`Deleted ${userPath}
+`);
+  } else {
+    process.stdout.write("No user settings found.\n");
+  }
+}
+async function startCli() {
+  const args = parseCliArgs();
+  if (args.version) {
+    process.stdout.write(`robota ${readVersion()}
+`);
+    return;
+  }
+  if (args.reset) {
+    resetConfig();
+    return;
+  }
+  const cwd = process.cwd();
+  await ensureConfig(cwd);
+  const [config, context, projectInfo] = await Promise.all([
+    loadConfig(cwd),
+    loadContext(cwd),
+    detectProject(cwd)
+  ]);
+  if (args.model !== void 0) {
+    config.provider.model = args.model;
+  }
+  if (args.language !== void 0) {
+    config.language = args.language;
+  }
+  const sessionStore = new SessionStore();
+  if (args.printMode) {
+    const prompt = args.positional.join(" ").trim();
+    if (prompt.length === 0) {
+      process.stderr.write("Print mode (-p) requires a prompt argument.\n");
+      process.exit(1);
+    }
+    const terminal = new PrintTerminal();
+    const paths = projectPaths2(cwd);
+    const session = createSession2({
+      config,
+      context,
+      terminal,
+      sessionLogger: new FileSessionLogger2(paths.logs),
+      projectInfo,
+      permissionMode: args.permissionMode,
+      promptForApproval
+    });
+    const response = await session.run(prompt);
+    process.stdout.write(response + "\n");
+    return;
+  }
+  renderApp({
+    config,
+    context,
+    projectInfo,
+    sessionStore,
+    permissionMode: args.permissionMode,
+    maxTurns: args.maxTurns,
+    version: readVersion()
+  });
+}
+
+export {
+  startCli
+};