@robota-sdk/agent-cli 3.0.0-beta.2 → 3.0.0-beta.20

package/dist/node/{chunk-OH7DJXHF.js → chunk-RE4JCNEA.js}

@@ -1,45 +1,520 @@
 // src/cli.ts
-import { parseArgs } from "util";
-import { readFileSync as readFileSync2 } from "fs";
-import { join as join2, dirname } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
-import * as readline from "readline";
 import {
   loadConfig,
   loadContext,
   detectProject,
-  Session as Session2,
+  createSession as createSession2,
   SessionStore,
-  buildSystemPrompt
+  FileSessionLogger as FileSessionLogger2,
+  projectPaths as projectPaths2
 } from "@robota-sdk/agent-sdk";
+import { promptForApproval } from "@robota-sdk/agent-sdk";
 
-// src/permissions/permission-prompt.ts
-import chalk from "chalk";
-var PERMISSION_OPTIONS = ["Allow", "Deny"];
-var ALLOW_INDEX = 0;
-function formatArgs(toolArgs) {
-  const entries = Object.entries(toolArgs);
-  if (entries.length === 0) {
-    return "(no arguments)";
+// src/utils/cli-args.ts
+import { parseArgs } from "util";
+var VALID_MODES = ["plan", "default", "acceptEdits", "bypassPermissions"];
+function parsePermissionMode(raw) {
+  if (raw === void 0) return void 0;
+  if (!VALID_MODES.includes(raw)) {
+    process.stderr.write(`Invalid --permission-mode "${raw}". Valid: ${VALID_MODES.join(" | ")}
+`);
+    process.exit(1);
   }
-  return entries.map(([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`).join(", ");
+  return raw;
+}
+function parseMaxTurns(raw) {
+  if (raw === void 0) return void 0;
+  const n = parseInt(raw, 10);
+  if (isNaN(n) || n <= 0) {
+    process.stderr.write(`Invalid --max-turns "${raw}". Must be a positive integer.
+`);
+    process.exit(1);
+  }
+  return n;
+}
+function parseCliArgs() {
+  const { values, positionals } = parseArgs({
+    allowPositionals: true,
+    options: {
+      p: { type: "boolean", short: "p", default: false },
+      c: { type: "boolean", short: "c", default: false },
+      r: { type: "string", short: "r" },
+      model: { type: "string" },
+      "permission-mode": { type: "string" },
+      "max-turns": { type: "string" },
+      version: { type: "boolean", default: false },
+      reset: { type: "boolean", default: false }
+    }
+  });
+  return {
+    positional: positionals,
+    printMode: values["p"] ?? false,
+    continueMode: values["c"] ?? false,
+    resumeId: values["r"],
+    model: values["model"],
+    permissionMode: parsePermissionMode(values["permission-mode"]),
+    maxTurns: parseMaxTurns(values["max-turns"]),
+    version: values["version"] ?? false,
+    reset: values["reset"] ?? false
+  };
+}
+
+// src/utils/settings-io.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from "fs";
+import { join, dirname } from "path";
+function getUserSettingsPath() {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "/";
+  return join(home, ".robota", "settings.json");
+}
+function readSettings(path) {
+  if (!existsSync(path)) return {};
+  return JSON.parse(readFileSync(path, "utf8"));
 }
-async function promptForApproval(terminal, toolName, toolArgs) {
-  terminal.writeLine("");
-  terminal.writeLine(chalk.yellow(`[Permission Required] Tool: ${toolName}`));
-  terminal.writeLine(chalk.dim(`  ${formatArgs(toolArgs)}`));
-  terminal.writeLine("");
-  const selected = await terminal.select(PERMISSION_OPTIONS, ALLOW_INDEX);
-  return selected === ALLOW_INDEX;
+function writeSettings(path, settings) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(settings, null, 2) + "\n", "utf8");
 }
+function updateModelInSettings(settingsPath, modelId) {
+  const settings = readSettings(settingsPath);
+  const provider = settings.provider ?? {};
+  provider.model = modelId;
+  settings.provider = provider;
+  writeSettings(settingsPath, settings);
+}
+function deleteSettings(path) {
+  if (existsSync(path)) {
+    unlinkSync(path);
+    return true;
+  }
+  return false;
+}
+
+// src/print-terminal.ts
+import * as readline from "readline";
+var PrintTerminal = class {
+  write(text) {
+    process.stdout.write(text);
+  }
+  writeLine(text) {
+    process.stdout.write(text + "\n");
+  }
+  writeMarkdown(md) {
+    process.stdout.write(md);
+  }
+  writeError(text) {
+    process.stderr.write(text + "\n");
+  }
+  prompt(question) {
+    return new Promise((resolve) => {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: false,
+        historySize: 0
+      });
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    });
+  }
+  async select(options, initialIndex = 0) {
+    for (let i = 0; i < options.length; i++) {
+      const marker = i === initialIndex ? ">" : " ";
+      process.stdout.write(`  ${marker} ${i + 1}) ${options[i]}
+`);
+    }
+    const answer = await this.prompt(
+      `  Choose [1-${options.length}] (default: ${options[initialIndex]}): `
+    );
+    const trimmed = answer.trim().toLowerCase();
+    if (trimmed === "") return initialIndex;
+    const num = parseInt(trimmed, 10);
+    if (!isNaN(num) && num >= 1 && num <= options.length) return num - 1;
+    return initialIndex;
+  }
+  spinner(_message) {
+    return { stop() {
+    }, update() {
+    } };
+  }
+};
 
 // src/ui/render.tsx
 import { render } from "ink";
 
 // src/ui/App.tsx
-import { useState as useState4, useCallback as useCallback2, useRef as useRef2 } from "react";
-import { Box as Box6, Text as Text8, useApp, useInput as useInput4 } from "ink";
-import { Session } from "@robota-sdk/agent-sdk";
+import { useState as useState7, useRef as useRef5 } from "react";
+import { Box as Box8, Text as Text10, useApp, useInput as useInput5 } from "ink";
+import { getModelName } from "@robota-sdk/agent-core";
+
+// src/ui/hooks/useSession.ts
+import { useState, useCallback, useRef } from "react";
+import { createSession, FileSessionLogger, projectPaths } from "@robota-sdk/agent-sdk";
+var TOOL_ARG_DISPLAY_MAX = 80;
+var TOOL_ARG_TRUNCATE_AT = 77;
+var NOOP_TERMINAL = {
+  write: () => {
+  },
+  writeLine: () => {
+  },
+  writeMarkdown: () => {
+  },
+  writeError: () => {
+  },
+  prompt: () => Promise.resolve(""),
+  select: () => Promise.resolve(0),
+  spinner: () => ({ stop: () => {
+  }, update: () => {
+  } })
+};
+function useSession(props) {
+  const [permissionRequest, setPermissionRequest] = useState(null);
+  const [streamingText, setStreamingText] = useState("");
+  const [activeTools, setActiveTools] = useState([]);
+  const permissionQueueRef = useRef([]);
+  const processingRef = useRef(false);
+  const processNextPermission = useCallback(() => {
+    if (processingRef.current) return;
+    const next = permissionQueueRef.current[0];
+    if (!next) {
+      setPermissionRequest(null);
+      return;
+    }
+    processingRef.current = true;
+    setPermissionRequest({
+      toolName: next.toolName,
+      toolArgs: next.toolArgs,
+      resolve: (result) => {
+        permissionQueueRef.current.shift();
+        processingRef.current = false;
+        setPermissionRequest(null);
+        next.resolve(result);
+        setTimeout(() => processNextPermission(), 0);
+      }
+    });
+  }, []);
+  const sessionRef = useRef(null);
+  if (sessionRef.current === null) {
+    const permissionHandler = (toolName, toolArgs) => {
+      return new Promise((resolve) => {
+        permissionQueueRef.current.push({ toolName, toolArgs, resolve });
+        processNextPermission();
+      });
+    };
+    const onTextDelta = (delta) => {
+      setStreamingText((prev) => prev + delta);
+    };
+    const onToolExecution = (event) => {
+      if (event.type === "start") {
+        let firstArg = "";
+        if (event.toolArgs) {
+          const firstVal = Object.values(event.toolArgs)[0];
+          const raw = typeof firstVal === "string" ? firstVal : JSON.stringify(firstVal ?? "");
+          firstArg = raw.length > TOOL_ARG_DISPLAY_MAX ? raw.slice(0, TOOL_ARG_TRUNCATE_AT) + "..." : raw;
+        }
+        setActiveTools((prev) => [...prev, { toolName: event.toolName, firstArg, isRunning: true }]);
+      } else {
+        setActiveTools(
+          (prev) => prev.map(
+            (t) => t.toolName === event.toolName && t.isRunning ? { ...t, isRunning: false } : t
+          )
+        );
+      }
+    };
+    const paths = projectPaths(props.cwd ?? process.cwd());
+    sessionRef.current = createSession({
+      config: props.config,
+      context: props.context,
+      terminal: NOOP_TERMINAL,
+      sessionLogger: new FileSessionLogger(paths.logs),
+      projectInfo: props.projectInfo,
+      sessionStore: props.sessionStore,
+      permissionMode: props.permissionMode,
+      maxTurns: props.maxTurns,
+      permissionHandler,
+      onTextDelta,
+      onToolExecution
+    });
+  }
+  const clearStreamingText = useCallback(() => {
+    setStreamingText("");
+    setActiveTools([]);
+  }, []);
+  return { session: sessionRef.current, permissionRequest, streamingText, clearStreamingText, activeTools };
+}
+
+// src/ui/hooks/useMessages.ts
+import { useState as useState2, useCallback as useCallback2 } from "react";
+var msgIdCounter = 0;
+function nextId() {
+  msgIdCounter += 1;
+  return `msg_${msgIdCounter}`;
+}
+function useMessages() {
+  const [messages, setMessages] = useState2([]);
+  const addMessage = useCallback2((msg) => {
+    setMessages((prev) => [...prev, { ...msg, id: nextId(), timestamp: /* @__PURE__ */ new Date() }]);
+  }, []);
+  return { messages, setMessages, addMessage };
+}
+
+// src/ui/hooks/useSlashCommands.ts
+import { useCallback as useCallback3 } from "react";
+
+// src/commands/slash-executor.ts
+var VALID_MODES2 = ["plan", "default", "acceptEdits", "bypassPermissions"];
+var HELP_TEXT = [
+  "Available commands:",
+  "  /help              \u2014 Show this help",
+  "  /clear             \u2014 Clear conversation",
+  "  /compact [instr]   \u2014 Compact context (optional focus instructions)",
+  "  /mode [m]          \u2014 Show/change permission mode",
+  "  /cost              \u2014 Show session info",
+  "  /reset             \u2014 Delete settings and exit",
+  "  /exit              \u2014 Exit CLI"
+].join("\n");
+function handleHelp(addMessage) {
+  addMessage({ role: "system", content: HELP_TEXT });
+  return { handled: true };
+}
+function handleClear(addMessage, clearMessages, session) {
+  clearMessages();
+  session.clearHistory();
+  addMessage({ role: "system", content: "Conversation cleared." });
+  return { handled: true };
+}
+async function handleCompact(args, session, addMessage) {
+  const instructions = args.trim() || void 0;
+  const before = session.getContextState().usedPercentage;
+  addMessage({ role: "system", content: "Compacting context..." });
+  await session.compact(instructions);
+  const after = session.getContextState().usedPercentage;
+  addMessage({
+    role: "system",
+    content: `Context compacted: ${Math.round(before)}% -> ${Math.round(after)}%`
+  });
+  return { handled: true };
+}
+function handleMode(arg, session, addMessage) {
+  if (!arg) {
+    addMessage({ role: "system", content: `Current mode: ${session.getPermissionMode()}` });
+  } else if (VALID_MODES2.includes(arg)) {
+    session.setPermissionMode(arg);
+    addMessage({ role: "system", content: `Permission mode set to: ${arg}` });
+  } else {
+    addMessage({ role: "system", content: `Invalid mode. Valid: ${VALID_MODES2.join(" | ")}` });
+  }
+  return { handled: true };
+}
+function handleModel(modelId, addMessage) {
+  if (!modelId) {
+    addMessage({ role: "system", content: "Select a model from the /model submenu." });
+    return { handled: true };
+  }
+  return { handled: true, pendingModelId: modelId };
+}
+function handleCost(session, addMessage) {
+  addMessage({
+    role: "system",
+    content: `Session: ${session.getSessionId()}
+Messages: ${session.getMessageCount()}`
+  });
+  return { handled: true };
+}
+function handlePermissions(session, addMessage) {
+  const mode = session.getPermissionMode();
+  const sessionAllowed = session.getSessionAllowedTools();
+  const lines = [`Permission mode: ${mode}`];
+  if (sessionAllowed.length > 0) {
+    lines.push(`Session-approved tools: ${sessionAllowed.join(", ")}`);
+  } else {
+    lines.push("No session-approved tools.");
+  }
+  addMessage({ role: "system", content: lines.join("\n") });
+  return { handled: true };
+}
+function handleContext(session, addMessage) {
+  const ctx = session.getContextState();
+  addMessage({
+    role: "system",
+    content: `Context: ${ctx.usedTokens.toLocaleString()} / ${ctx.maxTokens.toLocaleString()} tokens (${Math.round(ctx.usedPercentage)}%)`
+  });
+  return { handled: true };
+}
+function handleReset(addMessage) {
+  const settingsPath = getUserSettingsPath();
+  if (deleteSettings(settingsPath)) {
+    addMessage({ role: "system", content: `Deleted ${settingsPath}. Exiting...` });
+  } else {
+    addMessage({ role: "system", content: "No user settings found." });
+  }
+  return { handled: true, exitRequested: true };
+}
+async function executeSlashCommand(cmd, args, session, addMessage, clearMessages, registry) {
+  switch (cmd) {
+    case "help":
+      return handleHelp(addMessage);
+    case "clear":
+      return handleClear(addMessage, clearMessages, session);
+    case "compact":
+      return handleCompact(args, session, addMessage);
+    case "mode":
+      return handleMode(args.split(/\s+/)[0] || void 0, session, addMessage);
+    case "model":
+      return handleModel(args.split(/\s+/)[0] || void 0, addMessage);
+    case "cost":
+      return handleCost(session, addMessage);
+    case "permissions":
+      return handlePermissions(session, addMessage);
+    case "context":
+      return handleContext(session, addMessage);
+    case "reset":
+      return handleReset(addMessage);
+    case "exit":
+      return { handled: true, exitRequested: true };
+    default: {
+      const skillCmd = registry.getCommands().find((c) => c.name === cmd && c.source === "skill");
+      if (skillCmd) {
+        addMessage({ role: "system", content: `Invoking skill: ${cmd}` });
+        return { handled: false };
+      }
+      addMessage({ role: "system", content: `Unknown command "/${cmd}". Type /help for help.` });
+      return { handled: true };
+    }
+  }
+}
+
+// src/ui/hooks/useSlashCommands.ts
+var EXIT_DELAY_MS = 500;
+function useSlashCommands(session, addMessage, setMessages, exit, registry, pendingModelChangeRef, setPendingModelId) {
+  return useCallback3(
+    async (input) => {
+      const parts = input.slice(1).split(/\s+/);
+      const cmd = parts[0]?.toLowerCase() ?? "";
+      const args = parts.slice(1).join(" ");
+      const clearMessages = () => setMessages([]);
+      const result = await executeSlashCommand(cmd, args, session, addMessage, clearMessages, registry);
+      if (result.pendingModelId) {
+        pendingModelChangeRef.current = result.pendingModelId;
+        setPendingModelId(result.pendingModelId);
+      }
+      if (result.exitRequested) {
+        setTimeout(() => exit(), EXIT_DELAY_MS);
+      }
+      return result.handled;
+    },
+    [session, addMessage, setMessages, exit, registry, pendingModelChangeRef, setPendingModelId]
+  );
+}
+
+// src/ui/hooks/useSubmitHandler.ts
+import { useCallback as useCallback4 } from "react";
+
+// src/utils/tool-call-extractor.ts
+var TOOL_ARG_MAX_LENGTH = 80;
+var TOOL_ARG_TRUNCATE_LENGTH = 77;
+function extractToolCalls(history, startIndex) {
+  const lines = [];
+  for (let i = startIndex; i < history.length; i++) {
+    const msg = history[i];
+    if (msg.role === "assistant" && msg.toolCalls) {
+      for (const tc of msg.toolCalls) {
+        const value = parseFirstArgValue(tc.function.arguments);
+        const truncated = value.length > TOOL_ARG_MAX_LENGTH ? value.slice(0, TOOL_ARG_TRUNCATE_LENGTH) + "..." : value;
+        lines.push(`${tc.function.name}(${truncated})`);
+      }
+    }
+  }
+  return lines;
+}
+function parseFirstArgValue(argsJson) {
+  try {
+    const parsed = JSON.parse(argsJson);
+    const firstVal = Object.values(parsed)[0];
+    return typeof firstVal === "string" ? firstVal : JSON.stringify(firstVal);
+  } catch {
+    return argsJson;
+  }
+}
+
+// src/utils/skill-prompt.ts
+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();
+  const userInstruction = args || skillCmd.description;
+  if (skillCmd.skillContent) {
+    return `<skill name="${cmd}">
+${skillCmd.skillContent}
+</skill>
+
+Execute the "${cmd}" skill: ${userInstruction}`;
+  }
+  return `Use the "${cmd}" skill: ${userInstruction}`;
+}
+
+// src/ui/hooks/useSubmitHandler.ts
+function syncContextState(session, setter) {
+  const ctx = session.getContextState();
+  setter({ percentage: ctx.usedPercentage, usedTokens: ctx.usedTokens, maxTokens: ctx.maxTokens });
+}
+async function runSessionPrompt(prompt, session, addMessage, clearStreamingText, setIsThinking, setContextState) {
+  setIsThinking(true);
+  clearStreamingText();
+  const historyBefore = session.getHistory().length;
+  try {
+    const response = await session.run(prompt);
+    clearStreamingText();
+    const history = session.getHistory();
+    const toolLines = extractToolCalls(
+      history,
+      historyBefore
+    );
+    if (toolLines.length > 0) {
+      addMessage({ role: "tool", content: toolLines.join("\n"), toolName: `${toolLines.length} tools` });
+    }
+    addMessage({ role: "assistant", content: response || "(empty response)" });
+    syncContextState(session, setContextState);
+  } 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 useSubmitHandler(session, addMessage, handleSlashCommand, clearStreamingText, setIsThinking, setContextState, registry) {
+  return useCallback4(
+    async (input) => {
+      if (input.startsWith("/")) {
+        const handled = await handleSlashCommand(input);
+        if (handled) {
+          syncContextState(session, setContextState);
+          return;
+        }
+        const prompt = buildSkillPrompt(input, registry);
+        if (!prompt) return;
+        return runSessionPrompt(prompt, session, addMessage, clearStreamingText, setIsThinking, setContextState);
+      }
+      addMessage({ role: "user", content: input });
+      return runSessionPrompt(input, session, addMessage, clearStreamingText, setIsThinking, setContextState);
+    },
+    [session, addMessage, handleSlashCommand, clearStreamingText, setIsThinking, setContextState, registry]
+  );
+}
+
+// src/ui/hooks/useCommandRegistry.ts
+import { useRef as useRef2 } from "react";
 
 // src/commands/command-registry.ts
 var CommandRegistry = class {
@@ -72,6 +547,21 @@ var CommandRegistry = class {
 };
 
 // src/commands/builtin-source.ts
+import { CLAUDE_MODELS, formatTokenCount } from "@robota-sdk/agent-core";
+function buildModelSubcommands() {
+  const seen = /* @__PURE__ */ new Set();
+  const commands = [];
+  for (const model of Object.values(CLAUDE_MODELS)) {
+    if (seen.has(model.name)) continue;
+    seen.add(model.name);
+    commands.push({
+      name: model.id,
+      description: `${model.name} (${formatTokenCount(model.contextWindow).toUpperCase()})`,
+      source: "builtin"
+    });
+  }
+  return commands;
+}
 function createBuiltinCommands() {
   return [
     { name: "help", description: "Show available commands", source: "builtin" },
@@ -91,16 +581,13 @@ function createBuiltinCommands() {
       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" }
-      ]
+      subcommands: buildModelSubcommands()
     },
     { 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: "reset", description: "Delete settings and exit", source: "builtin" },
     { name: "exit", description: "Exit CLI", source: "builtin" }
   ];
 }
@@ -116,8 +603,8 @@ var BuiltinCommandSource = class {
 };
 
 // src/commands/skill-source.ts
-import { readdirSync, readFileSync, existsSync } from "fs";
-import { join } from "path";
+import { readdirSync, readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
 import { homedir } from "os";
 function parseFrontmatter(content) {
   const lines = content.split("\n");
@@ -140,19 +627,20 @@ function parseFrontmatter(content) {
   return name ? { name, description } : null;
 }
 function scanSkillsDir(skillsDir) {
-  if (!existsSync(skillsDir)) return [];
+  if (!existsSync2(skillsDir)) return [];
   const commands = [];
   const entries = readdirSync(skillsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const skillFile = join(skillsDir, entry.name, "SKILL.md");
-    if (!existsSync(skillFile)) continue;
-    const content = readFileSync(skillFile, "utf-8");
+    const skillFile = join2(skillsDir, entry.name, "SKILL.md");
+    if (!existsSync2(skillFile)) continue;
+    const content = readFileSync2(skillFile, "utf-8");
     const frontmatter = parseFrontmatter(content);
     commands.push({
       name: frontmatter?.name ?? entry.name,
       description: frontmatter?.description ?? `Skill: ${entry.name}`,
-      source: "skill"
+      source: "skill",
+      skillContent: content
     });
   }
   return commands;
@@ -166,8 +654,8 @@ var SkillCommandSource = class {
   }
   getCommands() {
     if (this.cachedCommands) return this.cachedCommands;
-    const projectSkills = scanSkillsDir(join(this.cwd, ".agents", "skills"));
-    const userSkills = scanSkillsDir(join(homedir(), ".claude", "skills"));
+    const projectSkills = scanSkillsDir(join2(this.cwd, ".agents", "skills"));
+    const userSkills = scanSkillsDir(join2(homedir(), ".claude", "skills"));
     const seen = new Set(projectSkills.map((cmd) => cmd.name));
     const merged = [...projectSkills];
     for (const cmd of userSkills) {
@@ -180,6 +668,18 @@ var SkillCommandSource = class {
   }
 };
 
+// src/ui/hooks/useCommandRegistry.ts
+function useCommandRegistry(cwd) {
+  const registryRef = useRef2(null);
+  if (registryRef.current === null) {
+    const registry = new CommandRegistry();
+    registry.addSource(new BuiltinCommandSource());
+    registry.addSource(new SkillCommandSource(cwd));
+    registryRef.current = registry;
+  }
+  return registryRef.current;
+}
+
 // src/ui/MessageList.tsx
 import { Box, Text } from "ink";
 
@@ -241,6 +741,7 @@ function MessageList({ messages }) {
 
 // src/ui/StatusBar.tsx
 import { Box as Box2, Text as Text2 } from "ink";
+import { formatTokenCount as formatTokenCount2 } from "@robota-sdk/agent-core";
 import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
 var CONTEXT_YELLOW_THRESHOLD = 70;
 var CONTEXT_RED_THRESHOLD = 90;
@@ -280,10 +781,10 @@ function StatusBar({
             "Context: ",
             Math.round(contextPercentage),
             "% (",
-            (contextUsedTokens / 1e3).toFixed(1),
-            "k/",
-            (contextMaxTokens / 1e3).toFixed(0),
-            "k)"
+            formatTokenCount2(contextUsedTokens),
+            "/",
+            formatTokenCount2(contextMaxTokens),
+            ")"
           ] })
         ] }),
         /* @__PURE__ */ jsxs2(Text2, { children: [
@@ -299,15 +800,22 @@ function StatusBar({
 }
 
 // src/ui/InputArea.tsx
-import React3, { useState as useState3, useCallback, useMemo } from "react";
+import React3, { useState as useState5, useCallback as useCallback5, useMemo } from "react";
 import { Box as Box4, Text as Text6, useInput as useInput2 } from "ink";
 
 // src/ui/CjkTextInput.tsx
-import { useRef, useState } from "react";
-import { Text as Text3, useInput, useCursor } from "ink";
-import stringWidth from "string-width";
-import chalk2 from "chalk";
+import { useRef as useRef3, useState as useState3 } from "react";
+import { Text as Text3, useInput } from "ink";
+import chalk from "chalk";
 import { jsx as jsx3 } from "react/jsx-runtime";
+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 CjkTextInput({
   value,
   onChange,
@@ -316,10 +824,9 @@ function CjkTextInput({
   focus = true,
   showCursor = true
 }) {
-  const valueRef = useRef(value);
-  const cursorRef = useRef(value.length);
-  const [, forceRender] = useState(0);
-  const { setCursorPosition } = useCursor();
+  const valueRef = useRef3(value);
+  const cursorRef = useRef3(value.length);
+  const [, forceRender] = useState3(0);
   if (value !== valueRef.current) {
     valueRef.current = value;
     if (cursorRef.current > value.length) {
@@ -328,84 +835,82 @@ function CjkTextInput({
   }
   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 (key.upArrow || key.downArrow || key.ctrl && input === "c" || key.tab || key.shift && key.tab) {
+          return;
         }
-        return;
-      }
-      if (key.rightArrow) {
-        if (cursorRef.current < valueRef.current.length) {
-          cursorRef.current += 1;
-          forceRender((n) => n + 1);
+        if (key.return) {
+          onSubmit?.(valueRef.current);
+          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.leftArrow) {
+          if (cursorRef.current > 0) {
+            cursorRef.current -= 1;
+            forceRender((n) => n + 1);
+          }
+          return;
         }
-        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 + stringWidth(textBeforeCursor);
-    setCursorPosition({ x: cursorX, y: 0 });
-  }
   return /* @__PURE__ */ jsx3(Text3, { children: renderWithCursor(valueRef.current, cursorRef.current, placeholder, showCursor && focus) });
 }
 function renderWithCursor(value, cursorOffset, placeholder, showCursor) {
   if (!showCursor) {
-    return value.length > 0 ? value : placeholder ? chalk2.gray(placeholder) : "";
+    return value.length > 0 ? value : placeholder ? chalk.gray(placeholder) : "";
   }
   if (value.length === 0) {
     if (placeholder.length > 0) {
-      return chalk2.inverse(placeholder[0]) + chalk2.gray(placeholder.slice(1));
+      return chalk.inverse(placeholder[0]) + chalk.gray(placeholder.slice(1));
     }
-    return chalk2.inverse(" ");
+    return chalk.inverse(" ");
   }
   const chars = [...value];
   let rendered = "";
   for (let i = 0; i < chars.length; i++) {
     const char = chars[i] ?? "";
-    rendered += i === cursorOffset ? chalk2.inverse(char) : char;
+    rendered += i === cursorOffset ? chalk.inverse(char) : char;
   }
   if (cursorOffset >= chars.length) {
-    rendered += chalk2.inverse(" ");
+    rendered += chalk.inverse(" ");
   }
   return rendered;
 }
 
 // src/ui/WaveText.tsx
-import { useState as useState2, useEffect } from "react";
+import { useState as useState4, useEffect } from "react";
 import { Text as Text4 } from "ink";
 import { jsx as jsx4 } from "react/jsx-runtime";
 var WAVE_COLORS = ["#666666", "#888888", "#aaaaaa", "#888888"];
 var INTERVAL_MS = 400;
 var CHARS_PER_GROUP = 4;
 function WaveText({ text }) {
-  const [tick, setTick] = useState2(0);
+  const [tick, setTick] = useState4(0);
   useEffect(() => {
     const timer = setInterval(() => {
       setTick((prev) => prev + 1);
@@ -426,19 +931,13 @@ import { jsx as jsx5, jsxs as jsxs3 } from "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__ */ jsxs3(Box3, { children: [
-    /* @__PURE__ */ jsxs3(Text5, { color: nameColor, dimColor: dimmed, children: [
-      indicator,
-      prefix,
-      cmd.name
-    ] }),
-    /* @__PURE__ */ jsx5(Text5, { dimColor: dimmed, children: "  " }),
-    /* @__PURE__ */ jsx5(Text5, { color: nameColor, dimColor: dimmed, children: cmd.description })
-  ] });
+  return /* @__PURE__ */ jsx5(Box3, { children: /* @__PURE__ */ jsxs3(Text5, { color: nameColor, dimColor: dimmed, children: [
+    indicator,
+    showSlash ? `/${cmd.name}  ${cmd.description}` : cmd.description
+  ] }) });
 }
 function SlashAutocomplete({
   commands,
@@ -478,8 +977,8 @@ function parseSlashInput(value) {
   return { isSlash: true, parentCommand: parent, filter: rest };
 }
 function useAutocomplete(value, registry) {
-  const [selectedIndex, setSelectedIndex] = useState3(0);
-  const [dismissed, setDismissed] = useState3(false);
+  const [selectedIndex, setSelectedIndex] = useState5(0);
+  const [dismissed, setDismissed] = useState5(false);
   const prevValueRef = React3.useRef(value);
   if (prevValueRef.current !== value) {
     prevValueRef.current = value;
@@ -521,7 +1020,7 @@ function useAutocomplete(value, registry) {
   };
 }
 function InputArea({ onSubmit, isDisabled, registry }) {
-  const [value, setValue] = useState3("");
+  const [value, setValue] = useState5("");
   const {
     showPopup,
     filteredCommands,
@@ -530,7 +1029,7 @@ function InputArea({ onSubmit, isDisabled, registry }) {
     isSubcommandMode,
     setShowPopup
   } = useAutocomplete(value, registry);
-  const handleSubmit = useCallback(
+  const handleSubmit = useCallback5(
     (text) => {
       const trimmed = text.trim();
       if (trimmed.length === 0) return;
@@ -543,7 +1042,7 @@ function InputArea({ onSubmit, isDisabled, registry }) {
     },
     [showPopup, filteredCommands, selectedIndex, onSubmit]
   );
-  const selectCommand = useCallback(
+  const selectCommand = useCallback5(
     (cmd) => {
       const parsed = parseSlashInput(value);
       if (parsed.parentCommand) {
@@ -573,437 +1072,276 @@ function InputArea({ onSubmit, isDisabled, registry }) {
         setShowPopup(false);
       } else if (key.tab) {
         const cmd = filteredCommands[selectedIndex];
-        if (cmd) selectCommand(cmd);
-      }
-    },
-    { isActive: showPopup && !isDisabled }
-  );
-  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
-    showPopup && /* @__PURE__ */ jsx6(
-      SlashAutocomplete,
-      {
-        commands: filteredCommands,
-        selectedIndex,
-        visible: showPopup,
-        isSubcommandMode
-      }
-    ),
-    /* @__PURE__ */ jsx6(Box4, { borderStyle: "single", borderColor: isDisabled ? "gray" : "green", paddingLeft: 1, children: isDisabled ? /* @__PURE__ */ jsx6(WaveText, { text: "  Waiting for response..." }) : /* @__PURE__ */ jsxs4(Box4, { children: [
-      /* @__PURE__ */ jsx6(Text6, { color: "green", bold: true, children: "> " }),
-      /* @__PURE__ */ jsx6(
-        CjkTextInput,
-        {
-          value,
-          onChange: setValue,
-          onSubmit: handleSubmit,
-          placeholder: "Type a message or /help"
-        }
-      )
-    ] }) })
-  ] });
-}
-
-// src/ui/PermissionPrompt.tsx
-import React4 from "react";
-import { Box as Box5, Text as Text7, useInput as useInput3 } from "ink";
-import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
-var OPTIONS = ["Allow", "Allow always (this session)", "Deny"];
-function formatArgs2(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] = React4.useState(0);
-  const resolvedRef = React4.useRef(false);
-  const prevRequestRef = React4.useRef(request);
-  if (prevRequestRef.current !== request) {
-    prevRequestRef.current = request;
-    resolvedRef.current = false;
-    setSelected(0);
-  }
-  const doResolve = React4.useCallback(
-    (index) => {
-      if (resolvedRef.current) return;
-      resolvedRef.current = true;
-      if (index === 0) request.resolve(true);
-      else if (index === 1) request.resolve("allow-session");
-      else request.resolve(false);
-    },
-    [request]
-  );
-  useInput3((input, key) => {
-    if (resolvedRef.current) return;
-    if (key.upArrow || key.leftArrow) {
-      setSelected((prev) => prev > 0 ? prev - 1 : prev);
-    } else if (key.downArrow || key.rightArrow) {
-      setSelected((prev) => prev < OPTIONS.length - 1 ? prev + 1 : prev);
-    } else if (key.return) {
-      doResolve(selected);
-    } else if (input === "y" || input === "1") {
-      doResolve(0);
-    } else if (input === "a" || input === "2") {
-      doResolve(1);
-    } else if (input === "n" || input === "d" || input === "3") {
-      doResolve(2);
-    }
-  });
-  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
-    /* @__PURE__ */ jsx7(Text7, { color: "yellow", bold: true, children: "[Permission Required]" }),
-    /* @__PURE__ */ jsxs5(Text7, { children: [
-      "Tool:",
-      " ",
-      /* @__PURE__ */ jsx7(Text7, { color: "cyan", bold: true, children: request.toolName })
-    ] }),
-    /* @__PURE__ */ jsxs5(Text7, { dimColor: true, children: [
-      " ",
-      formatArgs2(request.toolArgs)
-    ] }),
-    /* @__PURE__ */ jsx7(Box5, { marginTop: 1, children: OPTIONS.map((opt, i) => /* @__PURE__ */ jsx7(Box5, { marginRight: 2, children: /* @__PURE__ */ jsxs5(Text7, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
-      i === selected ? "> " : "  ",
-      opt
-    ] }) }, opt)) }),
-    /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: " left/right to select, Enter to confirm" })
-  ] });
-}
-
-// src/ui/App.tsx
-import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
-var msgIdCounter = 0;
-function nextId() {
-  msgIdCounter += 1;
-  return `msg_${msgIdCounter}`;
-}
-var NOOP_TERMINAL = {
-  write: () => {
-  },
-  writeLine: () => {
-  },
-  writeMarkdown: () => {
-  },
-  writeError: () => {
-  },
-  prompt: () => Promise.resolve(""),
-  select: () => Promise.resolve(0),
-  spinner: () => ({ stop: () => {
-  }, update: () => {
-  } })
-};
-function useSession(props) {
-  const [permissionRequest, setPermissionRequest] = useState4(null);
-  const [streamingText, setStreamingText] = useState4("");
-  const permissionQueueRef = useRef2([]);
-  const processingRef = useRef2(false);
-  const processNextPermission = useCallback2(() => {
-    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 = useRef2(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);
-    };
-    sessionRef.current = new Session({
-      config: props.config,
-      context: props.context,
-      terminal: NOOP_TERMINAL,
-      projectInfo: props.projectInfo,
-      sessionStore: props.sessionStore,
-      permissionMode: props.permissionMode,
-      maxTurns: props.maxTurns,
-      permissionHandler,
-      onTextDelta
-    });
-  }
-  const clearStreamingText = useCallback2(() => setStreamingText(""), []);
-  return { session: sessionRef.current, permissionRequest, streamingText, clearStreamingText };
-}
-function useMessages() {
-  const [messages, setMessages] = useState4([]);
-  const addMessage = useCallback2((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(" | ")}` });
-  }
-  return true;
-}
-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;
-    }
-    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 (cmd) selectCommand(cmd);
       }
