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

package/dist/node/index.cjs

@@ -30,192 +30,599 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  Session: () => import_agent_sdk3.Session,
-  SessionStore: () => import_agent_sdk3.SessionStore,
-  TRUST_TO_MODE: () => import_agent_sdk3.TRUST_TO_MODE,
-  query: () => import_agent_sdk3.query,
   startCli: () => startCli
 });
 module.exports = __toCommonJS(index_exports);
-var import_agent_sdk3 = require("@robota-sdk/agent-sdk");
 
 // src/cli.ts
+var import_node_fs3 = require("fs");
+var import_node_path5 = require("path");
+var import_node_url = require("url");
+var import_agent_sdk3 = require("@robota-sdk/agent-sdk");
+var import_agent_sessions = require("@robota-sdk/agent-sessions");
+
+// src/utils/cli-args.ts
 var import_node_util = require("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 } = (0, import_node_util.parseArgs)({
+    allowPositionals: true,
+    options: {
+      p: { type: "boolean", short: "p", default: false },
+      continue: { type: "boolean", short: "c", default: false },
+      resume: { type: "string", short: "r" },
+      model: { type: "string" },
+      language: { type: "string" },
+      "permission-mode": { type: "string" },
+      "max-turns": { type: "string" },
+      "fork-session": { type: "boolean", default: false },
+      name: { type: "string", short: "n" },
+      "output-format": { type: "string" },
+      "system-prompt": { type: "string" },
+      "append-system-prompt": { type: "string" },
+      version: { type: "boolean", default: false },
+      reset: { type: "boolean", default: false }
+    }
+  });
+  return {
+    positional: positionals,
+    printMode: values["p"] ?? false,
+    continueMode: values["continue"] ?? false,
+    resumeId: values["resume"],
+    model: values["model"],
+    language: values["language"],
+    permissionMode: parsePermissionMode(values["permission-mode"]),
+    maxTurns: parseMaxTurns(values["max-turns"]),
+    forkSession: values["fork-session"] ?? false,
+    sessionName: values["name"],
+    outputFormat: values["output-format"],
+    systemPrompt: values["system-prompt"],
+    appendSystemPrompt: values["append-system-prompt"],
+    version: values["version"] ?? false,
+    reset: values["reset"] ?? false
+  };
+}
+
+// src/utils/settings-io.ts
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+function getUserSettingsPath() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "/";
+  return (0, import_node_path.join)(home, ".robota", "settings.json");
+}
+function readSettings(path) {
+  if (!(0, import_node_fs.existsSync)(path)) return {};
+  return JSON.parse((0, import_node_fs.readFileSync)(path, "utf8"));
+}
+function writeSettings(path, settings) {
+  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(path), { recursive: true });
+  (0, import_node_fs.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 ((0, import_node_fs.existsSync)(path)) {
+    (0, import_node_fs.unlinkSync)(path);
+    return true;
+  }
+  return false;
+}
+
+// src/utils/provider-factory.ts
 var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
