@robota-sdk/agent-cli 3.0.0-beta.43 → 3.0.0-beta.44

package/dist/node/index.cjs

@@ -30,21 +30,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  Session: () => import_agent_sdk5.Session,
-  SessionStore: () => import_agent_sdk5.SessionStore,
-  TRUST_TO_MODE: () => import_agent_sdk5.TRUST_TO_MODE,
-  query: () => import_agent_sdk5.query,
   startCli: () => startCli
 });
 module.exports = __toCommonJS(index_exports);
-var import_agent_sdk5 = require("@robota-sdk/agent-sdk");
 
 // src/cli.ts
-var import_node_fs2 = require("fs");
+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_sdk4 = require("@robota-sdk/agent-sdk");
 
 // src/utils/cli-args.ts
 var import_node_util = require("util");
@@ -127,56 +121,49 @@ function deleteSettings(path) {
   return false;
 }
 
-// src/print-terminal.ts
-var readline = __toESM(require("readline"), 1);
-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]}
-`);
+// src/utils/provider-factory.ts
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
+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;
     }
-    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() {
-    } };
+  throw new Error("No provider configuration found. Run `robota` to set up.");
+}
+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/ui/render.tsx
 var import_ink14 = require("ink");
@@ -188,227 +175,136 @@ var import_agent_core4 = require("@robota-sdk/agent-core");
 
 // src/ui/hooks/useInteractiveSession.ts
 var import_react = require("react");
-var import_node_os = require("os");
+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/plugin-source.ts
-var PluginCommandSource = class {
-  name = "plugin";
-  plugins;
-  constructor(plugins) {
-    this.plugins = plugins;
-  }
-  getCommands() {
-    const commands = [];
-    for (const plugin of this.plugins) {
-      for (const skill of plugin.skills) {
-        const baseName = skill.name.includes("@") ? skill.name.split("@")[0] : skill.name;
-        commands.push({
-          name: baseName,
-          description: `(${plugin.manifest.name}) ${skill.description}`,
-          source: "plugin",
-          skillContent: skill.skillContent,
-          pluginDir: plugin.pluginDir
-        });
-      }
-      for (const cmd of plugin.commands) {
-        commands.push({
-          name: cmd.name,
-          description: cmd.description,
-          source: "plugin",
-          skillContent: cmd.skillContent,
-          pluginDir: plugin.pluginDir
-        });
-      }
-    }
-    return commands;
-  }
-};
-
-// src/utils/skill-prompt.ts
-var import_node_child_process = require("child_process");
-function substituteVariables(content, args, context) {
-  const argParts = args ? args.split(/\s+/) : [];
-  let result = content;
-  result = result.replace(/\$ARGUMENTS\[(\d+)]/g, (_match, index) => {
-    return argParts[Number(index)] ?? "";
-  });
-  result = result.replace(/\$ARGUMENTS/g, args);
-  result = result.replace(/\$(\d)(?!\d|\w|\[)/g, (_match, digit) => {
-    return argParts[Number(digit)] ?? "";
-  });
-  result = result.replace(/\$\{CLAUDE_SESSION_ID}/g, context?.sessionId ?? "");
-  result = result.replace(/\$\{CLAUDE_SKILL_DIR}/g, context?.skillDir ?? "");
-  return result;
-}
-async function preprocessShellCommands(content) {
-  const shellPattern = /!`([^`]+)`/g;
-  if (!shellPattern.test(content)) {
-    return content;
-  }
-  shellPattern.lastIndex = 0;
-  let result = content;
-  let match;
-  const matches = [];
-  while ((match = shellPattern.exec(content)) !== null) {
-    matches.push({ full: match[0], command: match[1] });
-  }
-  for (const { full, command } of matches) {
-    let output = "";
-    try {
-      output = (0, import_node_child_process.execSync)(command, {
-        timeout: 5e3,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trimEnd();
-    } catch {
-      output = "";
+// 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?.();
+  }
+  // ── 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) => {
+    this.activeTools = this.activeTools.map(
+      (t) => t.toolName === state.toolName && t.isRunning ? state : t
+    );
+    this.notify();
+  };
+  onThinking = (thinking) => {
+    this.isThinking = thinking;
+    if (thinking) {
+      this.streamBuf = "";
+      this.streamingText = "";
+      this.activeTools = [];
+    } else {
+      this.isAborting = false;
     }
-    result = result.replace(full, output);
-  }
-  return result;
-}
-async function buildSkillPrompt(input, registry, context) {
-  const parts = input.slice(1).split(/\s+/);
-  const cmd = parts[0]?.toLowerCase() ?? "";
-  const skillCmd = registry.getCommands().find((c) => c.name === cmd && (c.source === "skill" || c.source === "plugin"));
-  if (!skillCmd) return null;
-  const args = parts.slice(1).join(" ").trim();
-  const userInstruction = args || skillCmd.description;
-  if (skillCmd.skillContent) {
-    let processed = await preprocessShellCommands(skillCmd.skillContent);
-    processed = substituteVariables(processed, args, context);
-    return `<skill name="${cmd}">
-${processed}
-</skill>
-
-Execute the "${cmd}" skill: ${userInstruction}`;
-  }
-  return `Use the "${cmd}" skill: ${userInstruction}`;
-}
-
-// src/ui/hooks/plugin-hooks-merger.ts
-var import_node_path2 = require("path");
-function buildPluginEnv(plugin) {
-  const dataDir = (0, import_node_path2.join)((0, import_node_path2.dirname)((0, import_node_path2.dirname)(plugin.pluginDir)), "data", plugin.manifest.name);
-  return {
-    CLAUDE_PLUGIN_ROOT: plugin.pluginDir,
-    CLAUDE_PLUGIN_PATH: plugin.pluginDir,
-    CLAUDE_PLUGIN_DATA: dataDir
+    this.notify();
   };
-}
-function resolvePluginRoot(group, pluginDir) {
-  if (Array.isArray(group.hooks)) {
-    return {
-      ...group,
-      hooks: group.hooks.map((h) => {
-        if (typeof h.command === "string") {
-          return {
-            ...h,
-            command: h.command.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, pluginDir)
-          };
-        }
-        return h;
-      })
+  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();
+  }
+  /** 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();
+  }
+  /** 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();
   }
-  return group;
-}
-function mergePluginHooks(plugins) {
-  const merged = {};
-  for (const plugin of plugins) {
-    const hooksObj = plugin.hooks;
-    if (!hooksObj) continue;
-    const pluginEnv = buildPluginEnv(plugin);
-    const innerHooks = hooksObj.hooks ?? hooksObj;
-    for (const [event, groups] of Object.entries(innerHooks)) {
-      if (!Array.isArray(groups)) continue;
-      if (!merged[event]) merged[event] = [];
-      const resolved = groups.map((group) => {
-        const r = resolvePluginRoot(group, plugin.pluginDir);
-        r.env = pluginEnv;
-        return r;
-      });
-      merged[event].push(...resolved);
-    }
-  }
-  return merged;
-}
-function mergeHooksIntoConfig(configHooks, pluginHooks) {
-  const pluginKeys = Object.keys(pluginHooks);
-  if (pluginKeys.length === 0) return configHooks;
-  const merged = {};
-  for (const [event, groups] of Object.entries(pluginHooks)) {
-    merged[event] = [...groups];
-  }
-  if (configHooks) {
-    for (const [event, groups] of Object.entries(configHooks)) {
-      if (!Array.isArray(groups)) continue;
-      if (!merged[event]) merged[event] = [];
-      merged[event].push(...groups);
-    }
-  }
-  return merged;
-}
+};
 
 // src/ui/hooks/useInteractiveSession.ts
-var MAX_RENDERED_MESSAGES = 100;
 function initializeSession(props, permissionHandler) {
-  const cwd = props.cwd ?? process.cwd();
+  const interactiveSession = new import_agent_sdk.InteractiveSession({
+    cwd: props.cwd,
+    provider: props.provider,
+    permissionMode: props.permissionMode,
+    maxTurns: props.maxTurns,
+    permissionHandler
+  });
   const registry = new import_agent_sdk.CommandRegistry();
   registry.addSource(new import_agent_sdk.BuiltinCommandSource());
-  registry.addSource(new import_agent_sdk.SkillCommandSource(cwd));
-  let pluginHooks = {};
-  const pluginsDir = (0, import_node_path3.join)((0, import_node_os.homedir)(), ".robota", "plugins");
+  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 PluginCommandSource(plugins));
-      pluginHooks = mergePluginHooks(plugins);
+      registry.addSource(new import_agent_sdk.PluginCommandSource(plugins));
     }
   } catch {
   }
-  const mergedConfig = {
-    ...props.config,
-    hooks: mergeHooksIntoConfig(
-      props.config.hooks,
-      pluginHooks
-    )
-  };
-  const interactiveSession = new import_agent_sdk.InteractiveSession({
-    config: mergedConfig,
-    context: props.context,
-    projectInfo: props.projectInfo,
-    sessionStore: props.sessionStore,
-    permissionMode: props.permissionMode,
-    maxTurns: props.maxTurns,
-    cwd,
-    permissionHandler
-  });
-  return {
-    interactiveSession,
-    registry,
-    commandExecutor: new import_agent_sdk.SystemCommandExecutor(),
-    pluginHooks
-  };
+  const manager = new TuiStateManager();
+  return { interactiveSession, registry, manager };
 }
 function useInteractiveSession(props) {
-  const [messages, setMessages] = (0, import_react.useState)([]);
-  const addMessage = (0, import_react.useCallback)((msg) => {
-    setMessages((prev) => {
-      const updated = [...prev, msg];
-      return updated.length > MAX_RENDERED_MESSAGES ? updated.slice(-MAX_RENDERED_MESSAGES) : updated;
-    });
-  }, []);
-  const [streamingText, setStreamingText] = (0, import_react.useState)("");
-  const [activeTools, setActiveTools] = (0, import_react.useState)([]);
-  const [isThinking, setIsThinking] = (0, import_react.useState)(false);
-  const [isAborting, setIsAborting] = (0, import_react.useState)(false);
-  const [pendingPrompt, setPendingPrompt] = (0, import_react.useState)(null);
-  const [contextState, setContextState] = (0, import_react.useState)({ percentage: 0, usedTokens: 0, maxTokens: 0 });
+  const [, 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);
@@ -443,79 +339,54 @@ function useInteractiveSession(props) {
   if (stateRef.current === null) {
     stateRef.current = initializeSession(props, permissionHandler);
   }
-  const { interactiveSession, registry, commandExecutor } = stateRef.current;
+  const { interactiveSession, registry, manager } = stateRef.current;
+  manager.onChange = () => forceRender((n) => n + 1);
   (0, import_react.useEffect)(() => {
-    let streamBuf = "";
-    const onTextDelta = (delta) => {
-      streamBuf += delta;
-      setStreamingText(streamBuf);
-    };
-    const onToolStart = (state) => {
-      setActiveTools((prev) => [...prev, state]);
-    };
-    const onToolEnd = (state) => {
-      setActiveTools(
-        (prev) => prev.map((t) => t.toolName === state.toolName && t.isRunning ? state : t)
-      );
-    };
-    const onThinking = (thinking) => {
-      setIsThinking(thinking);
-      if (thinking) {
-        streamBuf = "";
-        setStreamingText("");
-        setActiveTools([]);
-      } else {
-        setIsAborting(false);
+    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
+        });
+        clearInterval(initCheck);
+      } catch {
       }
-    };
-    const onComplete = (result) => {
-      setContextState({
-        percentage: result.contextState.usedPercentage,
-        usedTokens: result.contextState.usedTokens,
-        maxTokens: result.contextState.maxTokens
-      });
-    };
-    const onInterrupted = () => {
-    };
-    const onError = () => {
-    };
-    interactiveSession.on("text_delta", onTextDelta);
-    interactiveSession.on("tool_start", onToolStart);
-    interactiveSession.on("tool_end", onToolEnd);
-    interactiveSession.on("thinking", onThinking);
-    interactiveSession.on("complete", onComplete);
-    interactiveSession.on("interrupted", onInterrupted);
-    interactiveSession.on("error", onError);
+    }, 200);
     return () => {
-      interactiveSession.off("text_delta", onTextDelta);
-      interactiveSession.off("tool_start", onToolStart);
-      interactiveSession.off("tool_end", onToolEnd);
-      interactiveSession.off("thinking", onThinking);
-      interactiveSession.off("complete", onComplete);
-      interactiveSession.off("interrupted", onInterrupted);
-      interactiveSession.off("error", onError);
+      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]);
+  }, [interactiveSession, manager]);
   (0, import_react.useEffect)(() => {
-    if (!isThinking) {
-      const sessionMessages = interactiveSession.getMessages();
-      if (sessionMessages.length > 0) {
-        setMessages(
-          sessionMessages.length > MAX_RENDERED_MESSAGES ? sessionMessages.slice(-MAX_RENDERED_MESSAGES) : [...sessionMessages]
-        );
-      }
-      setPendingPrompt(interactiveSession.getPendingPrompt());
+    manager.syncHistory(interactiveSession.getFullHistory());
+    if (!manager.isThinking) {
+      manager.setPendingPrompt(interactiveSession.getPendingPrompt());
     }
-  }, [isThinking, interactiveSession]);
+  }, [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 commandExecutor.execute(cmd, interactiveSession, args);
+        const result = await interactiveSession.executeCommand(cmd, args);
         if (result) {
-          addMessage((0, import_agent_core.createSystemMessage)(result.message));
+          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;
@@ -530,7 +401,7 @@ function useInteractiveSession(props) {
             return;
           }
           const ctx = interactiveSession.getContextState();
-          setContextState({
+          manager.setContextState({
             percentage: ctx.usedPercentage,
             usedTokens: ctx.usedTokens,
             maxTokens: ctx.maxTokens
@@ -539,13 +410,23 @@ function useInteractiveSession(props) {
         }
         const skillCmd = registry.getCommands().find((c) => c.name === cmd && (c.source === "skill" || c.source === "plugin"));
         if (skillCmd) {
-          addMessage((0, import_agent_core.createSystemMessage)(`Invoking ${skillCmd.source}: ${cmd}`));
-          const prompt = await buildSkillPrompt(input, registry);
+          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);
-            setPendingPrompt(interactiveSession.getPendingPrompt());
+            manager.setPendingPrompt(interactiveSession.getPendingPrompt());
             return;
           }
         }
@@ -557,45 +438,38 @@ function useInteractiveSession(props) {
           interactiveSession._triggerPluginTUI = true;
           return;
         }
-        addMessage((0, import_agent_core.createSystemMessage)(`Unknown command "/${cmd}". Type /help for help.`));
+        manager.addEntry(
+          (0, import_agent_core.messageToHistoryEntry)(
+            (0, import_agent_core.createSystemMessage)(`Unknown command "/${cmd}". Type /help for help.`)
+          )
+        );
         return;
       }
       await interactiveSession.submit(input);
-      setPendingPrompt(interactiveSession.getPendingPrompt());
+      manager.setPendingPrompt(interactiveSession.getPendingPrompt());
     },
-    [interactiveSession, commandExecutor, registry, addMessage]
+    [interactiveSession, registry, manager]
   );
   const handleAbort = (0, import_react.useCallback)(() => {
-    setIsAborting(true);
+    manager.setAborting(true);
     interactiveSession.abort();
-  }, [interactiveSession]);
+  }, [interactiveSession, manager]);
   const handleCancelQueue = (0, import_react.useCallback)(() => {
     interactiveSession.cancelQueue();
-    setPendingPrompt(null);
-  }, [interactiveSession]);
-  if (contextState.maxTokens === 0) {
-    const ctx = interactiveSession.getContextState();
-    setContextState({
-      percentage: ctx.usedPercentage,
-      usedTokens: ctx.usedTokens,
-      maxTokens: ctx.maxTokens
-    });
-  }
+    manager.setPendingPrompt(null);
+  }, [interactiveSession, manager]);
   return {
     interactiveSession,
     registry,
-    commandExecutor,
-    pluginHooks: stateRef.current.pluginHooks,
-    messages,
-    addMessage,
-    setMessages,
-    streamingText,
-    activeTools,
-    isThinking,
-    isAborting,
-    pendingPrompt,
+    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,
+    contextState: manager.contextState,
     handleSubmit,
     handleAbort,
     handleCancelQueue
@@ -604,12 +478,12 @@ function useInteractiveSession(props) {
 
 // src/ui/hooks/usePluginCallbacks.ts
 var import_react2 = require("react");
-var import_node_os2 = require("os");
+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_os2.homedir)();
+    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);
@@ -869,8 +743,45 @@ var MessageItem = import_react3.default.memo(function MessageItem2({
     /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Box, { marginLeft: 2, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Text, { wrap: "wrap", children: (0, import_agent_core2.isAssistantMessage)(message) ? renderMarkdown(content + (isInterrupted ? "\n\n_(interrupted)_" : "")) : content }) })
   ] });
 });
-function MessageList({ messages }) {
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_ink2.Box, { flexDirection: "column", children: messages.map((msg) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(MessageItem, { message: msg }, msg.id)) });
+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 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 });
+  }
+  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
@@ -1979,12 +1890,12 @@ var import_jsx_runtime14 = require("react/jsx-runtime");
 var EXIT_DELAY_MS = 500;
 function App(props) {
   const { exit } = (0, import_ink13.useApp)();
-  const cwd = props.cwd ?? process.cwd();
+  const cwd = props.cwd;
   const {
     interactiveSession,
     registry,
-    messages,
-    addMessage,
+    history,
+    addEntry,
     streamingText,
     activeTools,
     isThinking,
@@ -1996,13 +1907,10 @@ function App(props) {
     handleAbort,
     handleCancelQueue
   } = useInteractiveSession({
-    config: props.config,
-    context: props.context,
-    projectInfo: props.projectInfo,
-    sessionStore: props.sessionStore,
+    cwd,
+    provider: props.provider,
     permissionMode: props.permissionMode,
-    maxTurns: props.maxTurns,
-    cwd
+    maxTurns: props.maxTurns
   });
   const pluginCallbacks = usePluginCallbacks(cwd);
   const [pendingModelId, setPendingModelId] = (0, import_react12.useState)(null);
@@ -2025,7 +1933,9 @@ function App(props) {
       const settings = readSettings(settingsPath);
       settings.language = lang;
       writeSettings(settingsPath, settings);
-      addMessage((0, import_agent_core4.createSystemMessage)(`Language set to "${lang}". Restarting...`));
+      addEntry(
+        (0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)(`Language set to "${lang}". Restarting...`))
+      );
       setTimeout(() => exit(), EXIT_DELAY_MS);
       return;
     }
@@ -2033,9 +1943,9 @@ function App(props) {
       delete sideEffects._resetRequested;
       const settingsPath = getUserSettingsPath();
       if (deleteSettings(settingsPath)) {
-        addMessage((0, import_agent_core4.createSystemMessage)(`Deleted ${settingsPath}. Exiting...`));
+        addEntry((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)(`Deleted ${settingsPath}. Exiting...`)));
       } else {
-        addMessage((0, import_agent_core4.createSystemMessage)("No user settings found."));
+        addEntry((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)("No user settings found.")));
       }
       setTimeout(() => exit(), EXIT_DELAY_MS);
       return;
@@ -2059,7 +1969,14 @@ function App(props) {
     },
     { isActive: !permissionRequest && !showPluginTUI }
   );
-  const session = interactiveSession.getSession();
+  let permissionMode = props.permissionMode ?? "default";
+  let sessionId = "";
+  try {
+    const session = interactiveSession.getSession();
+    permissionMode = session.getPermissionMode();
+    sessionId = session.getSessionId();
+  } catch {
+  }
   return /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_ink13.Box, { flexDirection: "column", children: [
     /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_ink13.Box, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
       /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_ink13.Text, { color: "cyan", bold: true, children: `
@@ -2075,7 +1992,7 @@ function App(props) {
       ] })
     ] }),
     /* @__PURE__ */ (0, import_jsx_runtime14.jsxs)(import_ink13.Box, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(MessageList, { messages }),
+      /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(MessageList, { history }),
       (isThinking || activeTools.length > 0) && /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_ink13.Box, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(StreamingIndicator, { text: streamingText, activeTools }) })
     ] }),
     permissionRequest && /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(PermissionPrompt, { request: permissionRequest }),