-      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;
-    }
-    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;
+    },
+    { isActive: showPopup && !isDisabled }
+  );
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    showPopup && /* @__PURE__ */ jsx6(
+      SlashAutocomplete,
+      {
+        commands: filteredCommands,
+        selectedIndex,
+        visible: showPopup,
+        isSubcommandMode
       }
-      addMessage({ role: "system", content: `Unknown command "/${cmd}". Type /help for help.` });
-      return true;
-    }
-  }
+    ),
+    /* @__PURE__ */ jsx6(Box4, { borderStyle: "single", borderColor: isDisabled ? "gray" : "green", paddingLeft: 1, children: isDisabled ? /* @__PURE__ */ jsx6(WaveText, { text: "  Waiting for response..." }) : /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx6(Text6, { color: "green", bold: true, children: "> " }),
+      /* @__PURE__ */ jsx6(
+        CjkTextInput,
+        {
+          value,
+          onChange: setValue,
+          onSubmit: handleSubmit,
+          placeholder: "Type a message or /help"
+        }
+      )
+    ] }) })
+  ] });
 }
-function useSlashCommands(session, addMessage, setMessages, exit, registry) {
-  return useCallback2(
-    async (input) => {
-      const parts = input.slice(1).split(/\s+/);
-      const cmd = parts[0]?.toLowerCase() ?? "";
-      return executeSlashCommand(cmd, parts, session, addMessage, setMessages, exit, registry);
+
+// src/ui/ConfirmPrompt.tsx
+import { useState as useState6, useCallback as useCallback6, useRef as useRef4 } from "react";
+import { Box as Box5, Text as Text7, useInput as useInput3 } from "ink";
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+function ConfirmPrompt({
+  message,
+  options = ["Yes", "No"],
+  onSelect
+}) {
+  const [selected, setSelected] = useState6(0);
+  const resolvedRef = useRef4(false);
+  const doSelect = useCallback6(
+    (index) => {
+      if (resolvedRef.current) return;
+      resolvedRef.current = true;
+      onSelect(index);
     },
-    [session, addMessage, setMessages, exit, registry]
+    [onSelect]
   );
-}
-function StreamingIndicator({ text }) {
-  if (text) {
-    return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsxs6(Text8, { color: "cyan", bold: true, children: [
-        "Robota:",
-        " "
-      ] }),
-      /* @__PURE__ */ jsx8(Text8, { children: " " }),
-      /* @__PURE__ */ jsx8(Box6, { marginLeft: 2, children: /* @__PURE__ */ jsx8(Text8, { wrap: "wrap", children: renderMarkdown(text) }) })
-    ] });
-  }
-  return /* @__PURE__ */ jsx8(Text8, { 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}` });
+  useInput3((input, key) => {
+    if (resolvedRef.current) return;
+    if (key.leftArrow || key.upArrow) {
+      setSelected((prev) => prev > 0 ? prev - 1 : prev);
+    } else if (key.rightArrow || key.downArrow) {
+      setSelected((prev) => prev < options.length - 1 ? prev + 1 : prev);
+    } else if (key.return) {
+      doSelect(selected);
+    } else if (input === "y" && options.length === 2) {
+      doSelect(0);
+    } else if (input === "n" && options.length === 2) {
+      doSelect(1);
     }
-  } finally {
-    setIsThinking(false);
-  }
+  });
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx7(Text7, { color: "yellow", children: message }),
+    /* @__PURE__ */ jsx7(Box5, { marginTop: 1, children: options.map((opt, i) => /* @__PURE__ */ jsx7(Box5, { marginRight: 2, children: /* @__PURE__ */ jsxs5(Text7, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
+      i === selected ? "> " : "  ",
+      opt
+    ] }) }, opt)) }),
+    /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: " arrow keys to select, Enter to confirm" })
+  ] });
 }
-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}`;
+
+// src/ui/PermissionPrompt.tsx
+import React5 from "react";
+import { Box as Box6, Text as Text8, useInput as useInput4 } from "ink";
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+var OPTIONS = ["Allow", "Allow always (this session)", "Deny"];
+function formatArgs(args) {
+  const entries = Object.entries(args);
+  if (entries.length === 0) return "(no arguments)";
+  return entries.map(([k, v]) => `${k}: ${typeof v === "string" ? v : JSON.stringify(v)}`).join(", ");
 }
-function useSubmitHandler(session, addMessage, handleSlashCommand, clearStreamingText, setIsThinking, setContextPercentage, registry) {
-  return useCallback2(
-    async (input) => {
-      if (input.startsWith("/")) {
-        const handled = await handleSlashCommand(input);
-        if (handled) {
-          setContextPercentage(session.getContextState().usedPercentage);
-          return;
-        }
-        const prompt = buildSkillPrompt(input, registry);
-        if (!prompt) return;
-        return runSessionPrompt(
-          prompt,
-          session,
-          addMessage,
-          clearStreamingText,
-          setIsThinking,
-          setContextPercentage
-        );
-      }
-      addMessage({ role: "user", content: input });
-      return runSessionPrompt(
-        input,
-        session,
-        addMessage,
-        clearStreamingText,
-        setIsThinking,
-        setContextPercentage
-      );
+function PermissionPrompt({ request }) {
+  const [selected, setSelected] = React5.useState(0);
+  const resolvedRef = React5.useRef(false);
+  const prevRequestRef = React5.useRef(request);
+  if (prevRequestRef.current !== request) {
+    prevRequestRef.current = request;
+    resolvedRef.current = false;
+    setSelected(0);
+  }
+  const doResolve = React5.useCallback(
+    (index) => {
+      if (resolvedRef.current) return;
+      resolvedRef.current = true;
+      if (index === 0) request.resolve(true);
+      else if (index === 1) request.resolve("allow-session");
+      else request.resolve(false);
     },
-    [
-      session,
-      addMessage,
-      handleSlashCommand,
-      clearStreamingText,
-      setIsThinking,
-      setContextPercentage,
-      registry
-    ]
+    [request]
   );
+  useInput4((input, key) => {
+    if (resolvedRef.current) return;
+    if (key.upArrow || key.leftArrow) {
+      setSelected((prev) => prev > 0 ? prev - 1 : prev);
+    } else if (key.downArrow || key.rightArrow) {
+      setSelected((prev) => prev < OPTIONS.length - 1 ? prev + 1 : prev);
+    } else if (key.return) {
+      doResolve(selected);
+    } else if (input === "y" || input === "1") {
+      doResolve(0);
+    } else if (input === "a" || input === "2") {
+      doResolve(1);
+    } else if (input === "n" || input === "d" || input === "3") {
+      doResolve(2);
+    }
+  });
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [
+    /* @__PURE__ */ jsx8(Text8, { color: "yellow", bold: true, children: "[Permission Required]" }),
+    /* @__PURE__ */ jsxs6(Text8, { children: [
+      "Tool:",
+      " ",
+      /* @__PURE__ */ jsx8(Text8, { color: "cyan", bold: true, children: request.toolName })
+    ] }),
+    /* @__PURE__ */ jsxs6(Text8, { dimColor: true, children: [
+      " ",
+      formatArgs(request.toolArgs)
+    ] }),
+    /* @__PURE__ */ jsx8(Box6, { marginTop: 1, children: OPTIONS.map((opt, i) => /* @__PURE__ */ jsx8(Box6, { marginRight: 2, children: /* @__PURE__ */ jsxs6(Text8, { color: i === selected ? "cyan" : void 0, bold: i === selected, children: [
+      i === selected ? "> " : "  ",
+      opt
+    ] }) }, opt)) }),
+    /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: " left/right to select, Enter to confirm" })
+  ] });
 }
-function useCommandRegistry(cwd) {
-  const registryRef = useRef2(null);
-  if (registryRef.current === null) {
-    const registry = new CommandRegistry();
-    registry.addSource(new BuiltinCommandSource());
-    registry.addSource(new SkillCommandSource(cwd));
-    registryRef.current = registry;
+
+// src/ui/StreamingIndicator.tsx
+import { Box as Box7, Text as Text9 } from "ink";
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+function StreamingIndicator({ text, activeTools }) {
+  const hasTools = activeTools.length > 0;
+  const hasText = text.length > 0;
+  if (!hasTools && !hasText) {
+    return /* @__PURE__ */ jsx9(Text9, { color: "yellow", children: "Thinking..." });
   }
-  return registryRef.current;
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+    hasTools && /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx9(Text9, { color: "gray", bold: true, children: "Tools:" }),
+      /* @__PURE__ */ jsx9(Text9, { children: " " }),
+      activeTools.map((t, i) => /* @__PURE__ */ jsxs7(Text9, { color: t.isRunning ? "yellow" : "green", children: [
+        "  ",
+        t.isRunning ? "\u27F3" : "\u2713",
+        " ",
+        t.toolName,
+        "(",
+        t.firstArg,
+        ")"
+      ] }, `${t.toolName}-${i}`))
+    ] }),
+    hasText && /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx9(Text9, { color: "cyan", bold: true, children: "Robota:" }),
+      /* @__PURE__ */ jsx9(Text9, { children: " " }),
+      /* @__PURE__ */ jsx9(Box7, { marginLeft: 2, children: /* @__PURE__ */ jsx9(Text9, { wrap: "wrap", children: renderMarkdown(text) }) })
+    ] })
+  ] });
 }