-var import_node_url = require("url");
-var readline = __toESM(require("readline"), 1);
-var import_agent_sdk2 = require("@robota-sdk/agent-sdk");
-
-// src/permissions/permission-prompt.ts
-var import_chalk = __toESM(require("chalk"), 1);
-var PERMISSION_OPTIONS = ["Allow", "Deny"];
-var ALLOW_INDEX = 0;
-function formatArgs(toolArgs) {
-  const entries = Object.entries(toolArgs);
-  if (entries.length === 0) {
-    return "(no arguments)";
+var import_node_os = require("os");
+var import_agent_provider_anthropic = require("@robota-sdk/agent-provider-anthropic");
+function readProviderSettings(cwd) {
+  const paths = [
+    (0, import_node_path2.join)(cwd, ".robota", "settings.local.json"),
+    (0, import_node_path2.join)(cwd, ".robota", "settings.json"),
+    (0, import_node_path2.join)(cwd, ".claude", "settings.local.json"),
+    (0, import_node_path2.join)(cwd, ".claude", "settings.json"),
+    (0, import_node_path2.join)((0, import_node_os.homedir)(), ".robota", "settings.json"),
+    (0, import_node_path2.join)((0, import_node_os.homedir)(), ".claude", "settings.json")
+  ];
+  for (const filePath of paths) {
+    if (!(0, import_node_fs2.existsSync)(filePath)) continue;
+    try {
+      const raw = (0, import_node_fs2.readFileSync)(filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      const provider = parsed.provider;
+      if (provider?.apiKey && provider?.name) {
+        return {
+          name: provider.name,
+          model: provider.model ?? "claude-sonnet-4-6",
+          apiKey: provider.apiKey
+        };
+      }
+    } catch {
+      continue;
+    }
   }
-  return entries.map(([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`).join(", ");
+  throw new Error("No provider configuration found. Run `robota` to set up.");
 }
-async function promptForApproval(terminal, toolName, toolArgs) {
-  terminal.writeLine("");
-  terminal.writeLine(import_chalk.default.yellow(`[Permission Required] Tool: ${toolName}`));
-  terminal.writeLine(import_chalk.default.dim(`  ${formatArgs(toolArgs)}`));
-  terminal.writeLine("");
-  const selected = await terminal.select(PERMISSION_OPTIONS, ALLOW_INDEX);
-  return selected === ALLOW_INDEX;
+function createProviderFromSettings(cwd, modelOverride) {
+  const settings = readProviderSettings(cwd);
+  const model = modelOverride ?? settings.model;
+  switch (settings.name) {
+    case "anthropic":
+      return new import_agent_provider_anthropic.AnthropicProvider({ apiKey: settings.apiKey, defaultModel: model });
+    default:
+      throw new Error(`Unknown provider: ${settings.name}. Currently supported: anthropic`);
+  }
 }
 
+// src/cli.ts
+var import_agent_transport_headless = require("@robota-sdk/agent-transport-headless");
+
 // src/ui/render.tsx
-var import_ink9 = require("ink");
+var import_ink15 = require("ink");
 
 // src/ui/App.tsx
-var import_react5 = require("react");
-var import_ink8 = require("ink");
+var import_react13 = require("react");
+var import_ink14 = require("ink");
+var import_agent_core4 = require("@robota-sdk/agent-core");
+
+// src/ui/hooks/useInteractiveSession.ts
+var import_react = require("react");
+var import_node_os2 = require("os");
+var import_node_path3 = require("path");
 var import_agent_sdk = require("@robota-sdk/agent-sdk");
+var import_agent_core = require("@robota-sdk/agent-core");
+var import_node_crypto = require("crypto");
 
-// src/commands/command-registry.ts
-var CommandRegistry = class {
-  sources = [];
-  addSource(source) {
-    this.sources.push(source);
+// src/ui/tui-state-manager.ts
+var MAX_RENDERED_MESSAGES = 100;
+var TuiStateManager = class {
+  // ── Rendering state ───────────────────────────────────────────
+  history = [];
+  streamingText = "";
+  activeTools = [];
+  isThinking = false;
+  isAborting = false;
+  pendingPrompt = null;
+  contextState = { percentage: 0, usedTokens: 0, maxTokens: 0 };
+  /** Called after any state change. React hook sets this to trigger re-render. */
+  onChange = null;
+  // ── Internal ──────────────────────────────────────────────────
+  streamBuf = "";
+  notify() {
+    this.onChange?.();
   }
-  /** Get all commands, optionally filtered by prefix */
-  getCommands(filter) {
-    const all = [];
-    for (const source of this.sources) {
-      all.push(...source.getCommands());
+  // ── Event handlers (InteractiveSession → state) ───────────────
+  onTextDelta = (delta) => {
+    this.streamBuf += delta;
+    this.streamingText = this.streamBuf;
+    this.notify();
+  };
+  onToolStart = (state) => {
+    this.activeTools = [...this.activeTools, state];
+    this.notify();
+  };
+  onToolEnd = (state) => {
+    const idx = this.activeTools.findIndex((t) => t.toolName === state.toolName && t.isRunning);
+    if (idx !== -1) {
+      const updated = [...this.activeTools];
+      updated[idx] = state;
+      this.activeTools = updated;
     }
-    if (!filter) return all;
-    const lower = filter.toLowerCase();
-    return all.filter((cmd) => cmd.name.toLowerCase().startsWith(lower));
-  }
-  /** 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;
-        }
-      }
+    this.notify();
+  };
+  onThinking = (thinking) => {
+    this.isThinking = thinking;
+    if (thinking) {
+      this.streamBuf = "";
+      this.streamingText = "";
+      this.activeTools = [];
+    } else {
+      this.isAborting = false;
     }
-    return [];
+    this.notify();
+  };
+  onComplete = (result) => {
+    this.streamBuf = "";
+    this.streamingText = "";
+    this.activeTools = [];
+    this.contextState = {
+      percentage: result.contextState.usedPercentage,
+      usedTokens: result.contextState.usedTokens,
+      maxTokens: result.contextState.maxTokens
+    };
+    this.notify();
+  };
+  onInterrupted = () => {
+    this.streamBuf = "";
+    this.streamingText = "";
+    this.activeTools = [];
+    this.notify();
+  };
+  onError = () => {
+    this.streamBuf = "";
+    this.streamingText = "";
+    this.activeTools = [];
+    this.notify();
+  };
+  // ── State updates from external sources ───────────────────────
+  /** Sync history from InteractiveSession */
+  syncHistory(entries) {
+    if (entries.length === 0) return;
+    this.history = entries.length > MAX_RENDERED_MESSAGES ? entries.slice(-MAX_RENDERED_MESSAGES) : [...entries];
+    this.notify();
   }
-};
-
-// src/commands/builtin-source.ts
-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: [
-        { name: "claude-opus-4-6", description: "Opus 4.6 (highest quality)", source: "builtin" },
-        { name: "claude-sonnet-4-6", description: "Sonnet 4.6 (balanced)", source: "builtin" },
-        { name: "claude-haiku-4-5", description: "Haiku 4.5 (fastest)", 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: "exit", description: "Exit CLI", source: "builtin" }
-  ];
-}
-var BuiltinCommandSource = class {
-  name = "builtin";
-  commands;
-  constructor() {
-    this.commands = createBuiltinCommands();
+  /** Add a single history entry */
+  addEntry(entry) {
+    const updated = [...this.history, entry];
+    this.history = updated.length > MAX_RENDERED_MESSAGES ? updated.slice(-MAX_RENDERED_MESSAGES) : updated;
+    this.notify();
   }
-  getCommands() {
-    return this.commands;
+  /** Update pending prompt state */
+  setPendingPrompt(prompt) {
+    this.pendingPrompt = prompt;
+    this.notify();
+  }
+  /** Set aborting flag */
+  setAborting(aborting) {
+    this.isAborting = aborting;
+    this.notify();
+  }
+  /** Update context state */
+  setContextState(state) {
+    this.contextState = state;
+    this.notify();
   }
 };
 
-// src/commands/skill-source.ts
-var import_node_fs = require("fs");
-var import_node_path = require("path");
-var import_node_os = require("os");
-function parseFrontmatter(content) {
-  const lines = content.split("\n");
-  if (lines[0]?.trim() !== "---") return null;
-  let name = "";
-  let description = "";
-  for (let i = 1; i < lines.length; i++) {
-    const line = lines[i];
-    if (line.trim() === "---") break;
-    const nameMatch = line.match(/^name:\s*(.+)/);
-    if (nameMatch) {
-      name = nameMatch[1].trim();
-      continue;
-    }
-    const descMatch = line.match(/^description:\s*(.+)/);
-    if (descMatch) {
-      description = descMatch[1].trim();
+// src/ui/hooks/useInteractiveSession.ts
+function initializeSession(props, permissionHandler) {
+  const interactiveSession = new import_agent_sdk.InteractiveSession({
+    cwd: props.cwd,
+    provider: props.provider,
+    permissionMode: props.permissionMode,
+    maxTurns: props.maxTurns,
+    permissionHandler,
+    sessionStore: props.sessionStore,
+    resumeSessionId: props.resumeSessionId,
+    forkSession: props.forkSession,
+    sessionName: props.sessionName
+  });
+  const registry = new import_agent_sdk.CommandRegistry();
+  registry.addSource(new import_agent_sdk.BuiltinCommandSource());
+  registry.addSource(new import_agent_sdk.SkillCommandSource(props.cwd));
+  const pluginsDir = (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".robota", "plugins");
+  const loader = new import_agent_sdk.BundlePluginLoader(pluginsDir);
+  try {
+    const plugins = loader.loadPluginsSync();
+    if (plugins.length > 0) {
+      registry.addSource(new import_agent_sdk.PluginCommandSource(plugins));
     }
+  } catch {
   }
-  return name ? { name, description } : null;
+  const manager = new TuiStateManager();
+  return { interactiveSession, registry, manager };
 }
-function scanSkillsDir(skillsDir) {
-  if (!(0, import_node_fs.existsSync)(skillsDir)) return [];
-  const commands = [];
-  const entries = (0, import_node_fs.readdirSync)(skillsDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const skillFile = (0, import_node_path.join)(skillsDir, entry.name, "SKILL.md");
-    if (!(0, import_node_fs.existsSync)(skillFile)) continue;
-    const content = (0, import_node_fs.readFileSync)(skillFile, "utf-8");
-    const frontmatter = parseFrontmatter(content);
-    commands.push({
-      name: frontmatter?.name ?? entry.name,
-      description: frontmatter?.description ?? `Skill: ${entry.name}`,
-      source: "skill"
+function useInteractiveSession(props) {
+  const [, forceRender] = (0, import_react.useState)(0);
+  const [permissionRequest, setPermissionRequest] = (0, import_react.useState)(null);
+  const permissionQueueRef = (0, import_react.useRef)([]);
+  const processingRef = (0, import_react.useRef)(false);
+  const processNextPermission = (0, import_react.useCallback)(() => {
+    if (processingRef.current) return;
+    const next = permissionQueueRef.current[0];
+    if (!next) {
+      setPermissionRequest(null);
+      return;
+    }
+    processingRef.current = true;
+    setPermissionRequest({
+      toolName: next.toolName,
+      toolArgs: next.toolArgs,
+      resolve: (result) => {
+        permissionQueueRef.current.shift();
+        processingRef.current = false;
+        setPermissionRequest(null);
+        next.resolve(result);
+        setTimeout(() => processNextPermission(), 0);
+      }
     });
+  }, []);
+  const permissionHandler = (0, import_react.useCallback)(
+    (toolName, toolArgs) => new Promise((resolve) => {
+      permissionQueueRef.current.push({ toolName, toolArgs, resolve });
+      processNextPermission();
+    }),
+    [processNextPermission]
+  );
+  const stateRef = (0, import_react.useRef)(null);
+  if (stateRef.current === null) {
+    stateRef.current = initializeSession(props, permissionHandler);
   }
-  return commands;
-}
-var SkillCommandSource = class {
-  name = "skill";
-  cwd;
-  cachedCommands = null;
-  constructor(cwd) {
-    this.cwd = cwd;
+  const { interactiveSession, registry, manager } = stateRef.current;
+  manager.onChange = () => forceRender((n) => n + 1);
+  if (manager.history.length === 0) {
+    const restored = interactiveSession.getFullHistory();
+    if (restored.length > 0) {
+      manager.syncHistory(restored);
+    }
   }
-  getCommands() {
-    if (this.cachedCommands) return this.cachedCommands;
-    const projectSkills = scanSkillsDir((0, import_node_path.join)(this.cwd, ".agents", "skills"));
-    const userSkills = scanSkillsDir((0, import_node_path.join)((0, import_node_os.homedir)(), ".claude", "skills"));
-    const seen = new Set(projectSkills.map((cmd) => cmd.name));
-    const merged = [...projectSkills];
-    for (const cmd of userSkills) {
-      if (!seen.has(cmd.name)) {
-        merged.push(cmd);
+  (0, import_react.useEffect)(() => {
+    interactiveSession.on("text_delta", manager.onTextDelta);
+    interactiveSession.on("tool_start", manager.onToolStart);
+    interactiveSession.on("tool_end", manager.onToolEnd);
+    interactiveSession.on("thinking", manager.onThinking);
+    interactiveSession.on("complete", manager.onComplete);
+    interactiveSession.on("interrupted", manager.onInterrupted);
+    interactiveSession.on("error", manager.onError);
+    const initCheck = setInterval(() => {
+      try {
+        const ctx = interactiveSession.getContextState();
+        manager.setContextState({
+          percentage: ctx.usedPercentage,
+          usedTokens: ctx.usedTokens,
+          maxTokens: ctx.maxTokens
+        });
+        const restored = interactiveSession.getFullHistory();
+        if (restored.length > 0) {
+          manager.syncHistory(restored);
+        }
+        clearInterval(initCheck);
+      } catch {
       }
+    }, 200);
+    return () => {
+      clearInterval(initCheck);
+      interactiveSession.off("text_delta", manager.onTextDelta);
+      interactiveSession.off("tool_start", manager.onToolStart);
+      interactiveSession.off("tool_end", manager.onToolEnd);
+      interactiveSession.off("thinking", manager.onThinking);
+      interactiveSession.off("complete", manager.onComplete);
+      interactiveSession.off("interrupted", manager.onInterrupted);
+      interactiveSession.off("error", manager.onError);
+    };
+  }, [interactiveSession, manager]);
+  (0, import_react.useEffect)(() => {
+    manager.syncHistory(interactiveSession.getFullHistory());
+    if (!manager.isThinking) {
+      manager.setPendingPrompt(interactiveSession.getPendingPrompt());
     }
-    this.cachedCommands = merged;
-    return this.cachedCommands;
-  }
-};
+  }, [manager.isThinking, interactiveSession, manager]);
+  const handleSubmit = (0, import_react.useCallback)(
+    async (input) => {
+      if (input.startsWith("/")) {
+        const parts = input.slice(1).split(/\s+/);
+        const cmd = parts[0]?.toLowerCase() ?? "";
+        const args = parts.slice(1).join(" ");
+        const result = await interactiveSession.executeCommand(cmd, args);
+        if (result) {
+          manager.addEntry((0, import_agent_core.messageToHistoryEntry)((0, import_agent_core.createSystemMessage)(result.message)));
+          const effects = interactiveSession;
+          if (result.data?.modelId) {
+            effects._pendingModelId = result.data.modelId;
+            return;
+          }
+          if (result.data?.language) {
+            effects._pendingLanguage = result.data.language;
+            return;
+          }
+          if (result.data?.resetRequested) {
+            effects._resetRequested = true;
+            return;
+          }
+          if (result.data?.triggerResumePicker) {
+            effects._triggerResumePicker = true;
+            return;
+          }
+          if (result.data?.name) {
+            effects._sessionName = result.data.name;
+            return;
+          }
+          const ctx = interactiveSession.getContextState();
+          manager.setContextState({
+            percentage: ctx.usedPercentage,
+            usedTokens: ctx.usedTokens,
+            maxTokens: ctx.maxTokens
+          });
+          return;
+        }
+        const skillCmd = registry.getCommands().find((c) => c.name === cmd && (c.source === "skill" || c.source === "plugin"));
+        if (skillCmd) {
+          manager.addEntry({
+            id: (0, import_node_crypto.randomUUID)(),
+            timestamp: /* @__PURE__ */ new Date(),
+            category: "event",
+            type: "skill-invocation",
+            data: {
+              skillName: cmd,
+              source: skillCmd.source,
+              message: `Invoking ${skillCmd.source}: ${cmd}`
+            }
+          });
+          const prompt = await (0, import_agent_sdk.buildSkillPrompt)(input, registry);
+          if (prompt) {
+            const qualifiedName = registry.resolveQualifiedName(cmd);
+            const hookInput = qualifiedName ? `/${qualifiedName}${input.slice(1 + cmd.length)}` : input;
+            await interactiveSession.submit(prompt, input, hookInput);
+            manager.setPendingPrompt(interactiveSession.getPendingPrompt());
+            return;
+          }
+        }
+        if (cmd === "exit") {
+          interactiveSession._exitRequested = true;
+          return;
+        }
+        if (cmd === "plugin") {
+          interactiveSession._triggerPluginTUI = true;
+          return;
+        }
+        manager.addEntry(
+          (0, import_agent_core.messageToHistoryEntry)(
+            (0, import_agent_core.createSystemMessage)(`Unknown command "/${cmd}". Type /help for help.`)
+          )
+        );
+        return;
+      }
+      await interactiveSession.submit(input);
+      manager.setPendingPrompt(interactiveSession.getPendingPrompt());
+    },
+    [interactiveSession, registry, manager]
+  );
+  const handleAbort = (0, import_react.useCallback)(() => {
+    manager.setAborting(true);
+    interactiveSession.abort();
+  }, [interactiveSession, manager]);
+  const handleCancelQueue = (0, import_react.useCallback)(() => {
+    interactiveSession.cancelQueue();
+    manager.setPendingPrompt(null);
+  }, [interactiveSession, manager]);
+  return {
+    interactiveSession,
+    registry,
+    history: manager.history,
+    addEntry: (entry) => manager.addEntry(entry),
+    streamingText: manager.streamingText,
+    activeTools: manager.activeTools,
+    isThinking: manager.isThinking,
+    isAborting: manager.isAborting,
+    pendingPrompt: manager.pendingPrompt,
+    permissionRequest,
+    contextState: manager.contextState,
+    handleSubmit,
+    handleAbort,
+    handleCancelQueue
+  };
+}
+
+// src/ui/hooks/usePluginCallbacks.ts
+var import_react2 = require("react");
+var import_node_os3 = require("os");
+var import_node_path4 = require("path");
+var import_agent_sdk2 = require("@robota-sdk/agent-sdk");
+function usePluginCallbacks(cwd) {
+  return (0, import_react2.useMemo)(() => {
+    const home = (0, import_node_os3.homedir)();
+    const pluginsDir = (0, import_node_path4.join)(home, ".robota", "plugins");
+    const userSettingsPath = (0, import_node_path4.join)(home, ".robota", "settings.json");
+    const settingsStore = new import_agent_sdk2.PluginSettingsStore(userSettingsPath);
+    const marketplace = new import_agent_sdk2.MarketplaceClient({ pluginsDir });
+    const installer = new import_agent_sdk2.BundlePluginInstaller({
+      pluginsDir,
+      settingsStore,
+      marketplaceClient: marketplace
+    });
+    const loader = new import_agent_sdk2.BundlePluginLoader(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 = (0, import_node_path4.join)(cwd, ".robota", "plugins");
+          const projectInstaller = new import_agent_sdk2.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
-var import_ink = require("ink");
+var import_react3 = __toESM(require("react"), 1);
+var import_ink2 = require("ink");
+var import_agent_core2 = require("@robota-sdk/agent-core");
 
 // src/ui/render-markdown.ts
 var import_marked = require("marked");
@@ -228,54 +635,201 @@ function renderMarkdown(md) {
   return typeof result === "string" ? result.trimEnd() : md;
 }
 
-// src/ui/MessageList.tsx
+// src/ui/DiffBlock.tsx
+var import_ink = require("ink");
 var import_jsx_runtime = require("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__ */ (0, import_jsx_runtime.jsxs)(import_ink.Box, { flexDirection: "column", marginLeft: 4, children: [
+    file && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink.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__ */ (0, import_jsx_runtime.jsxs)(import_ink.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__ */ (0, import_jsx_runtime.jsxs)(import_ink.Text, { color: fgColor, backgroundColor: bgColor, children: [
+        "\u2502 ",
+        lineNum,
+        " ",
+        prefix,
+        " ",
+        line.text
+      ] }, i);
+    }),
+    truncated && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink.Text, { color: "white", dimColor: true, children: [
+      "\u2502 ... and ",
+      remaining,
+      " more lines"
+    ] })
+  ] });
+}
+
+// src/ui/MessageList.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
 function RoleLabel({ role }) {
   switch (role) {
     case "user":
-      return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink.Text, { color: "green", bold: true, children: [
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { color: "green", bold: true, children: [
         "You:",
         " "
       ] });
     case "assistant":
-      return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink.Text, { color: "cyan", bold: true, children: [
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { color: "cyan", bold: true, children: [
         "Robota:",
         " "
       ] });
     case "system":
-      return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink.Text, { color: "yellow", bold: true, children: [
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { color: "yellow", bold: true, children: [
         "System:",
         " "
       ] });
     case "tool":
-      return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink.Text, { color: "magenta", bold: true, children: [
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { color: "white", bold: true, children: [
         "Tool:",
         " "
       ] });
   }
 }
-function MessageItem({ message }) {
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink.Box, { flexDirection: "column", marginBottom: 1, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink.Box, { children: [
-      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RoleLabel, { role: message.role }),
-      message.toolName && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_ink.Text, { color: "magenta", dimColor: true, children: [
-        "[",
-        message.toolName,
-        "]",
+function ToolMessage({ message }) {
+  if (!(0, import_agent_core2.isToolMessage)(message)) {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.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__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Box, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Box, { children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { color: "white", bold: true, children: [
+          "Tool:",
+          " "
+        ] }),
+        toolName && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { color: "white", dimColor: true, children: [
+          "[",
+          toolName,
+          "]"
+        ] })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Text, { children: " " }),
+      summaries.map((s, i) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Box, { flexDirection: "column", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { color: "green", children: [
+          "  ",
+          "\u2713",
+          " ",
+          s.line
+        ] }),
+        s.diffLines && s.diffLines.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(DiffBlock, { file: s.diffFile, lines: s.diffLines })
+      ] }, i))
+    ] });
+  }
+  const lines = content.split("\n").filter((l) => l.trim());
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Box, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { color: "white", bold: true, children: [
+        "Tool:",
         " "
+      ] }),
+      toolName && /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { color: "white", dimColor: true, children: [
+        "[",
+        toolName,
+        "]"
       ] })
     ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Text, { children: " " }),
-    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Text, { wrap: "wrap", children: message.role === "assistant" ? renderMarkdown(message.content) : message.content }) })
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Text, { children: " " }),
+    lines.map((line, i) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { color: "green", children: [
+      "  ",
+      "\u2713",
+      " ",
+      line
+    ] }, i))
+  ] });
+}
+var MessageItem = import_react3.default.memo(function MessageItem2({
+  message
+}) {
+  if ((0, import_agent_core2.isToolMessage)(message)) {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ToolMessage, { message });
+  }
+  const content = message.content ?? "";
+  const isInterrupted = message.state === "interrupted";
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(RoleLabel, { role: message.role }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Text, { children: " " }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Box, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Text, { wrap: "wrap", children: (0, import_agent_core2.isAssistantMessage)(message) ? renderMarkdown(content + (isInterrupted ? "\n\n_(interrupted)_" : "")) : content }) })
+  ] });
+});
+function ToolSummaryEntry({ entry }) {
+  const data = entry.data;
+  const lines = data?.summary?.split("\n") ?? [];
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { color: "white", bold: true, children: [
+      "Tool:",
+      " "
+    ] }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Text, { children: " " }),
+    lines.map((line, i) => /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { color: "green", children: [
+      "  ",
+      line
+    ] }, i))
+  ] });
+}
+function EventEntry({ entry }) {
+  const eventData = entry.data;
+  const eventMessage = typeof eventData?.message === "string" ? eventData.message : typeof eventData?.content === "string" ? eventData.content : entry.type;
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Box, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { color: "yellow", bold: true, children: [
+      "System:",
+      " "
+    ] }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Text, { children: " " }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Box, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Text, { wrap: "wrap", children: eventMessage }) })
   ] });
 }
-function MessageList({ messages }) {
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ink.Box, { flexDirection: "column", children: messages.map((msg) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MessageItem, { message: msg }, msg.id)) });
+function EntryItem({ entry }) {
+  if (entry.category === "chat") {
+    const message = entry.data;
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(MessageItem, { message });
+  }
+  if (entry.type === "tool-summary") {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ToolSummaryEntry, { entry });
+  }
+  if (entry.type === "tool-start" || entry.type === "tool-end") {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, {});
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(EventEntry, { entry });
+}
+function MessageList({ history }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Box, { flexDirection: "column", children: history.map((entry) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(EntryItem, { entry }, entry.id)) });
 }
 
 // src/ui/StatusBar.tsx
-var import_ink2 = require("ink");
-var import_jsx_runtime2 = require("react/jsx-runtime");
+var import_ink3 = require("ink");
+var import_agent_core3 = require("@robota-sdk/agent-core");
+var import_jsx_runtime3 = require("react/jsx-runtime");
 var CONTEXT_YELLOW_THRESHOLD = 70;
 var CONTEXT_RED_THRESHOLD = 90;
 function getContextColor(percentage) {
@@ -291,11 +845,12 @@ function StatusBar({
   isThinking,
   contextPercentage,
   contextUsedTokens,
-  contextMaxTokens
+  contextMaxTokens,
+  sessionName
 }) {
   const contextColor = getContextColor(contextPercentage);
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
-    import_ink2.Box,
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+    import_ink3.Box,
     {
       borderStyle: "single",
       borderColor: "gray",
@@ -303,26 +858,30 @@ function StatusBar({
       paddingRight: 1,
       justifyContent: "space-between",
       children: [
-        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { children: [
-          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Text, { color: "cyan", bold: true, children: "Mode:" }),
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_ink3.Text, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink3.Text, { color: "cyan", bold: true, children: "Mode:" }),
           " ",
-          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Text, { children: permissionMode }),
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink3.Text, { children: permissionMode }),
+          sessionName && /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_jsx_runtime3.Fragment, { children: [
+            "  |  ",
+            /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink3.Text, { color: "magenta", children: sessionName })
+          ] }),
           "  |  ",
-          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Text, { dimColor: true, children: modelName }),
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink3.Text, { dimColor: true, children: modelName }),
           "  |  ",
-          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { color: contextColor, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_ink3.Text, { color: contextColor, children: [
             "Context: ",
             Math.round(contextPercentage),
             "% (",
-            (contextUsedTokens / 1e3).toFixed(1),
-            "k/",
-            (contextMaxTokens / 1e3).toFixed(0),
-            "k)"
+            (0, import_agent_core3.formatTokenCount)(contextUsedTokens),
+            "/",
+            (0, import_agent_core3.formatTokenCount)(contextMaxTokens),
+            ")"
           ] })
         ] }),
-        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { children: [
-          isThinking && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Text, { color: "yellow", children: "Thinking... " }),
-          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_ink2.Text, { dimColor: true, children: [
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_ink3.Text, { children: [
+          isThinking && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink3.Text, { color: "yellow", children: "Thinking... " }),
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_ink3.Text, { dimColor: true, children: [
             "msgs: ",
             messageCount
           ] })
@@ -333,146 +892,222 @@ function StatusBar({
 }
 
 // src/ui/InputArea.tsx
-var import_react3 = __toESM(require("react"), 1);
-var import_ink6 = require("ink");
+var import_react6 = __toESM(require("react"), 1);
+var import_ink7 = require("ink");
 
 // src/ui/CjkTextInput.tsx
-var import_react = require("react");
-var import_ink3 = require("ink");
+var import_react4 = require("react");
+var import_ink4 = require("ink");
+var import_chalk = __toESM(require("chalk"), 1);
 var import_string_width = __toESM(require("string-width"), 1);
-var import_chalk2 = __toESM(require("chalk"), 1);
-var import_jsx_runtime3 = require("react/jsx-runtime");
+var import_jsx_runtime4 = require("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 = (0, import_string_width.default)(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 = (0, import_string_width.default)(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
+  showCursor = true,
+  availableWidth
 }) {
-  const valueRef = (0, import_react.useRef)(value);
-  const cursorRef = (0, import_react.useRef)(value.length);
-  const [, forceRender] = (0, import_react.useState)(0);
-  const { setCursorPosition } = (0, import_ink3.useCursor)();
+  const valueRef = (0, import_react4.useRef)(value);
+  const cursorRef = (0, import_react4.useRef)(value.length);
+  const [, forceRender] = (0, import_react4.useState)(0);
+  const isPastingRef = (0, import_react4.useRef)(false);
+  const pasteBufferRef = (0, import_react4.useRef)("");
   if (value !== valueRef.current) {
     valueRef.current = value;
-    if (cursorRef.current > value.length) {
-      cursorRef.current = value.length;
-    }
+    cursorRef.current = value.length;
   }
-  (0, import_ink3.useInput)(
+  (0, import_ink4.useInput)(
     (input, key) => {
-      if (key.upArrow || key.downArrow || key.ctrl && input === "c" || key.tab || key.shift && key.tab) {
-        return;
-      }
-      if (key.return) {
-        onSubmit?.(valueRef.current);
-        return;
-      }
-      if (key.leftArrow) {
-        if (cursorRef.current > 0) {
-          cursorRef.current -= 1;
-          forceRender((n) => n + 1);
+      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;
         }
-        return;
-      }
-      if (key.rightArrow) {
-        if (cursorRef.current < valueRef.current.length) {
-          cursorRef.current += 1;
-          forceRender((n) => n + 1);
+        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;
         }
-        return;
-      }
-      if (key.backspace || key.delete) {
-        if (cursorRef.current > 0) {
-          const v2 = valueRef.current;
-          const next2 = v2.slice(0, cursorRef.current - 1) + v2.slice(cursorRef.current);
-          cursorRef.current -= 1;
-          valueRef.current = next2;
-          onChange(next2);
+        if (key.ctrl && input === "c" || key.tab || key.shift && key.tab) {
+          return;
         }
-        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 {
       }
-      const v = valueRef.current;
-      const c = cursorRef.current;
-      const next = v.slice(0, c) + input + v.slice(c);
-      cursorRef.current = c + input.length;
-      valueRef.current = next;
-      onChange(next);
     },
     { isActive: focus }
   );
-  if (showCursor && focus) {
-    const textBeforeCursor = [...valueRef.current].slice(0, cursorRef.current).join("");
-    const cursorX = 4 + (0, import_string_width.default)(textBeforeCursor);
-    setCursorPosition({ x: cursorX, y: 0 });
-  }
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_ink3.Text, { children: renderWithCursor(valueRef.current, cursorRef.current, placeholder, showCursor && focus) });
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink4.Text, { children: renderWithCursor(valueRef.current, cursorRef.current, placeholder, showCursor && focus) });
 }
 function renderWithCursor(value, cursorOffset, placeholder, showCursor) {
   if (!showCursor) {
-    return value.length > 0 ? value : placeholder ? import_chalk2.default.gray(placeholder) : "";
+    return value.length > 0 ? value : placeholder ? import_chalk.default.gray(placeholder) : "";
   }
   if (value.length === 0) {
     if (placeholder.length > 0) {
-      return import_chalk2.default.inverse(placeholder[0]) + import_chalk2.default.gray(placeholder.slice(1));
+      return import_chalk.default.inverse(placeholder[0]) + import_chalk.default.gray(placeholder.slice(1));
     }
-    return import_chalk2.default.inverse(" ");
+    return import_chalk.default.inverse(" ");
   }
   const chars = [...value];
   let rendered = "";
   for (let i = 0; i < chars.length; i++) {
     const char = chars[i] ?? "";
-    rendered += i === cursorOffset ? import_chalk2.default.inverse(char) : char;
+    rendered += i === cursorOffset ? import_chalk.default.inverse(char) : char;
   }
   if (cursorOffset >= chars.length) {
-    rendered += import_chalk2.default.inverse(" ");
+    rendered += import_chalk.default.inverse(" ");
   }
   return rendered;
 }
 
 // src/ui/WaveText.tsx
-var import_react2 = require("react");
-var import_ink4 = require("ink");
-var import_jsx_runtime4 = require("react/jsx-runtime");
+var import_react5 = require("react");
+var import_ink5 = require("ink");
+var import_jsx_runtime5 = require("react/jsx-runtime");
 var WAVE_COLORS = ["#666666", "#888888", "#aaaaaa", "#888888"];
 var INTERVAL_MS = 400;
 var CHARS_PER_GROUP = 4;
 function WaveText({ text }) {
-  const [tick, setTick] = (0, import_react2.useState)(0);
-  (0, import_react2.useEffect)(() => {
+  const [tick, setTick] = (0, import_react5.useState)(0);
+  (0, import_react5.useEffect)(() => {
     const timer = setInterval(() => {
       setTick((prev) => prev + 1);
     }, INTERVAL_MS);
     return () => clearInterval(timer);
   }, []);
   const chars = [...text];
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink4.Text, { children: chars.map((char, i) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink5.Text, { children: chars.map((char, i) => {
     const group = Math.floor(i / CHARS_PER_GROUP);
     const colorIndex = (tick + group) % WAVE_COLORS.length;
-    return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_ink4.Text, { color: WAVE_COLORS[colorIndex], children: char }, i);
+    return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink5.Text, { color: WAVE_COLORS[colorIndex], children: char }, i);
   }) });
 }
 
 // src/ui/SlashAutocomplete.tsx
-var import_ink5 = require("ink");
-var import_jsx_runtime5 = require("react/jsx-runtime");
+var import_ink6 = require("ink");
+var import_jsx_runtime6 = require("react/jsx-runtime");
 var MAX_VISIBLE = 8;
 function CommandRow(props) {
   const { cmd, isSelected, showSlash } = props;
-  const prefix = showSlash ? "/" : "";
   const indicator = isSelected ? "\u25B8 " : "  ";
   const nameColor = isSelected ? "cyan" : void 0;
   const dimmed = !isSelected;
-  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_ink5.Box, { children: [
-    /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_ink5.Text, { color: nameColor, dimColor: dimmed, children: [
-      indicator,
-      prefix,
-      cmd.name
-    ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink5.Text, { dimColor: dimmed, children: "  " }),
-    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink5.Text, { color: nameColor, dimColor: dimmed, children: cmd.description })
-  ] });
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_ink6.Box, { children: /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_ink6.Text, { color: nameColor, dimColor: dimmed, children: [
+    indicator,
+    showSlash ? `/${cmd.name}  ${cmd.description}` : cmd.description
+  ] }) });
 }
 function SlashAutocomplete({
   commands,
@@ -483,7 +1118,7 @@ function SlashAutocomplete({
   if (!visible || commands.length === 0) return null;
   const scrollOffset = computeScrollOffset(selectedIndex, commands.length);
   const visibleCommands = commands.slice(scrollOffset, scrollOffset + MAX_VISIBLE);
-  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_ink5.Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: visibleCommands.map((cmd, i) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_ink6.Box, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, children: visibleCommands.map((cmd, i) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
     CommandRow,
     {
       cmd,
@@ -500,8 +1135,14 @@ function computeScrollOffset(selectedIndex, total) {
   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
-var import_jsx_runtime6 = require("react/jsx-runtime");
+var import_jsx_runtime7 = require("react/jsx-runtime");
 function parseSlashInput(value) {
   if (!value.startsWith("/")) return { isSlash: false, parentCommand: "", filter: "" };
   const afterSlash = value.slice(1);
@@ -512,16 +1153,16 @@ function parseSlashInput(value) {
   return { isSlash: true, parentCommand: parent, filter: rest };
 }
 function useAutocomplete(value, registry) {
-  const [selectedIndex, setSelectedIndex] = (0, import_react3.useState)(0);
-  const [dismissed, setDismissed] = (0, import_react3.useState)(false);
-  const prevValueRef = import_react3.default.useRef(value);
+  const [selectedIndex, setSelectedIndex] = (0, import_react6.useState)(0);
+  const [dismissed, setDismissed] = (0, import_react6.useState)(false);
+  const prevValueRef = import_react6.default.useRef(value);
   if (prevValueRef.current !== value) {
     prevValueRef.current = value;
     if (dismissed) setDismissed(false);
   }
   const parsed = parseSlashInput(value);
   const isSubcommandMode = parsed.isSlash && parsed.parentCommand.length > 0;
-  const filteredCommands = (0, import_react3.useMemo)(() => {
+  const filteredCommands = (0, import_react6.useMemo)(() => {
     if (!registry || !parsed.isSlash || dismissed) return [];
     if (isSubcommandMode) {
       const subs = registry.getSubcommands(parsed.parentCommand);
@@ -554,8 +1195,25 @@ function useAutocomplete(value, registry) {
     }
   };
 }
-function InputArea({ onSubmit, isDisabled, registry }) {
-  const [value, setValue] = (0, import_react3.useState)("");
+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,
+  sessionName
+}) {
+  const [value, setValue] = (0, import_react6.useState)("");
+  const pasteStore = (0, import_react6.useRef)(/* @__PURE__ */ new Map());
+  const { stdout } = (0, import_ink7.useStdout)();
+  const terminalColumns = stdout?.columns ?? 80;
+  const availableWidth = Math.max(1, terminalColumns - INPUT_AREA_OVERHEAD);
+  const pasteIdRef = (0, import_react6.useRef)(0);
   const {
     showPopup,
     filteredCommands,
@@ -564,20 +1222,31 @@ function InputArea({ onSubmit, isDisabled, registry }) {
     isSubcommandMode,
     setShowPopup
   } = useAutocomplete(value, registry);
-  const handleSubmit = (0, import_react3.useCallback)(
-    (text) => {
-      const trimmed = text.trim();
-      if (trimmed.length === 0) return;
-      if (showPopup && filteredCommands[selectedIndex]) {
-        selectCommand(filteredCommands[selectedIndex]);
+  const handlePaste = (0, import_react6.useCallback)((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 tabCompleteCommand = (0, import_react6.useCallback)(
+    (cmd) => {
+      const parsed = parseSlashInput(value);
+      if (parsed.parentCommand) {
+        setValue(`/${parsed.parentCommand} ${cmd.name} `);
         return;
       }
-      setValue("");
-      onSubmit(trimmed);
+      if (cmd.subcommands && cmd.subcommands.length > 0) {
+        setValue(`/${cmd.name} `);
+        setSelectedIndex(0);
+        return;
+      }
+      setValue(`/${cmd.name} `);
     },
-    [showPopup, filteredCommands, selectedIndex, onSubmit]
+    [value, setSelectedIndex]
   );
-  const selectCommand = (0, import_react3.useCallback)(
+  const enterSelectCommand = (0, import_react6.useCallback)(
     (cmd) => {
       const parsed = parseSlashInput(value);
       if (parsed.parentCommand) {
@@ -596,7 +1265,23 @@ function InputArea({ onSubmit, isDisabled, registry }) {
     },
     [value, onSubmit, setSelectedIndex]
   );
-  (0, import_ink6.useInput)(
+  const handleSubmit = (0, import_react6.useCallback)(
+    (text) => {
+      const trimmed = text.trim();
+      if (trimmed.length === 0) return;
+      if (showPopup && filteredCommands[selectedIndex]) {
+        enterSelectCommand(filteredCommands[selectedIndex]);
+        return;
+      }
+      const expanded = expandPasteLabels(trimmed, pasteStore.current);
+      setValue("");
+      pasteStore.current.clear();
+      pasteIdRef.current = 0;
+      onSubmit(expanded);
+    },
+    [showPopup, filteredCommands, selectedIndex, onSubmit, enterSelectCommand]
+  );
+  (0, import_ink7.useInput)(
     (_input, key) => {
       if (!showPopup) return;
       if (key.upArrow) {
@@ -607,13 +1292,32 @@ function InputArea({ onSubmit, isDisabled, registry }) {
         setShowPopup(false);
       } else if (key.tab) {
         const cmd = filteredCommands[selectedIndex];
-        if (cmd) selectCommand(cmd);
+        if (cmd) tabCompleteCommand(cmd);
       }
     },
     { isActive: showPopup && !isDisabled }
   );
-  return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_ink6.Box, { flexDirection: "column", children: [
-    showPopup && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+  (0, import_ink7.useInput)(
+    (_input, key) => {
+      if ((key.backspace || key.delete) && pendingPrompt) {
+        onCancelQueue?.();
+      }
+    },
+    { isActive: !!pendingPrompt }
+  );
+  const borderColor = isAborting ? "yellow" : pendingPrompt ? "cyan" : isDisabled ? "gray" : "green";
+  const innerWidth = Math.max(1, terminalColumns - BORDER_HORIZONTAL);
+  const topBorder = (() => {
+    if (sessionName) {
+      const label = ` "${sessionName}" `;
+      const rightPad = 2;
+      const leftLen = Math.max(0, innerWidth - label.length - rightPad);
+      return { left: "\u250C" + "\u2500".repeat(leftLen), label, right: "\u2500".repeat(rightPad) + "\u2510" };
+    }
+    return { left: "\u250C" + "\u2500".repeat(innerWidth), label: "", right: "\u2510" };
+  })();
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_ink7.Box, { flexDirection: "column", children: [
+    showPopup && /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
       SlashAutocomplete,
       {
         commands: filteredCommands,
@@ -622,41 +1326,97 @@ function InputArea({ onSubmit, isDisabled, registry }) {
         isSubcommandMode
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_ink6.Box, { borderStyle: "single", borderColor: isDisabled ? "gray" : "green", paddingLeft: 1, children: isDisabled ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(WaveText, { text: "  Waiting for response..." }) : /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_ink6.Box, { children: [
-      /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_ink6.Text, { color: "green", bold: true, children: "> " }),
-      /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_ink7.Text, { color: borderColor, children: [
+      topBorder.left,
+      topBorder.label ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_ink7.Text, { backgroundColor: borderColor, color: "black", bold: true, children: topBorder.label }) : null,
+      topBorder.right
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_ink7.Box, { borderStyle: "single", borderTop: false, borderColor, paddingLeft: 1, children: isAborting ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_ink7.Text, { color: "yellow", children: " Interrupting..." }) : pendingPrompt ? /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_ink7.Text, { color: "cyan", children: [
+      " ",
+      "Queued: ",
+      pendingPrompt.length > 50 ? pendingPrompt.slice(0, 47) + "..." : pendingPrompt,
+      " ",
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_ink7.Text, { dimColor: true, children: "(Backspace to cancel)" })
+    ] }) : isDisabled ? /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(WaveText, { text: "  Waiting for response... (ESC to interrupt)" }) : /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_ink7.Box, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_ink7.Text, { color: "green", bold: true, children: "> " }),
+      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
         CjkTextInput,
         {
           value,
           onChange: setValue,
           onSubmit: handleSubmit,
-          placeholder: "Type a message or /help"
+          onPaste: handlePaste,
+          placeholder: "Type a message or /help",
+          availableWidth
         }
       )
     ] }) })
   ] });
 }
 
+// src/ui/ConfirmPrompt.tsx
+var import_react7 = require("react");
+var import_ink8 = require("ink");
+var import_jsx_runtime8 = require("react/jsx-runtime");
+function ConfirmPrompt({
+  message,
+  options = ["Yes", "No"],
+  onSelect
+}) {
+  const [selected, setSelected] = (0, import_react7.useState)(0);
+  const resolvedRef = (0, import_react7.useRef)(false);
+  const doSelect = (0, import_react7.useCallback)(
+    (index) => {
+      if (resolvedRef.current) return;
+      resolvedRef.current = true;
+      onSelect(index);
+    },
+    [onSelect]
+  );
+  (0, import_ink8.useInput)((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__ */ (0, import_jsx_runtime8.jsxs)(import_ink8.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink8.Text, { color: "yellow", children: message }),
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink8.Box, { marginTop: 1, children: options.map((opt, i) => /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink8.Box, { marginRight: 2, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_ink8.Text, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
+      i === selected ? "> " : "  ",
+      opt
+    ] }) }, opt)) }),
+    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink8.Text, { dimColor: true, children: " arrow keys to select, Enter to confirm" })
+  ] });
+}
+
 // src/ui/PermissionPrompt.tsx
-var import_react4 = __toESM(require("react"), 1);
-var import_ink7 = require("ink");
-var import_jsx_runtime7 = require("react/jsx-runtime");
+var import_react8 = __toESM(require("react"), 1);
+var import_ink9 = require("ink");
+var import_jsx_runtime9 = require("react/jsx-runtime");
 var OPTIONS = ["Allow", "Allow always (this session)", "Deny"];
-function formatArgs2(args) {
+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] = import_react4.default.useState(0);
-  const resolvedRef = import_react4.default.useRef(false);
-  const prevRequestRef = import_react4.default.useRef(request);
+  const [selected, setSelected] = import_react8.default.useState(0);
+  const resolvedRef = import_react8.default.useRef(false);
+  const prevRequestRef = import_react8.default.useRef(request);
   if (prevRequestRef.current !== request) {
     prevRequestRef.current = request;
     resolvedRef.current = false;
     setSelected(0);
   }
-  const doResolve = import_react4.default.useCallback(
+  const doResolve = import_react8.default.useCallback(
     (index) => {
       if (resolvedRef.current) return;
       resolvedRef.current = true;
@@ -666,7 +1426,7 @@ function PermissionPrompt({ request }) {
     },
     [request]
   );
-  (0, import_ink7.useInput)((input, key) => {
+  (0, import_ink9.useInput)((input, key) => {
     if (resolvedRef.current) return;
     if (key.upArrow || key.leftArrow) {
       setSelected((prev) => prev > 0 ? prev - 1 : prev);
@@ -682,364 +1442,857 @@ function PermissionPrompt({ request }) {
       doResolve(2);
     }
   });
-  return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_ink7.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_ink7.Text, { color: "yellow", bold: true, children: "[Permission Required]" }),
-    /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_ink7.Text, { children: [
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_ink9.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink9.Text, { color: "yellow", bold: true, children: "[Permission Required]" }),
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_ink9.Text, { children: [
       "Tool:",
       " ",
-      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_ink7.Text, { color: "cyan", bold: true, children: request.toolName })
+      /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink9.Text, { color: "cyan", bold: true, children: request.toolName })
     ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_ink7.Text, { dimColor: true, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_ink9.Text, { dimColor: true, children: [
       " ",
-      formatArgs2(request.toolArgs)
+      formatArgs(request.toolArgs)
     ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_ink7.Box, { marginTop: 1, children: OPTIONS.map((opt, i) => /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_ink7.Box, { marginRight: 2, children: /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_ink7.Text, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink9.Box, { marginTop: 1, children: OPTIONS.map((opt, i) => /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink9.Box, { marginRight: 2, children: /* @__PURE__ */ (0, import_jsx_runtime9.jsxs)(import_ink9.Text, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
       i === selected ? "> " : "  ",
       opt
     ] }) }, opt)) }),
-    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_ink7.Text, { dimColor: true, children: " left/right to select, Enter to confirm" })
+    /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_ink9.Text, { dimColor: true, children: " left/right to select, Enter to confirm" })
   ] });
 }
 
-// src/ui/App.tsx
-var import_jsx_runtime8 = require("react/jsx-runtime");
-var msgIdCounter = 0;
-function nextId() {
-  msgIdCounter += 1;
-  return `msg_${msgIdCounter}`;
+// src/ui/StreamingIndicator.tsx
+var import_ink10 = require("ink");
+var import_jsx_runtime10 = require("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 };
 }
-var NOOP_TERMINAL = {
-  write: () => {
-  },
-  writeLine: () => {
-  },
-  writeMarkdown: () => {
-  },
-  writeError: () => {
-  },
-  prompt: () => Promise.resolve(""),
-  select: () => Promise.resolve(0),
-  spinner: () => ({ stop: () => {
-  }, update: () => {
-  } })
-};
-function useSession(props) {
-  const [permissionRequest, setPermissionRequest] = (0, import_react5.useState)(null);
-  const [streamingText, setStreamingText] = (0, import_react5.useState)("");
-  const permissionQueueRef = (0, import_react5.useRef)([]);
-  const processingRef = (0, import_react5.useRef)(false);
-  const processNextPermission = (0, import_react5.useCallback)(() => {
-    if (processingRef.current) return;
-    const next = permissionQueueRef.current[0];
-    if (!next) {
-      setPermissionRequest(null);
-      return;
-    }
-    processingRef.current = true;
-    setPermissionRequest({
-      toolName: next.toolName,
-      toolArgs: next.toolArgs,
-      resolve: (result) => {
-        permissionQueueRef.current.shift();
-        processingRef.current = false;
-        setPermissionRequest(null);
-        next.resolve(result);
-        setTimeout(() => processNextPermission(), 0);
-      }
-    });
-  }, []);
-  const sessionRef = (0, import_react5.useRef)(null);
-  if (sessionRef.current === null) {
-    const permissionHandler = (toolName, toolArgs) => {
-      return new Promise((resolve) => {
-        permissionQueueRef.current.push({ toolName, toolArgs, resolve });
-        processNextPermission();
-      });
-    };
-    const onTextDelta = (delta) => {
-      setStreamingText((prev) => prev + delta);
-    };
-    const paths = (0, import_agent_sdk.projectPaths)(props.cwd ?? process.cwd());
-    sessionRef.current = (0, import_agent_sdk.createSession)({
-      config: props.config,
-      context: props.context,
-      terminal: NOOP_TERMINAL,
-      sessionLogger: new import_agent_sdk.FileSessionLogger(paths.logs),
-      projectInfo: props.projectInfo,
-      sessionStore: props.sessionStore,
-      permissionMode: props.permissionMode,
-      maxTurns: props.maxTurns,
-      permissionHandler,
-      onTextDelta
-    });
-  }
-  const clearStreamingText = (0, import_react5.useCallback)(() => setStreamingText(""), []);
-  return { session: sessionRef.current, permissionRequest, streamingText, clearStreamingText };
-}
-function useMessages() {
-  const [messages, setMessages] = (0, import_react5.useState)([]);
-  const addMessage = (0, import_react5.useCallback)((msg) => {
-    setMessages((prev) => [...prev, { ...msg, id: nextId(), timestamp: /* @__PURE__ */ new Date() }]);
-  }, []);
-  return { messages, setMessages, addMessage };
-}
-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",
-  "  /cost              \u2014 Show session info",
-  "  /exit              \u2014 Exit CLI"
-].join("\n");
-function handleModeCommand(arg, session, addMessage) {
-  const validModes = ["plan", "default", "acceptEdits", "bypassPermissions"];
-  if (!arg) {
-    addMessage({ role: "system", content: `Current mode: ${session.getPermissionMode()}` });
-  } else if (validModes.includes(arg)) {
-    session.setPermissionMode(arg);
-    addMessage({ role: "system", content: `Permission mode set to: ${arg}` });
-  } else {
-    addMessage({ role: "system", content: `Invalid mode. Valid: ${validModes.join(" | ")}` });
+function StreamingIndicator({ text, activeTools }) {
+  const hasTools = activeTools.length > 0;
+  const hasText = text.length > 0;
+  if (!hasTools && !hasText) {
+    return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_jsx_runtime10.Fragment, {});
   }
-  return true;
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_ink10.Box, { flexDirection: "column", children: [
+    hasTools && /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_ink10.Box, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink10.Text, { color: "white", bold: true, children: "Tools:" }),
+      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink10.Text, { children: " " }),
+      activeTools.map((t, i) => {
+        const { color, icon, strikethrough } = getToolStyle(t);
+        return /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_ink10.Box, { flexDirection: "column", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_ink10.Text, { color, strikethrough, children: [
+            "  ",
+            icon,
+            " ",
+            t.toolName,
+            "(",
+            t.firstArg,
+            ")"
+          ] }),
+          t.diffLines && t.diffLines.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(DiffBlock, { file: t.diffFile, lines: t.diffLines })
+        ] }, `${t.toolName}-${i}`);
+      })
+    ] }),
+    hasText && /* @__PURE__ */ (0, import_jsx_runtime10.jsxs)(import_ink10.Box, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink10.Text, { color: "cyan", bold: true, children: "Robota:" }),
+      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink10.Text, { children: " " }),
+      /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink10.Box, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(import_ink10.Text, { wrap: "wrap", children: renderMarkdown(text) }) })
+    ] })
+  ] });
 }
-async function executeSlashCommand(cmd, parts, session, addMessage, setMessages, exit, registry) {
-  switch (cmd) {
-    case "help":
-      addMessage({ role: "system", content: HELP_TEXT });
-      return true;
-    case "clear":
-      setMessages([]);
-      session.clearHistory();
-      addMessage({ role: "system", content: "Conversation cleared." });
-      return true;
-    case "compact": {
-      const instructions = parts.slice(1).join(" ").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 true;
+
+// src/ui/PluginTUI.tsx
+var import_react11 = require("react");
+
+// src/ui/MenuSelect.tsx
+var import_react9 = require("react");
+var import_ink11 = require("ink");
+var import_jsx_runtime11 = require("react/jsx-runtime");
+function MenuSelect({
+  title,
+  items,
+  onSelect,
+  onBack,
+  loading,
+  error
+}) {
+  const [selected, setSelected] = (0, import_react9.useState)(0);
+  const selectedRef = (0, import_react9.useRef)(0);
+  const resolvedRef = (0, import_react9.useRef)(false);
+  const doSelect = (0, import_react9.useCallback)(
+    (index) => {
+      if (resolvedRef.current || items.length === 0) return;
+      resolvedRef.current = true;
+      onSelect(items[index].value);
+    },
+    [items, onSelect]
+  );
+  (0, import_ink11.useInput)((input, key) => {
+    if (resolvedRef.current) return;
+    if (key.escape) {
+      resolvedRef.current = true;
+      onBack();
+      return;
     }
-    case "mode":
-      return handleModeCommand(parts[1], session, addMessage);
-    case "cost":
-      addMessage({
-        role: "system",
-        content: `Session: ${session.getSessionId()}
-Messages: ${session.getMessageCount()}`
-      });
-      return true;
-    case "permissions": {
-      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.");
+    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__ */ (0, import_jsx_runtime11.jsxs)(import_ink11.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Text, { color: "yellow", bold: true, children: title }),
+    loading && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Box, { marginTop: 1, children: /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Text, { dimColor: true, children: "Loading..." }) }),
+    error && /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_ink11.Box, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Text, { color: "red", children: error }),
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Text, { dimColor: true, children: "Press Esc to go back" })
+    ] }),
+    !loading && !error && /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Box, { flexDirection: "column", marginTop: 1, children: items.map((item, i) => /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_ink11.Box, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_ink11.Text, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
+        i === selected ? "> " : "  ",
+        item.label
+      ] }),
+      item.hint && /* @__PURE__ */ (0, import_jsx_runtime11.jsxs)(import_ink11.Text, { dimColor: true, children: [
+        " ",
+        item.hint
+      ] })
+    ] }, item.value)) }),
+    /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(import_ink11.Text, { dimColor: true, children: loading || error ? "" : " \u2191\u2193 Navigate  Enter Select  Esc Back" })
+  ] });
+}
+
+// src/ui/TextPrompt.tsx
+var import_react10 = require("react");
+var import_ink12 = require("ink");
+var import_jsx_runtime12 = require("react/jsx-runtime");
+function TextPrompt({
+  title,
+  placeholder,
+  onSubmit,
+  onCancel,
+  validate
+}) {
+  const [value, setValue] = (0, import_react10.useState)("");
+  const [error, setError] = (0, import_react10.useState)();
+  const resolvedRef = (0, import_react10.useRef)(false);
+  const valueRef = (0, import_react10.useRef)("");
+  const handleSubmit = (0, import_react10.useCallback)(() => {
+    if (resolvedRef.current) return;
+    const trimmed = valueRef.current.trim();
+    if (!trimmed) return;
+    if (validate) {
+      const err = validate(trimmed);
+      if (err) {
+        setError(err);
+        return;
       }
-      addMessage({ role: "system", content: lines.join("\n") });
-      return true;
     }
-    case "context": {
-      const ctx = session.getContextState();
-      addMessage({
-        role: "system",
-        content: `Context: ${ctx.usedTokens.toLocaleString()} / ${ctx.maxTokens.toLocaleString()} tokens (${Math.round(ctx.usedPercentage)}%)`
-      });
-      return true;
+    resolvedRef.current = true;
+    onSubmit(trimmed);
+  }, [validate, onSubmit]);
+  (0, import_ink12.useInput)((input, key) => {
+    if (resolvedRef.current) return;
+    if (key.escape) {
+      resolvedRef.current = true;
+      onCancel();
+      return;
     }
-    case "exit":
-      exit();
-      return true;
-    default: {
-      const skillCmd = registry.getCommands().find((c) => c.name === cmd && c.source === "skill");
-      if (skillCmd) {
-        addMessage({ role: "system", content: `Invoking skill: ${cmd}` });
-        return false;
-      }
-      addMessage({ role: "system", content: `Unknown command "/${cmd}". Type /help for help.` });
-      return true;
+    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__ */ (0, import_jsx_runtime12.jsxs)(import_ink12.Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Text, { color: "yellow", bold: true, children: title }),
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsxs)(import_ink12.Box, { marginTop: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Text, { color: "cyan", children: "> " }),
+      value ? /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Text, { children: value }) : placeholder ? /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Text, { dimColor: true, children: placeholder }) : null,
+      /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Text, { color: "cyan", children: "\u2588" })
+    ] }),
+    error && /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Text, { color: "red", children: error }),
+    /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(import_ink12.Text, { 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 useSlashCommands(session, addMessage, setMessages, exit, registry) {
-  return (0, import_react5.useCallback)(
-    async (input) => {
-      const parts = input.slice(1).split(/\s+/);
-      const cmd = parts[0]?.toLowerCase() ?? "";
-      return executeSlashCommand(cmd, parts, session, addMessage, setMessages, exit, registry);
-    },
-    [session, addMessage, setMessages, exit, registry]
-  );
+function handleMarketplaceListSelect(value, nav) {
+  if (value === "__add__") {
+    nav.push({ screen: "marketplace-add" });
+  } else {
+    nav.push({ screen: "marketplace-action", context: { marketplace: value } });
+  }
 }
-function StreamingIndicator({ text }) {
-  if (text) {
-    return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_ink8.Box, { flexDirection: "column", children: [
-      /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_ink8.Text, { color: "cyan", bold: true, children: [
-        "Robota:",
-        " "
-      ] }),
-      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink8.Text, { children: " " }),
-      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink8.Box, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink8.Text, { wrap: "wrap", children: renderMarkdown(text) }) })
-    ] });
+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)
+    });
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink8.Text, { color: "yellow", children: "Thinking..." });
 }
-async function runSessionPrompt(prompt, session, addMessage, clearStreamingText, setIsThinking, setContextPercentage) {
-  setIsThinking(true);
-  clearStreamingText();
-  try {
-    const response = await session.run(prompt);
-    clearStreamingText();
-    addMessage({ role: "assistant", content: response || "(empty response)" });
-    setContextPercentage(session.getContextState().usedPercentage);
-  } catch (err) {
-    clearStreamingText();
-    if (err instanceof DOMException && err.name === "AbortError") {
-      addMessage({ role: "system", content: "Cancelled." });
-    } else {
-      const errMsg = err instanceof Error ? err.message : String(err);
-      addMessage({ role: "system", content: `Error: ${errMsg}` });
-    }
-  } finally {
-    setIsThinking(false);
+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 buildSkillPrompt(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");
-  if (!skillCmd) return null;
-  const args = parts.slice(1).join(" ").trim();
-  return args ? `Use the "${cmd}" skill: ${args}` : `Use the "${cmd}" skill: ${skillCmd.description}`;
+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 useSubmitHandler(session, addMessage, handleSlashCommand, clearStreamingText, setIsThinking, setContextPercentage, registry) {
-  return (0, import_react5.useCallback)(
-    async (input) => {
-      if (input.startsWith("/")) {
-        const handled = await handleSlashCommand(input);
-        if (handled) {
-          setContextPercentage(session.getContextState().usedPercentage);
-          return;
+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
+var import_jsx_runtime13 = require("react/jsx-runtime");
+function PluginTUI({ callbacks, onClose, addMessage }) {
+  const [stack, setStack] = (0, import_react11.useState)([{ screen: "main" }]);
+  const [items, setItems] = (0, import_react11.useState)([]);
+  const [loading, setLoading] = (0, import_react11.useState)(false);
+  const [error, setError] = (0, import_react11.useState)();
+  const [confirm, setConfirm] = (0, import_react11.useState)();
+  const [refreshCounter, setRefreshCounter] = (0, import_react11.useState)(0);
+  const current = stack[stack.length - 1] ?? { screen: "main" };
+  const push = (0, import_react11.useCallback)((state) => {
+    setStack((prev) => [...prev, state]);
+    setItems([]);
+    setError(void 0);
+  }, []);
+  const pop = (0, import_react11.useCallback)(() => {
+    setStack((prev) => {
+      if (prev.length <= 1) {
+        onClose();
+        return prev;
+      }
+      return prev.slice(0, -1);
+    });
+    setItems([]);
+    setError(void 0);
+  }, [onClose]);
+  const popN = (0, import_react11.useCallback)(
+    (n) => {
+      setStack((prev) => {
+        const next = prev.slice(0, Math.max(1, prev.length - n));
+        if (next.length === 0) {
+          onClose();
+          return prev;
         }
-        const prompt = buildSkillPrompt(input, registry);
-        if (!prompt) return;
-        return runSessionPrompt(
-          prompt,
-          session,
-          addMessage,
-          clearStreamingText,
-          setIsThinking,
-          setContextPercentage
+        return next;
+      });
+      setItems([]);
+      setError(void 0);
+    },
+    [onClose]
+  );
+  const notify = (0, import_react11.useCallback)(
+    (content) => {
+      addMessage?.({ role: "system", content });
+    },
+    [addMessage]
+  );
+  const refresh = (0, import_react11.useCallback)(() => {
+    setItems([]);
+    setRefreshCounter((c) => c + 1);
+  }, []);
+  const nav = { push, pop, popN, notify, setConfirm, refresh };
+  (0, import_react11.useEffect)(() => {
+    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 = (0, import_react11.useCallback)(
+    (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 = (0, import_react11.useCallback)(
+    (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();
+        });
       }
-      addMessage({ role: "user", content: input });
-      return runSessionPrompt(
-        input,
-        session,
-        addMessage,
-        clearStreamingText,
-        setIsThinking,
-        setContextPercentage
-      );
     },
-    [
-      session,
-      addMessage,
-      handleSlashCommand,
-      clearStreamingText,
-      setIsThinking,
-      setContextPercentage,
-      registry
+    [current.screen, callbacks, notify, pop]
+  );
+  if (confirm) {
+    return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+      ConfirmPrompt,
+      {
+        message: confirm.message,
+        onSelect: (index) => {
+          if (index === 0) confirm.onConfirm();
+          else confirm.onCancel();
+        }
+      }
+    );
+  }
+  const screen = current.screen;
+  if (screen === "marketplace-add") {
+    return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
+      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__ */ (0, import_jsx_runtime13.jsx)(
+      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__ */ (0, import_jsx_runtime13.jsx)(
+      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__ */ (0, import_jsx_runtime13.jsx)(
+      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__ */ (0, import_jsx_runtime13.jsx)(
+    MenuSelect,
+    {
+      title: titleMap[screen] ?? "Plugin Management",
+      items: staticItemsMap[screen] ?? items,
+      onSelect: handleSelect,
+      onBack: pop,
+      loading,
+      error
+    },
+    `${screen}-${stack.length}-${refreshCounter}`
   );
 }
-function useCommandRegistry(cwd) {
-  const registryRef = (0, import_react5.useRef)(null);
-  if (registryRef.current === null) {
-    const registry = new CommandRegistry();
-    registry.addSource(new BuiltinCommandSource());
-    registry.addSource(new SkillCommandSource(cwd));
-    registryRef.current = registry;
+
+// src/ui/ListPicker.tsx
+var import_react12 = require("react");
+var import_ink13 = require("ink");
+var import_jsx_runtime14 = require("react/jsx-runtime");
+var DEFAULT_MAX_VISIBLE = 3;
+function ListPicker({
+  items,
+  renderItem,
+  onSelect,
+  onCancel,
+  maxVisible = DEFAULT_MAX_VISIBLE
+}) {
+  const [selectedIndex, setSelectedIndex] = (0, import_react12.useState)(0);
+  const [scrollOffset, setScrollOffset] = (0, import_react12.useState)(0);
+  const selectedRef = (0, import_react12.useRef)(0);
+  const resolvedRef = (0, import_react12.useRef)(false);
+  (0, import_ink13.useInput)((_input, key) => {
+    if (resolvedRef.current) return;
+    if (key.escape) {
+      resolvedRef.current = true;
+      onCancel();
+      return;
+    }
+    if (items.length === 0) return;
+    if (key.upArrow) {
+      const next = selectedRef.current > 0 ? selectedRef.current - 1 : selectedRef.current;
+      selectedRef.current = next;
+      setSelectedIndex(next);
+      if (next < scrollOffset) {
+        setScrollOffset(next);
+      }
+    } else if (key.downArrow) {
+      const next = selectedRef.current < items.length - 1 ? selectedRef.current + 1 : selectedRef.current;
+      selectedRef.current = next;
+      setSelectedIndex(next);
+      if (next >= scrollOffset + maxVisible) {
+        setScrollOffset(next - maxVisible + 1);
+      }
+    } else if (key.return) {
+      const item = items[selectedRef.current];
+      if (item !== void 0) {
+        resolvedRef.current = true;
+        onSelect(item);
+      }
+    }
+  });
+  if (items.length === 0) {
+    return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_ink13.Box, {});
   }
-  return registryRef.current;
+  const visibleItems = items.slice(scrollOffset, scrollOffset + maxVisible);
+  const hasMore = scrollOffset + maxVisible < items.length;
+  const hasLess = scrollOffset > 0;
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_ink13.Box, { flexDirection: "column", children: [
+    hasLess && /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_ink13.Text, { dimColor: true, children: [
+      " \u2191 ",
+      scrollOffset,
+      " more above"
+    ] }),
+    visibleItems.map((item, index) => /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_ink13.Box, { marginBottom: 1, children: renderItem(item, scrollOffset + index === selectedIndex) }, scrollOffset + index)),
+    hasMore && /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_ink13.Text, { dimColor: true, children: [
+      " \u2193 ",
+      items.length - scrollOffset - maxVisible,
+      " more below"
+    ] })
+  ] });
 }
+
+// src/ui/App.tsx
+var import_jsx_runtime15 = require("react/jsx-runtime");
+var EXIT_DELAY_MS = 500;
+var SESSION_ID_DISPLAY_LENGTH = 8;
 function App(props) {
-  const { exit } = (0, import_ink8.useApp)();
-  const { session, permissionRequest, streamingText, clearStreamingText } = useSession(props);
-  const { messages, setMessages, addMessage } = useMessages();
-  const [isThinking, setIsThinking] = (0, import_react5.useState)(false);
-  const [contextPercentage, setContextPercentage] = (0, import_react5.useState)(0);
-  const registry = useCommandRegistry(props.cwd ?? process.cwd());
-  const handleSlashCommand = useSlashCommands(session, addMessage, setMessages, exit, registry);
-  const handleSubmit = useSubmitHandler(
-    session,
-    addMessage,
-    handleSlashCommand,
-    clearStreamingText,
-    setIsThinking,
-    setContextPercentage,
-    registry
+  const [activeSessionId, setActiveSessionId] = (0, import_react13.useState)(props.resumeSessionId);
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+    AppInner,
+    {
+      ...props,
+      resumeSessionId: activeSessionId,
+      onSessionSwitch: (sessionId) => setActiveSessionId(sessionId)
+    },
+    activeSessionId ?? "__new__"
   );
-  (0, import_ink8.useInput)(
+}
+function AppInner(props) {
+  const { exit } = (0, import_ink14.useApp)();
+  const cwd = props.cwd;
+  const {
+    interactiveSession,
+    registry,
+    history,
+    addEntry,
+    streamingText,
+    activeTools,
+    isThinking,
+    isAborting,
+    pendingPrompt,
+    permissionRequest,
+    contextState,
+    handleSubmit: baseHandleSubmit,
+    handleAbort,
+    handleCancelQueue
+  } = useInteractiveSession({
+    cwd,
+    provider: props.provider,
+    permissionMode: props.permissionMode,
+    maxTurns: props.maxTurns,
+    sessionStore: props.sessionStore,
+    resumeSessionId: props.resumeSessionId,
+    forkSession: props.forkSession,
+    sessionName: props.sessionName
+  });
+  const pluginCallbacks = usePluginCallbacks(cwd);
+  const [pendingModelId, setPendingModelId] = (0, import_react13.useState)(null);
+  const pendingModelChangeRef = (0, import_react13.useRef)(null);
+  const [showPluginTUI, setShowPluginTUI] = (0, import_react13.useState)(false);
+  const [showSessionPicker, setShowSessionPicker] = (0, import_react13.useState)(
+    props.resumeSessionId === "__picker__"
+  );
+  const [sessionName, setSessionName] = (0, import_react13.useState)(props.sessionName);
+  (0, import_react13.useEffect)(() => {
+    const name = interactiveSession?.getName?.();
+    if (name && !sessionName) setSessionName(name);
+  }, [interactiveSession, sessionName]);
+  (0, import_react13.useEffect)(() => {
+    const title = sessionName ? `Robota \u2014 ${sessionName}` : "Robota";
+    process.stdout.write(`\x1B]0;${title}\x07`);
+  }, [sessionName]);
+  const handleSubmit = async (input) => {
+    await baseHandleSubmit(input);
+    const sideEffects = interactiveSession;
+    if (sideEffects._pendingModelId) {
+      const modelId = sideEffects._pendingModelId;
+      delete sideEffects._pendingModelId;
+      pendingModelChangeRef.current = modelId;
+      setPendingModelId(modelId);
+      return;
+    }
+    if (sideEffects._pendingLanguage) {
+      const lang = sideEffects._pendingLanguage;
+      delete sideEffects._pendingLanguage;
+      const settingsPath = getUserSettingsPath();
+      const settings = readSettings(settingsPath);
+      settings.language = lang;
+      writeSettings(settingsPath, settings);
+      addEntry(
+        (0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)(`Language set to "${lang}". Restarting...`))
+      );
+      setTimeout(() => exit(), EXIT_DELAY_MS);
+      return;
+    }
+    if (sideEffects._resetRequested) {
+      delete sideEffects._resetRequested;
+      const settingsPath = getUserSettingsPath();
+      if (deleteSettings(settingsPath)) {
+        addEntry((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)(`Deleted ${settingsPath}. Exiting...`)));
+      } else {
+        addEntry((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)("No user settings found.")));
+      }
+      setTimeout(() => exit(), EXIT_DELAY_MS);
+      return;
+    }
+    if (sideEffects._exitRequested) {
+      delete sideEffects._exitRequested;
+      setTimeout(() => exit(), EXIT_DELAY_MS);
+      return;
+    }
+    if (sideEffects._triggerPluginTUI) {
+      delete sideEffects._triggerPluginTUI;
+      setShowPluginTUI(true);
+      return;
+    }
+    if (sideEffects._triggerResumePicker) {
+      delete sideEffects._triggerResumePicker;
+      setShowSessionPicker(true);
+      return;
+    }
+    if (sideEffects._sessionName) {
+      const name = sideEffects._sessionName;
+      delete sideEffects._sessionName;
+      interactiveSession.setName(name);
+      setSessionName(name);
+      return;
+    }
+  };
+  (0, import_ink14.useInput)(
     (_input, key) => {
-      if (key.ctrl && _input === "c") exit();
-      if (key.escape && isThinking) session.abort();
+      if (key.escape && isThinking) {
+        handleAbort();
+      }
     },
-    { isActive: !permissionRequest }
+    { isActive: !permissionRequest && !showPluginTUI && !showSessionPicker }
   );
-  return /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_ink8.Box, { flexDirection: "column", children: [
-    /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_ink8.Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink8.Text, { color: "cyan", bold: true, children: `
+  let permissionMode = props.permissionMode ?? "default";
+  let sessionId = "";
+  try {
+    const session = interactiveSession.getSession();
+    permissionMode = session.getPermissionMode();
+    sessionId = session.getSessionId();
+  } catch {
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_ink14.Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_ink14.Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Text, { color: "cyan", bold: true, children: `
   ____   ___  ____   ___ _____  _
  |  _ \\ / _ \\| __ ) / _ \\_   _|/ \\
  | |_) | | | |  _ \\| | | || | / _ \\
  |  _ <| |_| | |_) | |_| || |/ ___ \\
  |_| \\_\\\\___/|____/ \\___/ |_/_/   \\_\\
 ` }),
-      /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_ink8.Text, { dimColor: true, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_ink14.Text, { dimColor: true, children: [
         " v",
         props.version ?? "0.0.0"
       ] })
     ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime8.jsxs)(import_ink8.Box, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(MessageList, { messages }),
-      isThinking && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_ink8.Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(StreamingIndicator, { text: streamingText }) })
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_ink14.Box, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(MessageList, { history }),
+      (isThinking || activeTools.length > 0) && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(StreamingIndicator, { text: streamingText, activeTools }) })
     ] }),
