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

package/dist/node/{chunk-SYGOHAAL.js → chunk-Y6VSMUKG.js}

@@ -1,17 +1,8 @@
 // src/cli.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join5, dirname as dirname3 } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
-import {
-  loadConfig,
-  loadContext,
-  detectProject,
-  createSession,
-  SessionStore,
-  FileSessionLogger,
-  projectPaths
-} from "@robota-sdk/agent-sdk";
-import { promptForApproval } from "@robota-sdk/agent-sdk";
+import { InteractiveSession as InteractiveSession2 } from "@robota-sdk/agent-sdk";
 
 // src/utils/cli-args.ts
 import { parseArgs } from "util";
@@ -94,56 +85,49 @@ function deleteSettings(path) {
   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]}
-`);
+// src/utils/provider-factory.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir } from "os";
+import { AnthropicProvider } from "@robota-sdk/agent-provider-anthropic";
+function readProviderSettings(cwd) {
+  const paths = [
+    join2(cwd, ".robota", "settings.local.json"),
+    join2(cwd, ".robota", "settings.json"),
+    join2(cwd, ".claude", "settings.local.json"),
+    join2(cwd, ".claude", "settings.json"),
+    join2(homedir(), ".robota", "settings.json"),
+    join2(homedir(), ".claude", "settings.json")
+  ];
+  for (const filePath of paths) {
+    if (!existsSync2(filePath)) continue;
+    try {
+      const raw = readFileSync2(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 AnthropicProvider({ apiKey: settings.apiKey, defaultModel: model });
+    default:
+      throw new Error(`Unknown provider: ${settings.name}. Currently supported: anthropic`);
   }
-};
+}
 
 // src/ui/render.tsx
 import { render } from "ink";
@@ -151,238 +135,148 @@ import { render } from "ink";
 // src/ui/App.tsx
 import { useState as useState9, useRef as useRef7 } from "react";
 import { Box as Box11, Text as Text13, useApp, useInput as useInput7 } from "ink";
-import { getModelName, createSystemMessage as createSystemMessage2 } from "@robota-sdk/agent-core";
+import { getModelName, createSystemMessage as createSystemMessage2, messageToHistoryEntry as messageToHistoryEntry2 } from "@robota-sdk/agent-core";
 
 // src/ui/hooks/useInteractiveSession.ts
 import { useState, useRef, useCallback, useEffect } from "react";
-import { homedir } from "os";
+import { homedir as homedir2 } from "os";
 import { join as join3 } from "path";
 import {
   InteractiveSession,
   CommandRegistry,
   BuiltinCommandSource,
   SkillCommandSource,
-  SystemCommandExecutor,
-  BundlePluginLoader
+  PluginCommandSource,
+  BundlePluginLoader,
+  buildSkillPrompt
 } from "@robota-sdk/agent-sdk";
-import { createSystemMessage } from "@robota-sdk/agent-core";
-
-// 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;
-  }
-};
+import { createSystemMessage, messageToHistoryEntry } from "@robota-sdk/agent-core";
+import { randomUUID } from "crypto";
 
-// src/utils/skill-prompt.ts
-import { execSync } from "child_process";
-function substituteVariables(content, args, context) {
-  const argParts = args ? args.split(/\s+/) : [];
-  let result = content;
-  result = result.replace(/\$ARGUMENTS\[(\d+)]/g, (_match, index) => {
-    return argParts[Number(index)] ?? "";
-  });
-  result = result.replace(/\$ARGUMENTS/g, args);
-  result = result.replace(/\$(\d)(?!\d|\w|\[)/g, (_match, digit) => {
-    return argParts[Number(digit)] ?? "";
-  });
-  result = result.replace(/\$\{CLAUDE_SESSION_ID}/g, context?.sessionId ?? "");
-  result = result.replace(/\$\{CLAUDE_SKILL_DIR}/g, context?.skillDir ?? "");
-  return result;
-}
-async function preprocessShellCommands(content) {
-  const shellPattern = /!`([^`]+)`/g;
-  if (!shellPattern.test(content)) {
-    return content;
-  }
-  shellPattern.lastIndex = 0;
-  let result = content;
-  let match;
-  const matches = [];
-  while ((match = shellPattern.exec(content)) !== null) {
-    matches.push({ full: match[0], command: match[1] });
-  }
-  for (const { full, command } of matches) {
-    let output = "";
-    try {
-      output = execSync(command, {
-        timeout: 5e3,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trimEnd();
-    } catch {
-      output = "";
+// 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
-import { join as join2, dirname as dirname2 } from "path";
-function buildPluginEnv(plugin) {
-  const dataDir = join2(dirname2(dirname2(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 InteractiveSession({
+    cwd: props.cwd,
+    provider: props.provider,
+    permissionMode: props.permissionMode,
+    maxTurns: props.maxTurns,
+    permissionHandler
+  });
   const registry = new CommandRegistry();
   registry.addSource(new BuiltinCommandSource());
-  registry.addSource(new SkillCommandSource(cwd));
-  let pluginHooks = {};
-  const pluginsDir = join3(homedir(), ".robota", "plugins");
+  registry.addSource(new SkillCommandSource(props.cwd));
+  const pluginsDir = join3(homedir2(), ".robota", "plugins");
   const loader = new BundlePluginLoader(pluginsDir);
   try {
     const plugins = loader.loadPluginsSync();
     if (plugins.length > 0) {
       registry.addSource(new PluginCommandSource(plugins));
-      pluginHooks = mergePluginHooks(plugins);
     }
   } catch {
   }
-  const mergedConfig = {
-    ...props.config,
-    hooks: mergeHooksIntoConfig(
-      props.config.hooks,
-      pluginHooks
-    )
-  };
-  const interactiveSession = new 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 SystemCommandExecutor(),
-    pluginHooks
-  };
+  const manager = new TuiStateManager();
+  return { interactiveSession, registry, manager };
 }
 function useInteractiveSession(props) {
-  const [messages, setMessages] = useState([]);
-  const addMessage = useCallback((msg) => {
-    setMessages((prev) => {
-      const updated = [...prev, msg];
-      return updated.length > MAX_RENDERED_MESSAGES ? updated.slice(-MAX_RENDERED_MESSAGES) : updated;
-    });
-  }, []);
-  const [streamingText, setStreamingText] = useState("");
-  const [activeTools, setActiveTools] = useState([]);
-  const [isThinking, setIsThinking] = useState(false);
-  const [isAborting, setIsAborting] = useState(false);
-  const [pendingPrompt, setPendingPrompt] = useState(null);
-  const [contextState, setContextState] = useState({ percentage: 0, usedTokens: 0, maxTokens: 0 });
+  const [, forceRender] = useState(0);
   const [permissionRequest, setPermissionRequest] = useState(null);
   const permissionQueueRef = useRef([]);
   const processingRef = useRef(false);
@@ -417,79 +311,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);
   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]);
   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 = 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(createSystemMessage(result.message));
+          manager.addEntry(messageToHistoryEntry(createSystemMessage(result.message)));
           const effects = interactiveSession;
           if (result.data?.modelId) {
             effects._pendingModelId = result.data.modelId;
@@ -504,7 +373,7 @@ function useInteractiveSession(props) {
             return;
           }
           const ctx = interactiveSession.getContextState();
-          setContextState({
+          manager.setContextState({
             percentage: ctx.usedPercentage,
             usedTokens: ctx.usedTokens,
             maxTokens: ctx.maxTokens
@@ -513,13 +382,23 @@ function useInteractiveSession(props) {
         }
         const skillCmd = registry.getCommands().find((c) => c.name === cmd && (c.source === "skill" || c.source === "plugin"));
         if (skillCmd) {
-          addMessage(createSystemMessage(`Invoking ${skillCmd.source}: ${cmd}`));
+          manager.addEntry({
+            id: randomUUID(),
+            timestamp: /* @__PURE__ */ new Date(),
+            category: "event",
+            type: "skill-invocation",
+            data: {
+              skillName: cmd,
+              source: skillCmd.source,
+              message: `Invoking ${skillCmd.source}: ${cmd}`
+            }
+          });
           const prompt = await 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;
           }
         }
@@ -531,45 +410,38 @@ function useInteractiveSession(props) {
           interactiveSession._triggerPluginTUI = true;
           return;
         }
-        addMessage(createSystemMessage(`Unknown command "/${cmd}". Type /help for help.`));
+        manager.addEntry(
+          messageToHistoryEntry(
+            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 = useCallback(() => {
-    setIsAborting(true);
+    manager.setAborting(true);
     interactiveSession.abort();
-  }, [interactiveSession]);
+  }, [interactiveSession, manager]);
   const handleCancelQueue = 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
@@ -578,7 +450,7 @@ function useInteractiveSession(props) {
 
 // src/ui/hooks/usePluginCallbacks.ts
 import { useMemo } from "react";
-import { homedir as homedir2 } from "os";
+import { homedir as homedir3 } from "os";
 import { join as join4 } from "path";
 import {
   PluginSettingsStore,
@@ -588,7 +460,7 @@ import {
 } from "@robota-sdk/agent-sdk";
 function usePluginCallbacks(cwd) {
   return useMemo(() => {
-    const home = homedir2();
+    const home = homedir3();
     const pluginsDir = join4(home, ".robota", "plugins");
     const userSettingsPath = join4(home, ".robota", "settings.json");
     const settingsStore = new PluginSettingsStore(userSettingsPath);
@@ -848,8 +720,45 @@ var MessageItem = React2.memo(function MessageItem2({
     /* @__PURE__ */ jsx(Box2, { marginLeft: 2, children: /* @__PURE__ */ jsx(Text2, { wrap: "wrap", children: isAssistantMessage(message) ? renderMarkdown(content + (isInterrupted ? "\n\n_(interrupted)_" : "")) : content }) })
   ] });
 });
-function MessageList({ messages }) {
-  return /* @__PURE__ */ jsx(Box2, { flexDirection: "column", children: messages.map((msg) => /* @__PURE__ */ jsx(MessageItem, { message: msg }, msg.id)) });
+function ToolSummaryEntry({ entry }) {
+  const data = entry.data;
+  const lines = data?.summary?.split("\n") ?? [];
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Box2, { children: /* @__PURE__ */ jsxs2(Text2, { color: "white", bold: true, children: [
+      "Tool:",
+      " "
+    ] }) }),
+    /* @__PURE__ */ jsx(Text2, { children: " " }),
+    lines.map((line, i) => /* @__PURE__ */ jsxs2(Text2, { 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__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx(Box2, { children: /* @__PURE__ */ jsxs2(Text2, { color: "yellow", bold: true, children: [
+      "System:",
+      " "
+    ] }) }),
+    /* @__PURE__ */ jsx(Text2, { children: " " }),
+    /* @__PURE__ */ jsx(Box2, { marginLeft: 2, children: /* @__PURE__ */ jsx(Text2, { wrap: "wrap", children: eventMessage }) })
+  ] });
+}
+function EntryItem({ entry }) {
+  if (entry.category === "chat") {
+    const message = entry.data;
+    return /* @__PURE__ */ jsx(MessageItem, { message });
+  }
+  if (entry.type === "tool-summary") {
+    return /* @__PURE__ */ jsx(ToolSummaryEntry, { entry });
+  }
+  return /* @__PURE__ */ jsx(EventEntry, { entry });
+}
+function MessageList({ history }) {
+  return /* @__PURE__ */ jsx(Box2, { flexDirection: "column", children: history.map((entry) => /* @__PURE__ */ jsx(EntryItem, { entry }, entry.id)) });
 }
 
 // src/ui/StatusBar.tsx
@@ -1958,12 +1867,12 @@ import { jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
 var EXIT_DELAY_MS = 500;
 function App(props) {
   const { exit } = useApp();
-  const cwd = props.cwd ?? process.cwd();
+  const cwd = props.cwd;
   const {
     interactiveSession,
     registry,
-    messages,
-    addMessage,
+    history,
+    addEntry,
     streamingText,
     activeTools,
     isThinking,
@@ -1975,13 +1884,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] = useState9(null);
@@ -2004,7 +1910,9 @@ function App(props) {
       const settings = readSettings(settingsPath);
       settings.language = lang;
       writeSettings(settingsPath, settings);
-      addMessage(createSystemMessage2(`Language set to "${lang}". Restarting...`));
+      addEntry(
+        messageToHistoryEntry2(createSystemMessage2(`Language set to "${lang}". Restarting...`))
+      );
       setTimeout(() => exit(), EXIT_DELAY_MS);
       return;
     }
@@ -2012,9 +1920,9 @@ function App(props) {
       delete sideEffects._resetRequested;
       const settingsPath = getUserSettingsPath();
       if (deleteSettings(settingsPath)) {
-        addMessage(createSystemMessage2(`Deleted ${settingsPath}. Exiting...`));
+        addEntry(messageToHistoryEntry2(createSystemMessage2(`Deleted ${settingsPath}. Exiting...`)));
       } else {
-        addMessage(createSystemMessage2("No user settings found."));
+        addEntry(messageToHistoryEntry2(createSystemMessage2("No user settings found.")));
       }
       setTimeout(() => exit(), EXIT_DELAY_MS);
       return;
@@ -2038,7 +1946,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__ */ jsxs11(Box11, { flexDirection: "column", children: [
     /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", paddingX: 1, marginBottom: 1, children: [
       /* @__PURE__ */ jsx13(Text13, { color: "cyan", bold: true, children: `
@@ -2054,7 +1969,7 @@ function App(props) {
       ] })
     ] }),
     /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [
-      /* @__PURE__ */ jsx13(MessageList, { messages }),
+      /* @__PURE__ */ jsx13(MessageList, { history }),
       (isThinking || activeTools.length > 0) && /* @__PURE__ */ jsx13(Box11, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsx13(StreamingIndicator, { text: streamingText, activeTools }) })
     ] }),
     permissionRequest && /* @__PURE__ */ jsx13(PermissionPrompt, { request: permissionRequest }),
@@ -2069,21 +1984,25 @@ function App(props) {
             try {
               const settingsPath = getUserSettingsPath();
               updateModelInSettings(settingsPath, pendingModelId);
-              addMessage(
-                createSystemMessage2(
-                  `Model changed to ${getModelName(pendingModelId)}. Restarting...`
+              addEntry(
+                messageToHistoryEntry2(
+                  createSystemMessage2(
+                    `Model changed to ${getModelName(pendingModelId)}. Restarting...`
+                  )
                 )
               );
               setTimeout(() => exit(), EXIT_DELAY_MS);
             } catch (err) {
-              addMessage(
-                createSystemMessage2(
-                  `Failed: ${err instanceof Error ? err.message : String(err)}`
+              addEntry(
+                messageToHistoryEntry2(
+                  createSystemMessage2(
+                    `Failed: ${err instanceof Error ? err.message : String(err)}`
+                  )
                 )
               );
             }
           } else {
-            addMessage(createSystemMessage2("Model change cancelled."));
+            addEntry(messageToHistoryEntry2(createSystemMessage2("Model change cancelled.")));
           }
         }
       }
@@ -2093,16 +2012,16 @@ function App(props) {
       {
         callbacks: pluginCallbacks,
         onClose: () => setShowPluginTUI(false),
-        addMessage: (msg) => addMessage(createSystemMessage2(msg.content))
+        addMessage: (msg) => addEntry(messageToHistoryEntry2(createSystemMessage2(msg.content)))
       }
     ),
     /* @__PURE__ */ jsx13(
       StatusBar,
       {
-        permissionMode: session.getPermissionMode(),
-        modelName: getModelName(props.config.provider.model),
-        sessionId: session.getSessionId(),
-        messageCount: messages.length,
+        permissionMode,
+        modelName: props.modelId ? getModelName(props.modelId) : "",
+        sessionId,
+        messageCount: history.length,
         isThinking,
         contextPercentage: contextState.percentage,
         contextUsedTokens: contextState.usedTokens,
@@ -2159,9 +2078,9 @@ function renderApp(options) {
 
 // src/cli.ts
 function checkSettingsFile(filePath) {
-  if (!existsSync2(filePath)) return "missing";
+  if (!existsSync3(filePath)) return "missing";
   try {
-    const raw = readFileSync2(filePath, "utf8").trim();
+    const raw = readFileSync3(filePath, "utf8").trim();
     if (raw.length === 0) return "incomplete";
     const parsed = JSON.parse(raw);
     const provider = parsed.provider;
@@ -2174,11 +2093,11 @@ function checkSettingsFile(filePath) {
 function readVersion() {
   try {
     const thisFile = fileURLToPath(import.meta.url);
-    const dir = dirname3(thisFile);
+    const dir = dirname2(thisFile);
     const candidates = [join5(dir, "..", "..", "package.json"), join5(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;
@@ -2265,7 +2184,7 @@ async function ensureConfig(cwd) {
     process.exit(1);
   }
   const language = await promptInput("  Response language (ko/en/ja/zh, default: en): ");
-  const settingsDir = dirname3(userPath);
+  const settingsDir = dirname2(userPath);
   mkdirSync2(settingsDir, { recursive: true });
   const settings = {
     provider: {
@@ -2305,44 +2224,40 @@ async function startCli() {
   }
   const cwd = process.cwd();
   await ensureConfig(cwd);
-  const [config, context, projectInfo] = await Promise.all([
-    loadConfig(cwd),
-    loadContext(cwd),
-    detectProject(cwd)
-  ]);
-  if (args.model !== void 0) {
-    config.provider.model = args.model;
-  }
-  if (args.language !== void 0) {
-    config.language = args.language;
-  }
-  const sessionStore = new SessionStore();
+  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 = projectPaths(cwd);
-    const session = createSession({
-      config,
-      context,
-      terminal,
-      sessionLogger: new FileSessionLogger(paths.logs),
-      projectInfo,
-      permissionMode: args.permissionMode,
-      promptForApproval
+    const session = new InteractiveSession2({
+      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()