@@ -2090,21 +2007,25 @@ function App(props) {
             try {
               const settingsPath = getUserSettingsPath();
               updateModelInSettings(settingsPath, pendingModelId);
-              addMessage(
-                (0, import_agent_core4.createSystemMessage)(
-                  `Model changed to ${(0, import_agent_core4.getModelName)(pendingModelId)}. Restarting...`
+              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) {
-              addMessage(
-                (0, import_agent_core4.createSystemMessage)(
-                  `Failed: ${err instanceof Error ? err.message : String(err)}`
+              addEntry(
+                (0, import_agent_core4.messageToHistoryEntry)(
+                  (0, import_agent_core4.createSystemMessage)(
+                    `Failed: ${err instanceof Error ? err.message : String(err)}`
+                  )
                 )
               );
             }
           } else {
-            addMessage((0, import_agent_core4.createSystemMessage)("Model change cancelled."));
+            addEntry((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)("Model change cancelled.")));
           }
         }
       }
@@ -2114,16 +2035,16 @@ function App(props) {
       {
         callbacks: pluginCallbacks,
         onClose: () => setShowPluginTUI(false),
-        addMessage: (msg) => addMessage((0, import_agent_core4.createSystemMessage)(msg.content))
+        addMessage: (msg) => addEntry((0, import_agent_core4.messageToHistoryEntry)((0, import_agent_core4.createSystemMessage)(msg.content)))
       }
     ),
     /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(
       StatusBar,
       {
-        permissionMode: session.getPermissionMode(),
-        modelName: (0, import_agent_core4.getModelName)(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: contextState.percentage,
         contextUsedTokens: contextState.usedTokens,
@@ -2181,9 +2102,9 @@ function renderApp(options) {
 // src/cli.ts
 var import_meta = {};
 function checkSettingsFile(filePath) {
-  if (!(0, import_node_fs2.existsSync)(filePath)) return "missing";
+  if (!(0, import_node_fs3.existsSync)(filePath)) return "missing";
   try {
-    const raw = (0, import_node_fs2.readFileSync)(filePath, "utf8").trim();
+    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;
@@ -2200,7 +2121,7 @@ function readVersion() {
     const candidates = [(0, import_node_path5.join)(dir, "..", "..", "package.json"), (0, import_node_path5.join)(dir, "..", "package.json")];
     for (const pkgPath of candidates) {
       try {
-        const raw = (0, import_node_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;
@@ -2288,7 +2209,7 @@ async function ensureConfig(cwd) {
   }
   const language = await promptInput("  Response language (ko/en/ja/zh, default: en): ");
   const settingsDir = (0, import_node_path5.dirname)(userPath);
-  (0, import_node_fs2.mkdirSync)(settingsDir, { recursive: true });
+  (0, import_node_fs3.mkdirSync)(settingsDir, { recursive: true });
   const settings = {
     provider: {
       name: "anthropic",
@@ -2299,7 +2220,7 @@ async function ensureConfig(cwd) {
   if (language) {
     settings.language = language;
   }
-  (0, import_node_fs2.writeFileSync)(userPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
+  (0, import_node_fs3.writeFileSync)(userPath, JSON.stringify(settings, null, 2) + "\n", "utf8");
   process.stdout.write(`
   Config saved to ${userPath}
 
@@ -2327,44 +2248,40 @@ async function startCli() {
   }
   const cwd = process.cwd();
   await ensureConfig(cwd);
-  const [config, context, projectInfo] = await Promise.all([
-    (0, import_agent_sdk3.loadConfig)(cwd),
-    (0, import_agent_sdk3.loadContext)(cwd),
-    (0, import_agent_sdk3.detectProject)(cwd)
-  ]);
-  if (args.model !== void 0) {
-    config.provider.model = args.model;
-  }
-  if (args.language !== void 0) {
-    config.language = args.language;
-  }
-  const sessionStore = new import_agent_sdk3.SessionStore();
+  const providerSettings = readProviderSettings(cwd);
+  const modelId = args.model ?? providerSettings.model;
+  const provider = createProviderFromSettings(cwd, args.model);
   if (args.printMode) {
     const prompt = args.positional.join(" ").trim();
     if (prompt.length === 0) {
       process.stderr.write("Print mode (-p) requires a prompt argument.\n");
       process.exit(1);
     }
-    const terminal = new PrintTerminal();
-    const paths = (0, import_agent_sdk3.projectPaths)(cwd);
-    const session = (0, import_agent_sdk3.createSession)({
-      config,
-      context,
-      terminal,
-      sessionLogger: new import_agent_sdk3.FileSessionLogger(paths.logs),
-      projectInfo,
-      permissionMode: args.permissionMode,
-      promptForApproval: import_agent_sdk4.promptForApproval
+    const session = new import_agent_sdk3.InteractiveSession({
+      cwd,
+      provider,
+      permissionMode: args.permissionMode ?? "bypassPermissions",
+      maxTurns: args.maxTurns
+    });
+    await new Promise((resolve, reject) => {
+      session.on("complete", (result) => {
+        process.stdout.write(result.response + "\n");
+        resolve();
+      });
+      session.on("interrupted", (result) => {
+        if (result.response) process.stdout.write(result.response + "\n");
+        resolve();
+      });
+      session.on("error", (err) => reject(err));
+      session.submit(prompt).catch(reject);
     });
-    const response = await session.run(prompt);
-    process.stdout.write(response + "\n");
     return;
   }
   renderApp({
-    config,
-    context,
-    projectInfo,
-    sessionStore,
+    cwd,
+    provider,
+    modelId,
+    language: args.language,
     permissionMode: args.permissionMode,
     maxTurns: args.maxTurns,
     version: readVersion()
@@ -2372,9 +2289,5 @@ async function startCli() {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Session,
-  SessionStore,
-  TRUST_TO_MODE,
-  query,
   startCli
 });