-    permissionRequest && /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(PermissionPrompt, { request: permissionRequest }),
-    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+    permissionRequest && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(PermissionPrompt, { request: permissionRequest }),
+    pendingModelId && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+      ConfirmPrompt,
+      {
+        message: `Change model to ${(0, import_agent_core4.getModelName)(pendingModelId)}? This will restart the session.`,
+        onSelect: (index) => {
+          setPendingModelId(null);
+          pendingModelChangeRef.current = null;
+          if (index === 0) {
+            try {
+              const settingsPath = getUserSettingsPath();
+              updateModelInSettings(settingsPath, pendingModelId);
+              addEntry(
+                (0, import_agent_core4.messageToHistoryEntry)(
+                  (0, import_agent_core4.createSystemMessage)(
+                    `Model changed to ${(0, import_agent_core4.getModelName)(pendingModelId)}. Restarting...`
+                  )
+                )
+              );
+              setTimeout(() => exit(), EXIT_DELAY_MS);
+            } catch (err) {
+              addEntry(
+                (0, import_agent_core4.messageToHistoryEntry)(
+                  (0, import_agent_core4.createSystemMessage)(
+                    `Failed: ${err instanceof Error ? err.message : String(err)}`
+                  )
+                )
+              );
+            }
+          } else {
+            addEntry((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)("Model change cancelled.")));
+          }
+        }
+      }
+    ),
+    showPluginTUI && /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+      PluginTUI,
+      {
+        callbacks: pluginCallbacks,
+        onClose: () => setShowPluginTUI(false),
+        addMessage: (msg) => addEntry((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)(msg.content)))
+      }
+    ),
+    showSessionPicker && /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_ink14.Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Text, { bold: true, color: "cyan", children: "Select a session to resume (ESC to cancel):" }),
+      /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
+        ListPicker,
+        {
+          items: (props.sessionStore?.list() ?? []).filter((s) => s.cwd === props.cwd),
+          renderItem: (session, isSelected) => {
+            const lastMsg = session.messages.slice().reverse().find((m) => {
+              const msg = m;
+              return msg.role === "assistant" && msg.content;
+            });
+            const rawPreview = lastMsg?.content?.replace(/[\n\r]+/g, " ").trim() ?? "";
+            const preview = rawPreview ? rawPreview.slice(0, 60) + (rawPreview.length > 60 ? "..." : "") : "";
+            return /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_ink14.Text, { children: [
+              isSelected ? "> " : "  ",
+              /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Text, { bold: true, children: session.name ?? session.id.slice(0, SESSION_ID_DISPLAY_LENGTH) }),
+              "  ",
+              /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Text, { dimColor: true, children: new Date(session.updatedAt).toLocaleString(void 0, {
+                month: "short",
+                day: "numeric",
+                hour: "2-digit",
+                minute: "2-digit"
+              }) }),
+              "  ",
+              /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_ink14.Text, { dimColor: true, children: [
+                "msgs: ",
+                session.messages.length
+              ] }),
+              preview ? /* @__PURE__ */ (0, import_jsx_runtime15.jsxs)(import_jsx_runtime15.Fragment, { children: [
+                "\n    ",
+                /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Text, { color: "gray", children: preview })
+              ] }) : null
+            ] });
+          },
+          onSelect: (session) => {
+            setShowSessionPicker(false);
+            props.onSessionSwitch(session.id);
+          },
+          onCancel: () => {
+            setShowSessionPicker(false);
+            addEntry((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)("Session resume cancelled.")));
+          }
+        }
+      )
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
       StatusBar,
       {
-        permissionMode: session.getPermissionMode(),
-        modelName: props.config.provider.model,
-        sessionId: session.getSessionId(),
-        messageCount: messages.length,
+        permissionMode,
+        modelName: props.modelId ? (0, import_agent_core4.getModelName)(props.modelId) : "",
+        sessionId,
+        messageCount: history.length,
         isThinking,
-        contextPercentage,
-        contextUsedTokens: session.getContextState().usedTokens,
-        contextMaxTokens: session.getContextState().maxTokens
+        contextPercentage: contextState.percentage,
+        contextUsedTokens: contextState.usedTokens,
+        contextMaxTokens: contextState.maxTokens,
+        sessionName
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(
       InputArea,
       {
         onSubmit: handleSubmit,
-        isDisabled: isThinking || !!permissionRequest,
-        registry
+        onCancelQueue: handleCancelQueue,
+        isDisabled: !!permissionRequest || showPluginTUI || showSessionPicker || isThinking && !!pendingPrompt,
+        isAborting,
+        pendingPrompt,
+        registry,
+        sessionName
       }
-    )
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_ink14.Text, { children: " " })
   ] });
 }
 
 // src/ui/render.tsx