+
+// src/ui/App.tsx
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
+var EXIT_DELAY_MS2 = 500;
 function App(props) {
   const { exit } = useApp();
-  const { session, permissionRequest, streamingText, clearStreamingText } = useSession(props);
+  const { session, permissionRequest, streamingText, clearStreamingText, activeTools } = useSession(props);
   const { messages, setMessages, addMessage } = useMessages();
-  const [isThinking, setIsThinking] = useState4(false);
-  const [contextPercentage, setContextPercentage] = useState4(0);
+  const [isThinking, setIsThinking] = useState7(false);
+  const initialCtx = session.getContextState();
+  const [contextState, setContextState] = useState7({
+    percentage: initialCtx.usedPercentage,
+    usedTokens: initialCtx.usedTokens,
+    maxTokens: initialCtx.maxTokens
+  });
   const registry = useCommandRegistry(props.cwd ?? process.cwd());
-  const handleSlashCommand = useSlashCommands(session, addMessage, setMessages, exit, registry);
+  const pendingModelChangeRef = useRef5(null);
+  const [pendingModelId, setPendingModelId] = useState7(null);
+  const handleSlashCommand = useSlashCommands(session, addMessage, setMessages, exit, registry, pendingModelChangeRef, setPendingModelId);
   const handleSubmit = useSubmitHandler(
     session,
     addMessage,
     handleSlashCommand,
     clearStreamingText,
     setIsThinking,
-    setContextPercentage,
+    setContextState,
     registry
   );
-  useInput4(
+  useInput5(
     (_input, key) => {
       if (key.ctrl && _input === "c") exit();
       if (key.escape && isThinking) session.abort();
     },
     { isActive: !permissionRequest }
   );
-  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
-      /* @__PURE__ */ jsx8(Text8, { color: "cyan", bold: true, children: `
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
+      /* @__PURE__ */ jsx10(Text10, { color: "cyan", bold: true, children: `
   ____   ___  ____   ___ _____  _
  |  _ \\ / _ \\| __ ) / _ \\_   _|/ \\
  | |_) | | | |  _ \\| | | || | / _ \\
  |  _ <| |_| | |_) | |_| || |/ ___ \\
  |_| \\_\\\\___/|____/ \\___/ |_/_/   \\_\\
 ` }),
-      /* @__PURE__ */ jsxs6(Text8, { dimColor: true, children: [
+      /* @__PURE__ */ jsxs8(Text10, { dimColor: true, children: [
         " v",
         props.version ?? "0.0.0"
       ] })
     ] }),
-    /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
-      /* @__PURE__ */ jsx8(MessageList, { messages }),
-      isThinking && /* @__PURE__ */ jsx8(Box6, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsx8(StreamingIndicator, { text: streamingText }) })
+    /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
+      /* @__PURE__ */ jsx10(MessageList, { messages }),
+      isThinking && /* @__PURE__ */ jsx10(Box8, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsx10(StreamingIndicator, { text: streamingText, activeTools }) })
     ] }),
-    permissionRequest && /* @__PURE__ */ jsx8(PermissionPrompt, { request: permissionRequest }),
-    /* @__PURE__ */ jsx8(
+    permissionRequest && /* @__PURE__ */ jsx10(PermissionPrompt, { request: permissionRequest }),
+    pendingModelId && /* @__PURE__ */ jsx10(
+      ConfirmPrompt,
+      {
+        message: `Change model to ${getModelName(pendingModelId)}? This will restart the session.`,
+        onSelect: (index) => {
+          setPendingModelId(null);
+          pendingModelChangeRef.current = null;
+          if (index === 0) {
+            try {
+              const settingsPath = getUserSettingsPath();
+              updateModelInSettings(settingsPath, pendingModelId);
+              addMessage({ role: "system", content: `Model changed to ${getModelName(pendingModelId)}. Restarting...` });
+              setTimeout(() => exit(), EXIT_DELAY_MS2);
+            } catch (err) {
+              addMessage({ role: "system", content: `Failed: ${err instanceof Error ? err.message : String(err)}` });
+            }
+          } else {
+            addMessage({ role: "system", content: "Model change cancelled." });
+          }
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx10(
       StatusBar,
       {
         permissionMode: session.getPermissionMode(),
-        modelName: props.config.provider.model,
+        modelName: getModelName(props.config.provider.model),
         sessionId: session.getSessionId(),
         messageCount: messages.length,
         isThinking,
-        contextPercentage,
-        contextUsedTokens: session.getContextState().usedTokens,
-        contextMaxTokens: session.getContextState().maxTokens
+        contextPercentage: contextState.percentage,
+        contextUsedTokens: contextState.usedTokens,
+        contextMaxTokens: contextState.maxTokens
       }
     ),
-    /* @__PURE__ */ jsx8(
+    /* @__PURE__ */ jsx10(
       InputArea,
       {
         onSubmit: handleSubmit,
         isDisabled: isThinking || !!permissionRequest,
         registry
       }
-    )
+    ),
+    /* @__PURE__ */ jsx10(Text10, { children: " " })
   ] });
 }
 
 // src/ui/render.tsx
-import { jsx as jsx9 } from "react/jsx-runtime";
+import { jsx as jsx11 } from "react/jsx-runtime";
 function renderApp(options) {
   process.on("unhandledRejection", (reason) => {
     process.stderr.write(`
@@ -1014,7 +1352,7 @@ function renderApp(options) {
 `);
     }
   });
-  const instance = render(/* @__PURE__ */ jsx9(App, { ...options }), {
+  const instance = render(/* @__PURE__ */ jsx11(App, { ...options }), {
     exitOnCtrlC: true
   });
   instance.waitUntilExit().catch((err) => {
@@ -1027,15 +1365,26 @@ function renderApp(options) {
 }
 
 // src/cli.ts
-var VALID_MODES = ["plan", "default", "acceptEdits", "bypassPermissions"];
+function hasValidSettingsFile(filePath) {
+  if (!existsSync3(filePath)) return false;
+  try {
+    const raw = readFileSync3(filePath, "utf8").trim();
+    if (raw.length === 0) return false;
+    const parsed = JSON.parse(raw);
+    const provider = parsed.provider;
+    return !!provider?.apiKey;
+  } catch {
+    return false;
+  }
+}
 function readVersion() {
   try {
     const thisFile = fileURLToPath(import.meta.url);
-    const dir = dirname(thisFile);
-    const candidates = [join2(dir, "..", "..", "package.json"), join2(dir, "..", "package.json")];
+    const dir = dirname2(thisFile);
+    const candidates = [join3(dir, "..", "..", "package.json"), join3(dir, "..", "package.json")];
     for (const pkgPath of candidates) {
       try {
-        const raw = readFileSync2(pkgPath, "utf-8");
+        const raw = readFileSync3(pkgPath, "utf-8");
         const pkg = JSON.parse(raw);
         if (pkg.version !== void 0 && pkg.name !== void 0) {
           return pkg.version;
@@ -1048,97 +1397,78 @@ 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);
+async function ensureConfig(cwd) {
+  const userPath = getUserSettingsPath();
+  const projectPath = join3(cwd, ".robota", "settings.json");
+  const localPath = join3(cwd, ".robota", "settings.local.json");
+  if (hasValidSettingsFile(userPath) || hasValidSettingsFile(projectPath) || hasValidSettingsFile(localPath)) {
+    return;
   }
-  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.stdout.write("\n");
+  process.stdout.write("  Welcome to Robota CLI!\n");
+  process.stdout.write("  No configuration found. Let's set up your API key.\n");
+  process.stdout.write("\n");
+  const apiKey = await new Promise((resolve) => {
+    process.stdout.write("  Anthropic API key: ");
+    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("*");
+        }
+      }
+    };
+    stdin.on("data", onData);
+  });
+  if (!apiKey) {
+    process.stderr.write("\n  No API key provided. Exiting.\n");
     process.exit(1);
   }
-  return n;
-}
-function parseCliArgs() {
-  const { values, positionals } = parseArgs({
-    allowPositionals: true,
-    options: {
-      p: { type: "boolean", short: "p", default: false },
-      c: { type: "boolean", short: "c", default: false },
-      r: { type: "string", short: "r" },
-      model: { type: "string" },
-      "permission-mode": { type: "string" },
-      "max-turns": { type: "string" },
-      version: { type: "boolean", default: false }
+  const settingsDir = dirname2(userPath);
+  mkdirSync2(settingsDir, { recursive: true });
+  const settings = {
+    provider: {
+      name: "anthropic",
+      model: "claude-sonnet-4-6",
+      apiKey
     }
-  });
-  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
   };
+  writeFileSync2(userPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  process.stdout.write(`
+  Config saved to ${userPath}
+
+`);
 }
-var PrintTerminal = class {
-  write(text) {
-    process.stdout.write(text);
-  }
-  writeLine(text) {
-    process.stdout.write(text + "\n");
-  }
-  writeMarkdown(md) {
-    process.stdout.write(md);
-  }
-  writeError(text) {
-    process.stderr.write(text + "\n");
-  }
-  prompt(question) {
-    return new Promise((resolve) => {
-      const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-        terminal: false,
-        historySize: 0
-      });
-      rl.question(question, (answer) => {
-        rl.close();
-        resolve(answer);
-      });
-    });
-  }
-  async select(options, initialIndex = 0) {
-    for (let i = 0; i < options.length; i++) {
-      const marker = i === initialIndex ? ">" : " ";
-      process.stdout.write(`  ${marker} ${i + 1}) ${options[i]}
+function resetConfig() {
+  const userPath = getUserSettingsPath();
+  if (deleteSettings(userPath)) {
+    process.stdout.write(`Deleted ${userPath}
 `);
-    }
-    const answer = await this.prompt(
-      `  Choose [1-${options.length}] (default: ${options[initialIndex]}): `
-    );
-    const trimmed = answer.trim().toLowerCase();
-    if (trimmed === "") return initialIndex;
-    const num = parseInt(trimmed, 10);
-    if (!isNaN(num) && num >= 1 && num <= options.length) return num - 1;
-    return initialIndex;
-  }
-  spinner(_message) {
-    return { stop() {
-    }, update() {
-    } };
+  } else {
+    process.stdout.write("No user settings found.\n");
   }
-};
+}
 async function startCli() {
   const args = parseCliArgs();
   if (args.version) {
@@ -1146,7 +1476,12 @@ async function startCli() {
 `);
     return;
   }
+  if (args.reset) {
+    resetConfig();
+    return;
+  }
   const cwd = process.cwd();
+  await ensureConfig(cwd);
   const [config, context, projectInfo] = await Promise.all([
     loadConfig(cwd),
     loadContext(cwd),
@@ -1163,13 +1498,14 @@ async function startCli() {
       process.exit(1);
     }
     const terminal = new PrintTerminal();
-    const session = new Session2({
+    const paths = projectPaths2(cwd);
+    const session = createSession2({
       config,
       context,
       terminal,
+      sessionLogger: new FileSessionLogger2(paths.logs),
       projectInfo,
       permissionMode: args.permissionMode,
-      systemPromptBuilder: buildSystemPrompt,
       promptForApproval
     });
     const response = await session.run(prompt);