-var import_jsx_runtime9 = require("react/jsx-runtime");
+var import_jsx_runtime16 = require("react/jsx-runtime");
 function renderApp(options) {
   process.on("unhandledRejection", (reason) => {
     process.stderr.write(`
@@ -1050,29 +2303,50 @@ function renderApp(options) {
 `);
     }
   });
-  const instance = (0, import_ink9.render)(/* @__PURE__ */ (0, import_jsx_runtime9.jsx)(App, { ...options }), {
+  if (process.stdin.isTTY && process.stdout.isTTY) {
+    process.stdout.write("\x1B[?2004h");
+  }
+  const instance = (0, import_ink15.render)(/* @__PURE__ */ (0, import_jsx_runtime16.jsx)(App, { ...options }), {
     exitOnCtrlC: true
   });
-  instance.waitUntilExit().catch((err) => {
+  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
 var import_meta = {};
-var VALID_MODES = ["plan", "default", "acceptEdits", "bypassPermissions"];
+function checkSettingsFile(filePath) {
+  if (!(0, import_node_fs3.existsSync)(filePath)) return "missing";
+  try {
+    const raw = (0, import_node_fs3.readFileSync)(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 = (0, import_node_url.fileURLToPath)(import_meta.url);
-    const dir = (0, import_node_path2.dirname)(thisFile);
-    const candidates = [(0, import_node_path2.join)(dir, "..", "..", "package.json"), (0, import_node_path2.join)(dir, "..", "package.json")];
+    const dir = (0, import_node_path5.dirname)(thisFile);
+    const candidates = [(0, import_node_path5.join)(dir, "..", "..", "package.json"), (0, import_node_path5.join)(dir, "..", "package.json")];
     for (const pkgPath of candidates) {
       try {
-        const raw = (0, import_node_fs2.readFileSync)(pkgPath, "utf-8");
+        const raw = (0, import_node_fs3.readFileSync)(pkgPath, "utf-8");
         const pkg = JSON.parse(raw);
         if (pkg.version !== void 0 && pkg.name !== void 0) {
           return pkg.version;
@@ -1085,97 +2359,107 @@ function readVersion() {
     return "0.0.0";
   }
 }
-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 } = (0, import_node_util.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" },
-      "permission-mode": { type: "string" },
-      "max-turns": { type: "string" },
-      version: { type: "boolean", default: false }
-    }
+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);
   });
-  return {
-    positional: positionals,
-    printMode: values["p"] ?? false,
-    continueMode: values["c"] ?? false,
-    resumeId: values["r"],
-    model: values["model"],
-    permissionMode: parsePermissionMode(values["permission-mode"]),
-    maxTurns: parseMaxTurns(values["max-turns"]),
-    version: values["version"] ?? false
-  };
 }
-var PrintTerminal = class {
-  write(text) {
-    process.stdout.write(text);
+async function ensureConfig(cwd) {
+  const userPath = getUserSettingsPath();
+  const projectPath = (0, import_node_path5.join)(cwd, ".robota", "settings.json");
+  const localPath = (0, import_node_path5.join)(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;
   }
-  writeLine(text) {
-    process.stdout.write(text + "\n");
+  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");
   }
-  writeMarkdown(md) {
-    process.stdout.write(md);
+  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");
   }
-  writeError(text) {
-    process.stderr.write(text + "\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");
   }
-  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);
-      });
-    });
+  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);
   }
-  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 language = await promptInput("  Response language (ko/en/ja/zh, default: en): ");
+  const settingsDir = (0, import_node_path5.dirname)(userPath);
+  (0, import_node_fs3.mkdirSync)(settingsDir, { recursive: true });
+  const settings = {
+    provider: {
+      name: "anthropic",
+      model: "claude-sonnet-4-6",
+      apiKey
     }
-    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;
+  };
+  if (language) {
+    settings.language = language;
   }
-  spinner(_message) {
-    return { stop() {
-    }, update() {
-    } };
+  (0, import_node_fs3.writeFileSync)(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) {
@@ -1183,52 +2467,81 @@ async function startCli() {
 `);
     return;
   }
+  if (args.reset) {
+    resetConfig();
+    return;
+  }
   const cwd = process.cwd();
-  const [config, context, projectInfo] = await Promise.all([
-    (0, import_agent_sdk2.loadConfig)(cwd),
-    (0, import_agent_sdk2.loadContext)(cwd),
-    (0, import_agent_sdk2.detectProject)(cwd)
-  ]);
-  if (args.model !== void 0) {
-    config.provider.model = args.model;
+  await ensureConfig(cwd);
+  const providerSettings = readProviderSettings(cwd);
+  const modelId = args.model ?? providerSettings.model;
+  const provider = createProviderFromSettings(cwd, args.model);
+  const sessionStore = new import_agent_sessions.SessionStore();
+  let resumeSessionId;
+  if (args.continueMode) {
+    const sessions = sessionStore.list().filter((s) => s.cwd === cwd);
+    if (sessions.length > 0) {
+      resumeSessionId = sessions[0].id;
+    }
+  } else if (args.resumeId !== void 0) {
+    if (args.resumeId === "") {
+      resumeSessionId = "__picker__";
+    } else {
+      const sessions = sessionStore.list();
+      const match = sessions.find((s) => s.id === args.resumeId || s.name === args.resumeId);
+      if (match) {
+        resumeSessionId = match.id;
+      } else {
+        process.stderr.write(`Session not found: ${args.resumeId}
+`);
+        process.exit(1);
+      }
+    }
   }
-  const sessionStore = new import_agent_sdk2.SessionStore();
   if (args.printMode) {
-    const prompt = args.positional.join(" ").trim();
-    if (prompt.length === 0) {
+    let prompt = args.positional.join(" ").trim();
+    if (!prompt && !process.stdin.isTTY) {
+      const chunks = [];
+      for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+      }
+      prompt = Buffer.concat(chunks).toString("utf-8").trim();
+    }
+    if (!prompt) {
       process.stderr.write("Print mode (-p) requires a prompt argument.\n");
       process.exit(1);
     }
-    const terminal = new PrintTerminal();
-    const paths = (0, import_agent_sdk2.projectPaths)(cwd);
-    const session = (0, import_agent_sdk2.createSession)({
-      config,
-      context,
-      terminal,
-      sessionLogger: new import_agent_sdk2.FileSessionLogger(paths.logs),
-      projectInfo,
-      permissionMode: args.permissionMode,
-      promptForApproval
+    const session = new import_agent_sdk3.InteractiveSession({
+      cwd,
+      provider,
+      permissionMode: args.permissionMode ?? "bypassPermissions",
+      maxTurns: args.maxTurns,
+      sessionStore,
+      sessionName: args.sessionName
     });
-    const response = await session.run(prompt);
-    process.stdout.write(response + "\n");
-    return;
+    const transport = (0, import_agent_transport_headless.createHeadlessTransport)({
+      outputFormat: args.outputFormat ?? "text",
+      prompt
+    });
+    session.attachTransport(transport);
+    await transport.start();
+    process.exit(transport.getExitCode());
   }
   renderApp({
-    config,
-    context,
-    projectInfo,
-    sessionStore,
+    cwd,
+    provider,
+    modelId,
+    language: args.language,
     permissionMode: args.permissionMode,
     maxTurns: args.maxTurns,
-    version: readVersion()
+    version: readVersion(),
+    sessionStore,
+    resumeSessionId,
+    forkSession: args.forkSession,
+    sessionName: args.sessionName
   });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Session,
-  SessionStore,
-  TRUST_TO_MODE,
-  query,
   startCli
 });