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

package/dist/node/{chunk-CRPNSO52.js → chunk-KX3JUGSB.js}

@@ -1,15 +1,15 @@
 // src/cli.ts
-import { readFileSync as readFileSync4, existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+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 { fileURLToPath } from "url";
 import {
   loadConfig,
   loadContext,
   detectProject,
-  createSession as createSession2,
+  createSession,
   SessionStore,
-  FileSessionLogger as FileSessionLogger2,
-  projectPaths as projectPaths2
+  FileSessionLogger,
+  projectPaths
 } from "@robota-sdk/agent-sdk";
 import { promptForApproval } from "@robota-sdk/agent-sdk";
 
@@ -149,615 +149,57 @@ var PrintTerminal = class {
 import { render } from "ink";
 
 // src/ui/App.tsx
-import { useState as useState10, useRef as useRef8, useEffect as useEffect3, useCallback as useCallback10 } from "react";
+import { useState as useState9, useRef as useRef7 } from "react";
 import { Box as Box11, Text as Text13, useApp, useInput as useInput7 } from "ink";
-import { getModelName } from "@robota-sdk/agent-core";
-import { createSystemMessage as createSystemMessage3 } from "@robota-sdk/agent-core";
+import { getModelName, createSystemMessage as createSystemMessage2 } from "@robota-sdk/agent-core";
 
-// src/ui/hooks/useSession.ts
-import { useState, useCallback, useRef } from "react";
-import { createSession, FileSessionLogger, projectPaths } from "@robota-sdk/agent-sdk";
-
-// src/utils/edit-diff.ts
-import { readFileSync as readFileSync2 } from "fs";
-var CONTEXT_LINES = 2;
-function generateDiffLines(oldStr, newStr, startLine = 1) {
-  if (oldStr === newStr) return [];
-  const lines = [];
-  const oldLines = oldStr.split("\n");
-  const newLines = newStr.split("\n");
-  for (let i = 0; i < oldLines.length; i++) {
-    lines.push({ type: "remove", text: oldLines[i], lineNumber: startLine + i });
-  }
-  for (let i = 0; i < newLines.length; i++) {
-    lines.push({ type: "add", text: newLines[i], lineNumber: startLine + i });
-  }
-  return lines;
-}
-function generateDiffLinesWithContext(oldStr, newStr, startLine, filePath) {
-  if (oldStr === newStr) return [];
-  const diffLines = generateDiffLines(oldStr, newStr, startLine);
-  let fileLines;
-  try {
-    fileLines = readFileSync2(filePath, "utf-8").split("\n");
-  } catch {
-    return diffLines;
-  }
-  const result = [];
-  const contextStart = Math.max(0, startLine - 1 - CONTEXT_LINES);
-  for (let i = contextStart; i < startLine - 1; i++) {
-    if (i < fileLines.length) {
-      result.push({ type: "context", text: fileLines[i], lineNumber: i + 1 });
-    }
-  }
-  result.push(...diffLines);
-  const newLineCount = newStr.split("\n").length;
-  const afterStart = startLine - 1 + newLineCount;
-  for (let i = afterStart; i < afterStart + CONTEXT_LINES; i++) {
-    if (i < fileLines.length) {
-      result.push({ type: "context", text: fileLines[i], lineNumber: i + 1 });
-    }
-  }
-  return result;
-}
-function extractEditDiff(toolName, toolArgs, startLine) {
-  if (toolName !== "Edit" || !toolArgs) return null;
-  const filePath = toolArgs.file_path ?? toolArgs.filePath;
-  const oldStr = toolArgs.old_string ?? toolArgs.oldString;
-  const newStr = toolArgs.new_string ?? toolArgs.newString;
-  if (typeof filePath !== "string") return null;
-  if (typeof oldStr !== "string" || typeof newStr !== "string") return null;
-  let sl = startLine ?? 0;
-  if (!sl) {
-    try {
-      const fileContent = readFileSync2(filePath, "utf-8");
-      const idx = fileContent.indexOf(newStr);
-      if (idx >= 0) {
-        sl = fileContent.substring(0, idx).split("\n").length;
-      } else {
-        sl = 1;
-      }
-    } catch {
-      sl = 1;
-    }
-  }
-  const lines = generateDiffLinesWithContext(oldStr, newStr, sl, filePath);
-  if (lines.length === 0) return null;
-  return { file: filePath, lines };
-}
-
-// src/ui/hooks/useSession.ts
-var TOOL_ARG_DISPLAY_MAX = 80;
-var TAIL_KEEP = 30;
-var MAX_COMPLETED_TOOLS = 50;
-var NOOP_TERMINAL = {
-  write: () => {
-  },
-  writeLine: () => {
-  },
-  writeMarkdown: () => {
-  },
-  writeError: () => {
-  },
-  prompt: () => Promise.resolve(""),
-  select: () => Promise.resolve(0),
-  spinner: () => ({ stop: () => {
-  }, update: () => {
-  } })
-};
-function useSession(props) {
-  const [permissionRequest, setPermissionRequest] = useState(null);
-  const [streamingText, setStreamingText] = useState("");
-  const streamingTextRef = useRef("");
-  const [activeTools, setActiveTools] = useState([]);
-  const permissionQueueRef = useRef([]);
-  const processingRef = useRef(false);
-  const processNextPermission = useCallback(() => {
-    if (processingRef.current) return;
-    const next = permissionQueueRef.current[0];
-    if (!next) {
-      setPermissionRequest(null);
-      return;
-    }
-    processingRef.current = true;
-    setPermissionRequest({
-      toolName: next.toolName,
-      toolArgs: next.toolArgs,
-      resolve: (result) => {
-        permissionQueueRef.current.shift();
-        processingRef.current = false;
-        setPermissionRequest(null);
-        next.resolve(result);
-        setTimeout(() => processNextPermission(), 0);
-      }
-    });
-  }, []);
-  const sessionRef = useRef(null);
-  if (sessionRef.current === null) {
-    const permissionHandler = (toolName, toolArgs) => {
-      return new Promise((resolve) => {
-        permissionQueueRef.current.push({ toolName, toolArgs, resolve });
-        processNextPermission();
-      });
-    };
-    let flushTimer = null;
-    const onTextDelta = (delta) => {
-      streamingTextRef.current += delta;
-      if (!flushTimer) {
-        flushTimer = setTimeout(() => {
-          setStreamingText(streamingTextRef.current);
-          flushTimer = null;
-        }, 16);
-      }
-    };
-    const onToolExecution = (event) => {
-      if (event.type === "start") {
-        let firstArg = "";
-        if (event.toolArgs) {
-          const firstVal = Object.values(event.toolArgs)[0];
-          const raw = typeof firstVal === "string" ? firstVal : JSON.stringify(firstVal ?? "");
-          firstArg = raw.length > TOOL_ARG_DISPLAY_MAX ? raw.slice(0, TOOL_ARG_DISPLAY_MAX - TAIL_KEEP - 3) + "..." + raw.slice(-TAIL_KEEP) : raw;
-        }
-        setActiveTools((prev) => [
-          ...prev,
-          { toolName: event.toolName, firstArg, isRunning: true, _toolArgs: event.toolArgs }
-        ]);
-      } else {
-        const toolResult = event.denied ? "denied" : event.success === false ? "error" : "success";
-        setActiveTools((prev) => {
-          const updated = prev.map((t) => {
-            if (!(t.toolName === event.toolName && t.isRunning)) return t;
-            let startLine;
-            if (event.toolResultData && event.toolName === "Edit") {
-              try {
-                const parsed = JSON.parse(event.toolResultData);
-                if (typeof parsed.startLine === "number") {
-                  startLine = parsed.startLine;
-                }
-              } catch {
-              }
-            }
-            const editDiff = extractEditDiff(
-              event.toolName,
-              t._toolArgs,
-              startLine
-            );
-            const finished = {
-              ...t,
-              isRunning: false,
-              result: toolResult
-            };
-            if (editDiff) {
-              finished.diffLines = editDiff.lines;
-              finished.diffFile = editDiff.file;
-            }
-            delete finished._toolArgs;
-            return finished;
-          });
-          const completed = updated.filter((t) => !t.isRunning);
-          if (completed.length > MAX_COMPLETED_TOOLS) {
-            const excess = completed.length - MAX_COMPLETED_TOOLS;
-            let removed = 0;
-            return updated.filter((t) => {
-              if (!t.isRunning && removed < excess) {
-                removed++;
-                return false;
-              }
-              return true;
-            });
-          }
-          return updated;
-        });
-      }
-    };
-    const paths = projectPaths(props.cwd ?? process.cwd());
-    sessionRef.current = createSession({
-      config: props.config,
-      context: props.context,
-      terminal: NOOP_TERMINAL,
-      sessionLogger: new FileSessionLogger(paths.logs),
-      projectInfo: props.projectInfo,
-      sessionStore: props.sessionStore,
-      permissionMode: props.permissionMode,
-      maxTurns: props.maxTurns,
-      permissionHandler,
-      onTextDelta,
-      onToolExecution
-    });
-  }
-  const clearStreamingText = useCallback(() => {
-    setStreamingText("");
-    streamingTextRef.current = "";
-    setActiveTools([]);
-  }, []);
-  return {
-    session: sessionRef.current,
-    permissionRequest,
-    streamingText,
-    clearStreamingText,
-    activeTools
-  };
-}
-
-// src/ui/hooks/useMessages.ts
-import { useState as useState2, useCallback as useCallback2 } from "react";
-var MAX_RENDERED_MESSAGES = 100;
-function useMessages() {
-  const [messages, setMessages] = useState2([]);
-  const addMessage = useCallback2((msg) => {
-    setMessages((prev) => {
-      const updated = [...prev, msg];
-      if (updated.length > MAX_RENDERED_MESSAGES) {
-        return updated.slice(-MAX_RENDERED_MESSAGES);
-      }
-      return updated;
-    });
-  }, []);
-  return { messages, setMessages, addMessage };
-}
-
-// src/ui/hooks/useSlashCommands.ts
-import { useCallback as useCallback3 } from "react";
+// src/ui/hooks/useInteractiveSession.ts
+import { useState, useRef, useCallback, useEffect } from "react";
+import { homedir } from "os";
+import { join as join3 } from "path";
+import {
+  InteractiveSession,
+  CommandRegistry,
+  BuiltinCommandSource,
+  SkillCommandSource,
+  SystemCommandExecutor,
+  BundlePluginLoader
+} from "@robota-sdk/agent-sdk";
 import { createSystemMessage } from "@robota-sdk/agent-core";
 
-// src/commands/slash-executor.ts
-var VALID_MODES2 = ["plan", "default", "acceptEdits", "bypassPermissions"];
-var HELP_TEXT = [
-  "Available commands:",
-  "  /help              \u2014 Show this help",
-  "  /clear             \u2014 Clear conversation",
-  "  /compact [instr]   \u2014 Compact context (optional focus instructions)",
-  "  /mode [m]          \u2014 Show/change permission mode",
-  "  /language [lang]   \u2014 Set response language (ko, en, ja, zh)",
-  "  /cost              \u2014 Show session info",
-  "  /reset             \u2014 Delete settings and exit",
-  "  /exit              \u2014 Exit CLI"
-].join("\n");
-function handleHelp(addMessage) {
-  addMessage({ role: "system", content: HELP_TEXT });
-  return { handled: true };
-}
-function handleClear(addMessage, clearMessages, session) {
-  clearMessages();
-  session.clearHistory();
-  addMessage({ role: "system", content: "Conversation cleared." });
-  return { handled: true };
-}
-async function handleCompact(args, session, addMessage) {
-  const instructions = args.trim() || void 0;
-  const before = session.getContextState().usedPercentage;
-  addMessage({ role: "system", content: "Compacting context..." });
-  await session.compact(instructions);
-  const after = session.getContextState().usedPercentage;
-  addMessage({
-    role: "system",
-    content: `Context compacted: ${Math.round(before)}% -> ${Math.round(after)}%`
-  });
-  return { handled: true };
-}
-function handleMode(arg, session, addMessage) {
-  if (!arg) {
-    addMessage({ role: "system", content: `Current mode: ${session.getPermissionMode()}` });
-  } else if (VALID_MODES2.includes(arg)) {
-    session.setPermissionMode(arg);
-    addMessage({ role: "system", content: `Permission mode set to: ${arg}` });
-  } else {
-    addMessage({ role: "system", content: `Invalid mode. Valid: ${VALID_MODES2.join(" | ")}` });
-  }
-  return { handled: true };
-}
-function handleModel(modelId, addMessage) {
-  if (!modelId) {
-    addMessage({ role: "system", content: "Select a model from the /model submenu." });
-    return { handled: true };
-  }
-  return { handled: true, pendingModelId: modelId };
-}
-function handleCost(session, addMessage) {
-  addMessage({
-    role: "system",
-    content: `Session: ${session.getSessionId()}
-Messages: ${session.getMessageCount()}`
-  });
-  return { handled: true };
-}
-function handlePermissions(session, addMessage) {
-  const mode = session.getPermissionMode();
-  const sessionAllowed = session.getSessionAllowedTools();
-  const lines = [`Permission mode: ${mode}`];
-  if (sessionAllowed.length > 0) {
-    lines.push(`Session-approved tools: ${sessionAllowed.join(", ")}`);
-  } else {
-    lines.push("No session-approved tools.");
-  }
-  addMessage({ role: "system", content: lines.join("\n") });
-  return { handled: true };
-}
-function handleContext(session, addMessage) {
-  const ctx = session.getContextState();
-  addMessage({
-    role: "system",
-    content: `Context: ${ctx.usedTokens.toLocaleString()} / ${ctx.maxTokens.toLocaleString()} tokens (${Math.round(ctx.usedPercentage)}%)`
-  });
-  return { handled: true };
-}
-function handleLanguage(lang, addMessage) {
-  if (!lang) {
-    addMessage({ role: "system", content: "Usage: /language <code> (e.g., ko, en, ja, zh)" });
-    return { handled: true };
-  }
-  const settingsPath = getUserSettingsPath();
-  const settings = readSettings(settingsPath);
-  settings.language = lang;
-  writeSettings(settingsPath, settings);
-  addMessage({ role: "system", content: `Language set to "${lang}". Restarting...` });
-  return { handled: true, exitRequested: true };
-}
-function handleReset(addMessage) {
-  const settingsPath = getUserSettingsPath();
-  if (deleteSettings(settingsPath)) {
-    addMessage({ role: "system", content: `Deleted ${settingsPath}. Exiting...` });
-  } else {
-    addMessage({ role: "system", content: "No user settings found." });
-  }
-  return { handled: true, exitRequested: true };
-}
-async function handlePluginCommand(args, addMessage, callbacks) {
-  const parts = args.trim().split(/\s+/);
-  const subcommand = parts[0] ?? "";
-  const subArgs = parts.slice(1).join(" ").trim();
-  try {
-    switch (subcommand) {
-      case "":
-      case void 0:
-      case "manage": {
-        return { handled: true, triggerPluginTUI: true };
-      }
-      case "install": {
-        if (!subArgs) {
-          addMessage({ role: "system", content: "Usage: /plugin install <name>@<marketplace>" });
-          return { handled: true };
-        }
-        await callbacks.install(subArgs);
-        addMessage({ role: "system", content: `Installed plugin: ${subArgs}` });
-        return { handled: true };
-      }
-      case "uninstall": {
-        if (!subArgs) {
-          addMessage({ role: "system", content: "Usage: /plugin uninstall <name>@<marketplace>" });
-          return { handled: true };
-        }
-        await callbacks.uninstall(subArgs);
-        addMessage({ role: "system", content: `Uninstalled plugin: ${subArgs}` });
-        return { handled: true };
-      }
-      case "enable": {
-        if (!subArgs) {
-          addMessage({ role: "system", content: "Usage: /plugin enable <name>@<marketplace>" });
-          return { handled: true };
-        }
-        await callbacks.enable(subArgs);
-        addMessage({ role: "system", content: `Enabled plugin: ${subArgs}` });
-        return { handled: true };
-      }
-      case "disable": {
-        if (!subArgs) {
-          addMessage({ role: "system", content: "Usage: /plugin disable <name>@<marketplace>" });
-          return { handled: true };
-        }
-        await callbacks.disable(subArgs);
-        addMessage({ role: "system", content: `Disabled plugin: ${subArgs}` });
-        return { handled: true };
-      }
-      case "marketplace": {
-        const mpParts = subArgs.split(/\s+/);
-        const mpSubcommand = mpParts[0] ?? "";
-        const mpArgs = mpParts.slice(1).join(" ").trim();
-        if (mpSubcommand === "add" && mpArgs) {
-          const registeredName = await callbacks.marketplaceAdd(mpArgs);
-          addMessage({
-            role: "system",
-            content: `Added marketplace: "${registeredName}" (from ${mpArgs})
-Install plugins with: /plugin install <name>@${registeredName}`
-          });
-          return { handled: true };
-        } else if (mpSubcommand === "remove" && mpArgs) {
-          await callbacks.marketplaceRemove(mpArgs);
-          addMessage({
-            role: "system",
-            content: `Removed marketplace "${mpArgs}" and uninstalled its plugins.`
-          });
-          return { handled: true };
-        } else if (mpSubcommand === "update" && mpArgs) {
-          await callbacks.marketplaceUpdate(mpArgs);
-          addMessage({
-            role: "system",
-            content: `Updated marketplace "${mpArgs}".`
-          });
-          return { handled: true };
-        } else if (mpSubcommand === "list") {
-          const sources = await callbacks.marketplaceList();
-          if (sources.length === 0) {
-            addMessage({ role: "system", content: "No marketplace sources configured." });
-          } else {
-            const lines = sources.map((s) => `  ${s.name} (${s.type})`);
-            addMessage({ role: "system", content: `Marketplace sources:
-${lines.join("\n")}` });
-          }
-          return { handled: true };
-        } else {
-          addMessage({
-            role: "system",
-            content: "Usage: /plugin marketplace add <source> | remove <name> | update <name> | list"
-          });
-          return { handled: true };
-        }
-      }
-      default:
-        addMessage({ role: "system", content: `Unknown plugin subcommand: ${subcommand}` });
-        return { handled: true };
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    addMessage({ role: "system", content: `Plugin error: ${message}` });
-    return { handled: true };
-  }
-}
-async function handleReloadPlugins(addMessage, callbacks) {
-  await callbacks.reloadPlugins();
-  addMessage({ role: "system", content: "Plugins reload complete." });
-  return { handled: true };
-}
-async function executeSlashCommand(cmd, args, session, addMessage, clearMessages, registry, pluginCallbacks) {
-  switch (cmd) {
-    case "help":
-      return handleHelp(addMessage);
-    case "clear":
-      return handleClear(addMessage, clearMessages, session);
-    case "compact":
-      return handleCompact(args, session, addMessage);
-    case "mode":
-      return handleMode(args.split(/\s+/)[0] || void 0, session, addMessage);
-    case "model":
-      return handleModel(args.split(/\s+/)[0] || void 0, addMessage);
-    case "language":
-      return handleLanguage(args.split(/\s+/)[0] || void 0, addMessage);
-    case "cost":
-      return handleCost(session, addMessage);
-    case "permissions":
-      return handlePermissions(session, addMessage);
-    case "context":
-      return handleContext(session, addMessage);
-    case "reset":
-      return handleReset(addMessage);
-    case "exit":
-      return { handled: true, exitRequested: true };
-    case "plugin":
-      if (pluginCallbacks) {
-        return handlePluginCommand(args, addMessage, pluginCallbacks);
-      }
-      addMessage({ role: "system", content: "Plugin management is not available." });
-      return { handled: true };
-    case "reload-plugins":
-      if (pluginCallbacks) {
-        return handleReloadPlugins(addMessage, pluginCallbacks);
-      }
-      addMessage({ role: "system", content: "Plugin management is not available." });
-      return { handled: true };
-    default: {
-      const dynamicCmd = registry.getCommands().find((c) => c.name === cmd && (c.source === "skill" || c.source === "plugin"));
-      if (dynamicCmd) {
-        addMessage({ role: "system", content: `Invoking ${dynamicCmd.source}: ${cmd}` });
-        return { handled: false };
-      }
-      addMessage({ role: "system", content: `Unknown command "/${cmd}". Type /help for help.` });
-      return { handled: true };
-    }
+// src/commands/plugin-source.ts
+var PluginCommandSource = class {
+  name = "plugin";
+  plugins;
+  constructor(plugins) {
+    this.plugins = plugins;
   }
-}
-
-// src/ui/hooks/useSlashCommands.ts
-var EXIT_DELAY_MS = 500;
-function useSlashCommands(session, addMessage, setMessages, exit, registry, pendingModelChangeRef, setPendingModelId, pluginCallbacks, setShowPluginTUI) {
-  return useCallback3(
-    async (input) => {
-      const parts = input.slice(1).split(/\s+/);
-      const cmd = parts[0]?.toLowerCase() ?? "";
-      const args = parts.slice(1).join(" ");
-      const clearMessages = () => setMessages([]);
-      const slashAddMessage = (msg) => {
-        addMessage(createSystemMessage(msg.content));
-      };
-      const result = await executeSlashCommand(
-        cmd,
-        args,
-        session,
-        slashAddMessage,
-        clearMessages,
-        registry,
-        pluginCallbacks
-      );
-      if (result.pendingModelId) {
-        pendingModelChangeRef.current = result.pendingModelId;
-        setPendingModelId(result.pendingModelId);
-      }
-      if (result.triggerPluginTUI) {
-        setShowPluginTUI?.(true);
-      }
-      if (result.exitRequested) {
-        setTimeout(() => exit(), EXIT_DELAY_MS);
+  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
+        });
       }
-      return result.handled;
-    },
-    [
-      session,
-      addMessage,
-      setMessages,
-      exit,
-      registry,
-      pendingModelChangeRef,
-      setPendingModelId,
-      pluginCallbacks,
-      setShowPluginTUI
-    ]
-  );
-}
-
-// src/ui/hooks/useSubmitHandler.ts
-import { useCallback as useCallback4 } from "react";
-import { randomUUID } from "crypto";
-import {
-  createSubagentSession,
-  getBuiltInAgent,
-  retrieveAgentToolDeps
-} from "@robota-sdk/agent-sdk";
-import {
-  createUserMessage,
-  createAssistantMessage,
-  createSystemMessage as createSystemMessage2,
-  createToolMessage
-} from "@robota-sdk/agent-core";
-
-// src/utils/tool-call-extractor.ts
-var TOOL_ARG_MAX_LENGTH = 80;
-var TAIL_KEEP2 = 30;
-function extractToolCallsWithDiff(history, startIndex) {
-  const summaries = [];
-  for (let i = startIndex; i < history.length; i++) {
-    const msg = history[i];
-    if (msg.role === "assistant" && msg.toolCalls) {
-      for (const tc of msg.toolCalls) {
-        const value = parseFirstArgValue(tc.function.arguments);
-        const truncated = value.length > TOOL_ARG_MAX_LENGTH ? value.slice(0, TOOL_ARG_MAX_LENGTH - TAIL_KEEP2 - 3) + "..." + value.slice(-TAIL_KEEP2) : value;
-        const summary = {
-          line: `${tc.function.name}(${truncated})`
-        };
-        if (tc.function.name === "Edit") {
-          try {
-            const args = JSON.parse(tc.function.arguments);
-            const diff = extractEditDiff("Edit", args);
-            if (diff) {
-              summary.diffLines = diff.lines;
-              summary.diffFile = diff.file;
-            }
-          } catch {
-          }
-        }
-        summaries.push(summary);
+      for (const cmd of plugin.commands) {
+        commands.push({
+          name: cmd.name,
+          description: cmd.description,
+          source: "plugin",
+          skillContent: cmd.skillContent,
+          pluginDir: plugin.pluginDir
+        });
       }
     }
+    return commands;
   }
-  return summaries;
-}
-function parseFirstArgValue(argsJson) {
-  try {
-    const parsed = JSON.parse(argsJson);
-    const firstVal = Object.values(parsed)[0];
-    return typeof firstVal === "string" ? firstVal : JSON.stringify(firstVal);
-  } catch {
-    return argsJson;
-  }
-}
+};
 
 // src/utils/skill-prompt.ts
 import { execSync } from "child_process";
@@ -821,488 +263,33 @@ Execute the "${cmd}" skill: ${userInstruction}`;
   return `Use the "${cmd}" skill: ${userInstruction}`;
 }
 
-// src/commands/skill-executor.ts
-function buildProcessedContent(skill, args, context) {
-  if (!skill.skillContent) return null;
-  return substituteVariables(skill.skillContent, args, context);
-}
-function buildInjectPrompt(skill, args, context) {
-  const processed = buildProcessedContent(skill, args, context);
-  if (processed) {
-    const userInstruction = args || skill.description;
-    return `<skill name="${skill.name}">
-${processed}
-</skill>
-
-Execute the "${skill.name}" skill: ${userInstruction}`;
-  }
-  return `Use the "${skill.name}" skill: ${args || skill.description}`;
-}
-async function executeSkill(skill, args, callbacks, context) {
-  if (skill.context === "fork") {
-    if (!callbacks.runInFork) {
-      throw new Error("Fork execution is not available. Agent tool deps may not be initialized.");
-    }
-    const content = buildProcessedContent(skill, args, context);
-    const prompt2 = content ?? `Use the "${skill.name}" skill: ${args || skill.description}`;
-    const options = {};
-    if (skill.agent) options.agent = skill.agent;
-    if (skill.allowedTools) options.allowedTools = skill.allowedTools;
-    const result = await callbacks.runInFork(prompt2, options);
-    return { mode: "fork", result };
-  }
-  const prompt = buildInjectPrompt(skill, args, context);
-  return { mode: "inject", prompt };
-}
-
-// src/ui/hooks/useSubmitHandler.ts
-function syncContextState(session, setter) {
-  const ctx = session.getContextState();
-  setter({ percentage: ctx.usedPercentage, usedTokens: ctx.usedTokens, maxTokens: ctx.maxTokens });
-}
-async function runSessionPrompt(prompt, session, addMessage, clearStreamingText, setIsThinking, setContextState, rawInput) {
-  setIsThinking(true);
-  clearStreamingText();
-  const historyBefore = session.getHistory().length;
-  try {
-    const response = await session.run(prompt, rawInput);
-    clearStreamingText();
-    const history = session.getHistory();
-    const toolSummaries = extractToolCallsWithDiff(
-      history,
-      historyBefore
-    );
-    if (toolSummaries.length > 0) {
-      addMessage(
-        createToolMessage(JSON.stringify(toolSummaries), {
-          toolCallId: randomUUID(),
-          name: `${toolSummaries.length} tools`
-        })
-      );
-    }
-    addMessage(createAssistantMessage(response || "(empty response)"));
-    syncContextState(session, setContextState);
-  } catch (err) {
-    clearStreamingText();
-    const isAbortError = err instanceof DOMException && err.name === "AbortError" || err instanceof Error && (err.message.includes("aborted") || err.message.includes("abort"));
-    if (isAbortError) {
-      const history = session.getHistory();
-      const toolSummaries = extractToolCallsWithDiff(
-        history,
-        historyBefore
-      );
-      if (toolSummaries.length > 0) {
-        addMessage(
-          createToolMessage(JSON.stringify(toolSummaries), {
-            toolCallId: randomUUID(),
-            name: `${toolSummaries.length} tools`
-          })
-        );
-      }
-      const assistantParts = [];
-      let lastAssistantState = "complete";
-      for (let i = historyBefore; i < history.length; i++) {
-        const msg = history[i];
-        if (msg && msg.role === "assistant" && msg.content) {
-          assistantParts.push(msg.content);
-          if (msg.state === "interrupted") lastAssistantState = "interrupted";
-        }
-      }
-      if (assistantParts.length > 0) {
-        addMessage(
-          createAssistantMessage(assistantParts.join("\n\n"), { state: lastAssistantState })
-        );
-      }
-      addMessage(createSystemMessage2("Interrupted by user."));
-    } else {
-      const errMsg = err instanceof Error ? err.message : String(err);
-      addMessage(createSystemMessage2(`Error: ${errMsg}`));
-    }
-  } finally {
-    setIsThinking(false);
-  }
-}
-function createForkRunner(sessionKey) {
-  const deps = retrieveAgentToolDeps(sessionKey);
-  if (!deps) return void 0;
-  return async (content, options) => {
-    const agentType = options.agent ?? "general-purpose";
-    const agentDef = getBuiltInAgent(agentType) ?? deps.customAgentRegistry?.(agentType);
-    if (!agentDef) {
-      throw new Error(`Unknown agent type for fork execution: ${agentType}`);
-    }
-    const effectiveDef = options.allowedTools ? { ...agentDef, tools: options.allowedTools } : agentDef;
-    const subSession = createSubagentSession({
-      agentDefinition: effectiveDef,
-      parentConfig: deps.config,
-      parentContext: deps.context,
-      parentTools: deps.tools,
-      terminal: deps.terminal,
-      isForkWorker: true,
-      permissionHandler: deps.permissionHandler,
-      onTextDelta: deps.onTextDelta,
-      onToolExecution: deps.onToolExecution
-    });
-    return await subSession.run(content);
-  };
-}
-function findSkillCommand(input, registry) {
-  const parts = input.slice(1).split(/\s+/);
-  const cmd = parts[0]?.toLowerCase() ?? "";
-  const skillCmd = registry.getCommands().find((c) => c.name === cmd && (c.source === "skill" || c.source === "plugin"));
-  if (!skillCmd) return null;
-  return { skill: skillCmd, args: parts.slice(1).join(" ").trim() };
-}
-function useSubmitHandler(session, addMessage, handleSlashCommand, clearStreamingText, setIsThinking, setContextState, registry) {
-  return useCallback4(
-    async (input) => {
-      if (input.startsWith("/")) {
-        const handled = await handleSlashCommand(input);
-        if (handled) {
-          syncContextState(session, setContextState);
-          return;
-        }
-        const found = findSkillCommand(input, registry);
-        if (!found) return;
-        const { skill, args } = found;
-        if (skill.context === "fork") {
-          const runInFork = createForkRunner(session);
-          const result = await executeSkill(skill, args, { runInFork });
-          if (result.mode === "fork") {
-            addMessage(createAssistantMessage(result.result ?? "(empty response)"));
-            syncContextState(session, setContextState);
-            return;
-          }
-          if (result.prompt) {
-            const cmdName2 = input.slice(1).split(/\s+/)[0]?.toLowerCase() ?? "";
-            const qualifiedName2 = registry.resolveQualifiedName(cmdName2);
-            const hookInput2 = qualifiedName2 ? `/${qualifiedName2}${input.slice(1 + cmdName2.length)}` : input;
-            return runSessionPrompt(
-              result.prompt,
-              session,
-              addMessage,
-              clearStreamingText,
-              setIsThinking,
-              setContextState,
-              hookInput2
-            );
-          }
-          return;
-        }
-        const prompt = await buildSkillPrompt(input, registry);
-        if (!prompt) return;
-        const cmdName = input.slice(1).split(/\s+/)[0]?.toLowerCase() ?? "";
-        const qualifiedName = registry.resolveQualifiedName(cmdName);
-        const hookInput = qualifiedName ? `/${qualifiedName}${input.slice(1 + cmdName.length)}` : input;
-        return runSessionPrompt(
-          prompt,
-          session,
-          addMessage,
-          clearStreamingText,
-          setIsThinking,
-          setContextState,
-          hookInput
-        );
-      }
-      addMessage(createUserMessage(input));
-      return runSessionPrompt(
-        input,
-        session,
-        addMessage,
-        clearStreamingText,
-        setIsThinking,
-        setContextState
-      );
-    },
-    [
-      session,
-      addMessage,
-      handleSlashCommand,
-      clearStreamingText,
-      setIsThinking,
-      setContextState,
-      registry
-    ]
-  );
-}
-
-// src/ui/hooks/useCommandRegistry.ts
-import { useRef as useRef2 } from "react";
-import { homedir as homedir2 } from "os";
-import { join as join3, dirname as dirname2 } from "path";
-import { BundlePluginLoader } from "@robota-sdk/agent-sdk";
-
-// src/commands/command-registry.ts
-var CommandRegistry = class {
-  sources = [];
-  addSource(source) {
-    this.sources.push(source);
-  }
-  /** Get all commands, optionally filtered by prefix */
-  getCommands(filter) {
-    const all = [];
-    for (const source of this.sources) {
-      all.push(...source.getCommands());
-    }
-    if (!filter) return all;
-    const lower = filter.toLowerCase();
-    return all.filter((cmd) => cmd.name.toLowerCase().startsWith(lower));
-  }
-  /** Resolve a short name to its fully qualified plugin:name form */
-  resolveQualifiedName(shortName) {
-    const matches = this.getCommands().filter(
-      (c) => c.source === "plugin" && c.name.includes(":") && c.name.endsWith(`:${shortName}`)
-    );
-    if (matches.length !== 1) return null;
-    return matches[0].name;
-  }
-  /** Get subcommands for a specific command */
-  getSubcommands(commandName) {
-    const lower = commandName.toLowerCase();
-    for (const source of this.sources) {
-      for (const cmd of source.getCommands()) {
-        if (cmd.name.toLowerCase() === lower && cmd.subcommands) {
-          return cmd.subcommands;
-        }
-      }
-    }
-    return [];
-  }
-};
-
-// src/commands/builtin-source.ts
-import { CLAUDE_MODELS, formatTokenCount } from "@robota-sdk/agent-core";
-function buildModelSubcommands() {
-  const seen = /* @__PURE__ */ new Set();
-  const commands = [];
-  for (const model of Object.values(CLAUDE_MODELS)) {
-    if (seen.has(model.name)) continue;
-    seen.add(model.name);
-    commands.push({
-      name: model.id,
-      description: `${model.name} (${formatTokenCount(model.contextWindow).toUpperCase()})`,
-      source: "builtin"
-    });
-  }
-  return commands;
-}
-function createBuiltinCommands() {
-  return [
-    { name: "help", description: "Show available commands", source: "builtin" },
-    { name: "clear", description: "Clear conversation history", source: "builtin" },
-    {
-      name: "mode",
-      description: "Permission mode",
-      source: "builtin",
-      subcommands: [
-        { name: "plan", description: "Plan only, no execution", source: "builtin" },
-        { name: "default", description: "Ask before risky actions", source: "builtin" },
-        { name: "acceptEdits", description: "Auto-approve file edits", source: "builtin" },
-        { name: "bypassPermissions", description: "Skip all permission checks", source: "builtin" }
-      ]
-    },
-    {
-      name: "model",
-      description: "Select AI model",
-      source: "builtin",
-      subcommands: buildModelSubcommands()
-    },
-    {
-      name: "language",
-      description: "Set response language",
-      source: "builtin",
-      subcommands: [
-        { name: "ko", description: "Korean", source: "builtin" },
-        { name: "en", description: "English", source: "builtin" },
-        { name: "ja", description: "Japanese", source: "builtin" },
-        { name: "zh", description: "Chinese", source: "builtin" }
-      ]
-    },
-    { name: "compact", description: "Compress context window", source: "builtin" },
-    { name: "cost", description: "Show session info", source: "builtin" },
-    { name: "context", description: "Context window info", source: "builtin" },
-    { name: "permissions", description: "Permission rules", source: "builtin" },
-    { name: "plugin", description: "Manage plugins", source: "builtin" },
-    { name: "reload-plugins", description: "Reload all plugin resources", source: "builtin" },
-    { name: "reset", description: "Delete settings and exit", source: "builtin" },
-    { name: "exit", description: "Exit CLI", source: "builtin" }
-  ];
-}
-var BuiltinCommandSource = class {
-  name = "builtin";
-  commands;
-  constructor() {
-    this.commands = createBuiltinCommands();
-  }
-  getCommands() {
-    return this.commands;
-  }
-};
-
-// src/commands/skill-source.ts
-import { readdirSync, readFileSync as readFileSync3, existsSync as existsSync2 } from "fs";
-import { join as join2, basename } from "path";
-import { homedir } from "os";
-var BOOLEAN_KEYS = /* @__PURE__ */ new Set(["disable-model-invocation", "user-invocable"]);
-var LIST_KEYS = /* @__PURE__ */ new Set(["allowed-tools"]);
-function kebabToCamel(key) {
-  return key.replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase());
-}
-function parseFrontmatter(content) {
-  const lines = content.split("\n");
-  if (lines[0]?.trim() !== "---") return null;
-  const result = {};
-  for (let i = 1; i < lines.length; i++) {
-    const line = lines[i];
-    if (line.trim() === "---") break;
-    const match = line.match(/^([a-z][a-z0-9-]*):\s*(.+)/);
-    if (!match) continue;
-    const key = match[1];
-    const rawValue = match[2].trim();
-    const camelKey = kebabToCamel(key);
-    if (BOOLEAN_KEYS.has(key)) {
-      result[camelKey] = rawValue === "true";
-    } else if (LIST_KEYS.has(key)) {
-      result[camelKey] = rawValue.split(",").map((s) => s.trim());
-    } else {
-      result[camelKey] = rawValue;
-    }
-  }
-  return Object.keys(result).length > 0 ? result : null;
-}
-function buildCommand(frontmatter, content, fallbackName) {
-  const cmd = {
-    name: frontmatter?.name ?? fallbackName,
-    description: frontmatter?.description ?? `Skill: ${fallbackName}`,
-    source: "skill",
-    skillContent: content
-  };
-  if (frontmatter?.argumentHint !== void 0) cmd.argumentHint = frontmatter.argumentHint;
-  if (frontmatter?.disableModelInvocation !== void 0)
-    cmd.disableModelInvocation = frontmatter.disableModelInvocation;
-  if (frontmatter?.userInvocable !== void 0) cmd.userInvocable = frontmatter.userInvocable;
-  if (frontmatter?.allowedTools !== void 0) cmd.allowedTools = frontmatter.allowedTools;
-  if (frontmatter?.model !== void 0) cmd.model = frontmatter.model;
-  if (frontmatter?.effort !== void 0) cmd.effort = frontmatter.effort;
-  if (frontmatter?.context !== void 0) cmd.context = frontmatter.context;
-  if (frontmatter?.agent !== void 0) cmd.agent = frontmatter.agent;
-  return cmd;
-}
-function scanSkillsDir(skillsDir) {
-  if (!existsSync2(skillsDir)) return [];
-  const commands = [];
-  const entries = readdirSync(skillsDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const skillFile = join2(skillsDir, entry.name, "SKILL.md");
-    if (!existsSync2(skillFile)) continue;
-    const content = readFileSync3(skillFile, "utf-8");
-    const frontmatter = parseFrontmatter(content);
-    commands.push(buildCommand(frontmatter, content, entry.name));
-  }
-  return commands;
-}
-function scanCommandsDir(commandsDir) {
-  if (!existsSync2(commandsDir)) return [];
-  const commands = [];
-  const entries = readdirSync(commandsDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const filePath = join2(commandsDir, entry.name);
-    const content = readFileSync3(filePath, "utf-8");
-    const frontmatter = parseFrontmatter(content);
-    const fallbackName = basename(entry.name, ".md");
-    commands.push(buildCommand(frontmatter, content, fallbackName));
-  }
-  return commands;
-}
-var SkillCommandSource = class {
-  name = "skill";
-  cwd;
-  home;
-  cachedCommands = null;
-  constructor(cwd, home) {
-    this.cwd = cwd;
-    this.home = home ?? homedir();
-  }
-  getCommands() {
-    if (this.cachedCommands) return this.cachedCommands;
-    const sources = [
-      scanSkillsDir(join2(this.cwd, ".claude", "skills")),
-      // 1. project .claude/skills
-      scanCommandsDir(join2(this.cwd, ".claude", "commands")),
-      // 2. project .claude/commands (legacy)
-      scanSkillsDir(join2(this.home, ".robota", "skills")),
-      // 3. user ~/.robota/skills
-      scanSkillsDir(join2(this.cwd, ".agents", "skills"))
-      // 4. project .agents/skills
-    ];
-    const seen = /* @__PURE__ */ new Set();
-    const merged = [];
-    for (const commands of sources) {
-      for (const cmd of commands) {
-        if (!seen.has(cmd.name)) {
-          seen.add(cmd.name);
-          merged.push(cmd);
-        }
-      }
-    }
-    this.cachedCommands = merged;
-    return this.cachedCommands;
-  }
-  /** Get skills that models can invoke (excludes disableModelInvocation: true) */
-  getModelInvocableSkills() {
-    return this.getCommands().filter((cmd) => cmd.disableModelInvocation !== true);
-  }
-  /** Get skills that users can invoke (excludes userInvocable: false) */
-  getUserInvocableSkills() {
-    return this.getCommands().filter((cmd) => cmd.userInvocable !== false);
-  }
-};
-
-// src/commands/plugin-source.ts
-var PluginCommandSource = class {
-  name = "plugin";
-  plugins;
-  constructor(plugins) {
-    this.plugins = plugins;
-  }
-  getCommands() {
-    const commands = [];
-    for (const plugin of this.plugins) {
-      for (const skill of plugin.skills) {
-        const baseName = skill.name.includes("@") ? skill.name.split("@")[0] : skill.name;
-        commands.push({
-          name: baseName,
-          description: `(${plugin.manifest.name}) ${skill.description}`,
-          source: "plugin",
-          skillContent: skill.skillContent,
-          pluginDir: plugin.pluginDir
-        });
-      }
-      for (const cmd of plugin.commands) {
-        commands.push({
-          name: cmd.name,
-          description: cmd.description,
-          source: "plugin",
-          skillContent: cmd.skillContent,
-          pluginDir: plugin.pluginDir
-        });
-      }
-    }
-    return commands;
-  }
-};
-
-// src/ui/hooks/useCommandRegistry.ts
+// src/ui/hooks/plugin-hooks-merger.ts
+import { join as join2, dirname as dirname2 } from "path";
 function buildPluginEnv(plugin) {
-  const dataDir = join3(dirname2(dirname2(plugin.pluginDir)), "data", plugin.manifest.name);
+  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
   };
 }
+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;
+      })
+    };
+  }
+  return group;
+}
 function mergePluginHooks(plugins) {
   const merged = {};
   for (const plugin of plugins) {
@@ -1314,63 +301,278 @@ function mergePluginHooks(plugins) {
       if (!Array.isArray(groups)) continue;
       if (!merged[event]) merged[event] = [];
       const resolved = groups.map((group) => {
-        const resolved2 = resolvePluginRoot(group, plugin.pluginDir);
-        if (typeof resolved2 === "object" && resolved2 !== null) {
-          resolved2.env = pluginEnv;
-        }
-        return resolved2;
+        const r = resolvePluginRoot(group, plugin.pluginDir);
+        r.env = pluginEnv;
+        return r;
       });
       merged[event].push(...resolved);
     }
   }
   return merged;
 }
-function resolvePluginRoot(group, pluginDir) {
-  if (typeof group !== "object" || group === null) return group;
-  const obj = group;
-  if (Array.isArray(obj.hooks)) {
-    return {
-      ...obj,
-      hooks: obj.hooks.map((h) => {
-        if (typeof h !== "object" || h === null) return h;
-        const hook = h;
-        if (typeof hook.command === "string") {
-          return {
-            ...hook,
-            command: hook.command.replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, pluginDir)
-          };
-        }
-        return hook;
-      })
-    };
+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];
   }
-  return group;
+  if (configHooks) {
+    for (const [event, groups] of Object.entries(configHooks)) {
+      if (!Array.isArray(groups)) continue;
+      if (!merged[event]) merged[event] = [];
+      merged[event].push(...groups);
+    }
+  }
+  return merged;
 }
-function useCommandRegistry(cwd) {
-  const resultRef = useRef2(null);
-  if (resultRef.current === null) {
-    const registry = new CommandRegistry();
-    registry.addSource(new BuiltinCommandSource());
-    registry.addSource(new SkillCommandSource(cwd));
-    let pluginHooks = {};
-    const pluginsDir = join3(homedir2(), ".robota", "plugins");
-    const loader = new BundlePluginLoader(pluginsDir);
-    try {
-      const plugins = loader.loadPluginsSync();
-      if (plugins.length > 0) {
-        registry.addSource(new PluginCommandSource(plugins));
-        pluginHooks = mergePluginHooks(plugins);
+
+// src/ui/hooks/useInteractiveSession.ts
+var MAX_RENDERED_MESSAGES = 100;
+function initializeSession(props, permissionHandler) {
+  const cwd = props.cwd ?? process.cwd();
+  const registry = new CommandRegistry();
+  registry.addSource(new BuiltinCommandSource());
+  registry.addSource(new SkillCommandSource(cwd));
+  let pluginHooks = {};
+  const pluginsDir = join3(homedir(), ".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
+  };
+}
+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 [permissionRequest, setPermissionRequest] = useState(null);
+  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);
       }
-    } catch {
+    });
+  }, []);
+  const permissionHandler = useCallback(
+    (toolName, toolArgs) => new Promise((resolve) => {
+      permissionQueueRef.current.push({ toolName, toolArgs, resolve });
+      processNextPermission();
+    }),
+    [processNextPermission]
+  );
+  const stateRef = useRef(null);
+  if (stateRef.current === null) {
+    stateRef.current = initializeSession(props, permissionHandler);
+  }
+  const { interactiveSession, registry, commandExecutor } = stateRef.current;
+  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) {
+        setIsAborting(false);
+        streamBuf = "";
+        setStreamingText("");
+        setActiveTools([]);
+      }
+    };
+    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);
+    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);
+    };
+  }, [interactiveSession]);
+  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());
     }
-    resultRef.current = { registry, pluginHooks };
+  }, [isThinking, interactiveSession]);
+  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);
+        if (result) {
+          addMessage(createSystemMessage(result.message));
+          const effects = interactiveSession;
+          if (result.data?.modelId) {
+            effects._pendingModelId = result.data.modelId;
+            return;
+          }
+          if (result.data?.language) {
+            effects._pendingLanguage = result.data.language;
+            return;
+          }
+          if (result.data?.resetRequested) {
+            effects._resetRequested = true;
+            return;
+          }
+          const ctx = interactiveSession.getContextState();
+          setContextState({
+            percentage: ctx.usedPercentage,
+            usedTokens: ctx.usedTokens,
+            maxTokens: ctx.maxTokens
+          });
+          return;
+        }
+        const skillCmd = registry.getCommands().find((c) => c.name === cmd && (c.source === "skill" || c.source === "plugin"));
+        if (skillCmd) {
+          const prompt = await buildSkillPrompt(input, registry);
+          if (prompt) {
+            await interactiveSession.submit(prompt);
+            return;
+          }
+        }
+        if (cmd === "exit") {
+          interactiveSession._exitRequested = true;
+          return;
+        }
+        if (cmd === "plugin") {
+          interactiveSession._triggerPluginTUI = true;
+          return;
+        }
+        addMessage(createSystemMessage(`Unknown command "/${cmd}". Type /help for help.`));
+        return;
+      }
+      await interactiveSession.submit(input);
+    },
+    [interactiveSession, commandExecutor, registry, addMessage]
+  );
+  const handleAbort = useCallback(() => {
+    setIsAborting(true);
+    interactiveSession.abort();
+  }, [interactiveSession]);
+  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
+    });
   }
-  return resultRef.current;
+  return {
+    interactiveSession,
+    registry,
+    commandExecutor,
+    pluginHooks: stateRef.current.pluginHooks,
+    messages,
+    addMessage,
+    setMessages,
+    streamingText,
+    activeTools,
+    isThinking,
+    isAborting,
+    pendingPrompt,
+    permissionRequest,
+    contextState,
+    handleSubmit,
+    handleAbort,
+    handleCancelQueue
+  };
 }
 
 // src/ui/hooks/usePluginCallbacks.ts
 import { useMemo } from "react";
-import { homedir as homedir3 } from "os";
+import { homedir as homedir2 } from "os";
 import { join as join4 } from "path";
 import {
   PluginSettingsStore,
@@ -1380,7 +582,7 @@ import {
 } from "@robota-sdk/agent-sdk";
 function usePluginCallbacks(cwd) {
   return useMemo(() => {
-    const home = homedir3();
+    const home = homedir2();
     const pluginsDir = join4(home, ".robota", "plugins");
     const userSettingsPath = join4(home, ".robota", "settings.json");
     const settingsStore = new PluginSettingsStore(userSettingsPath);
@@ -1646,7 +848,7 @@ function MessageList({ messages }) {
 
 // src/ui/StatusBar.tsx
 import { Box as Box3, Text as Text3 } from "ink";
-import { formatTokenCount as formatTokenCount2 } from "@robota-sdk/agent-core";
+import { formatTokenCount } from "@robota-sdk/agent-core";
 import { jsx as jsx2, jsxs as jsxs3 } from "react/jsx-runtime";
 var CONTEXT_YELLOW_THRESHOLD = 70;
 var CONTEXT_RED_THRESHOLD = 90;
@@ -1686,9 +888,9 @@ function StatusBar({
             "Context: ",
             Math.round(contextPercentage),
             "% (",
-            formatTokenCount2(contextUsedTokens),
+            formatTokenCount(contextUsedTokens),
             "/",
-            formatTokenCount2(contextMaxTokens),
+            formatTokenCount(contextMaxTokens),
             ")"
           ] })
         ] }),
@@ -1705,11 +907,11 @@ function StatusBar({
 }
 
 // src/ui/InputArea.tsx
-import React5, { useState as useState5, useCallback as useCallback5, useMemo as useMemo2, useRef as useRef4 } from "react";
+import React5, { useState as useState4, useCallback as useCallback2, useMemo as useMemo2, useRef as useRef3 } from "react";
 import { Box as Box5, Text as Text7, useInput as useInput2, useStdout } from "ink";
 
 // src/ui/CjkTextInput.tsx
-import { useRef as useRef3, useState as useState3 } from "react";
+import { useRef as useRef2, useState as useState2 } from "react";
 import { Text as Text4, useInput } from "ink";
 import chalk from "chalk";
 import stringWidth from "string-width";
@@ -1755,11 +957,11 @@ function CjkTextInput({
   showCursor = true,
   availableWidth
 }) {
-  const valueRef = useRef3(value);
-  const cursorRef = useRef3(value.length);
-  const [, forceRender] = useState3(0);
-  const isPastingRef = useRef3(false);
-  const pasteBufferRef = useRef3("");
+  const valueRef = useRef2(value);
+  const cursorRef = useRef2(value.length);
+  const [, forceRender] = useState2(0);
+  const isPastingRef = useRef2(false);
+  const pasteBufferRef = useRef2("");
   if (value !== valueRef.current) {
     valueRef.current = value;
     if (cursorRef.current > value.length) {
@@ -1888,15 +1090,15 @@ function renderWithCursor(value, cursorOffset, placeholder, showCursor) {
 }
 
 // src/ui/WaveText.tsx
-import { useState as useState4, useEffect } from "react";
+import { useState as useState3, useEffect as useEffect2 } from "react";
 import { Text as Text5 } from "ink";
 import { jsx as jsx4 } from "react/jsx-runtime";
 var WAVE_COLORS = ["#666666", "#888888", "#aaaaaa", "#888888"];
 var INTERVAL_MS = 400;
 var CHARS_PER_GROUP = 4;
 function WaveText({ text }) {
-  const [tick, setTick] = useState4(0);
-  useEffect(() => {
+  const [tick, setTick] = useState3(0);
+  useEffect2(() => {
     const timer = setInterval(() => {
       setTick((prev) => prev + 1);
     }, INTERVAL_MS);
@@ -1968,8 +1170,8 @@ function parseSlashInput(value) {
   return { isSlash: true, parentCommand: parent, filter: rest };
 }
 function useAutocomplete(value, registry) {
-  const [selectedIndex, setSelectedIndex] = useState5(0);
-  const [dismissed, setDismissed] = useState5(false);
+  const [selectedIndex, setSelectedIndex] = useState4(0);
+  const [dismissed, setDismissed] = useState4(false);
   const prevValueRef = React5.useRef(value);
   if (prevValueRef.current !== value) {
     prevValueRef.current = value;
@@ -2022,12 +1224,12 @@ function InputArea({
   pendingPrompt,
   registry
 }) {
-  const [value, setValue] = useState5("");
-  const pasteStore = useRef4(/* @__PURE__ */ new Map());
+  const [value, setValue] = useState4("");
+  const pasteStore = useRef3(/* @__PURE__ */ new Map());
   const { stdout } = useStdout();
   const terminalColumns = stdout?.columns ?? 80;
   const availableWidth = Math.max(1, terminalColumns - INPUT_AREA_OVERHEAD);
-  const pasteIdRef = useRef4(0);
+  const pasteIdRef = useRef3(0);
   const {
     showPopup,
     filteredCommands,
@@ -2036,7 +1238,7 @@ function InputArea({
     isSubcommandMode,
     setShowPopup
   } = useAutocomplete(value, registry);
-  const handlePaste = useCallback5((text) => {
+  const handlePaste = useCallback2((text) => {
     pasteIdRef.current += 1;
     const id = pasteIdRef.current;
     pasteStore.current.set(id, text);
@@ -2044,7 +1246,7 @@ function InputArea({
     const label = `[Pasted text #${id} +${lineCount} lines]`;
     setValue((prev) => prev ? `${prev} ${label}` : label);
   }, []);
-  const handleSubmit = useCallback5(
+  const handleSubmit = useCallback2(
     (text) => {
       const trimmed = text.trim();
       if (trimmed.length === 0) return;
@@ -2060,7 +1262,7 @@ function InputArea({
     },
     [showPopup, filteredCommands, selectedIndex, onSubmit]
   );
-  const selectCommand = useCallback5(
+  const selectCommand = useCallback2(
     (cmd) => {
       const parsed = parseSlashInput(value);
       if (parsed.parentCommand) {
@@ -2145,7 +1347,7 @@ function InputArea({
 }
 
 // src/ui/ConfirmPrompt.tsx
-import { useState as useState6, useCallback as useCallback6, useRef as useRef5 } from "react";
+import { useState as useState5, useCallback as useCallback3, useRef as useRef4 } from "react";
 import { Box as Box6, Text as Text8, useInput as useInput3 } from "ink";
 import { jsx as jsx7, jsxs as jsxs6 } from "react/jsx-runtime";
 function ConfirmPrompt({
@@ -2153,9 +1355,9 @@ function ConfirmPrompt({
   options = ["Yes", "No"],
   onSelect
 }) {
-  const [selected, setSelected] = useState6(0);
-  const resolvedRef = useRef5(false);
-  const doSelect = useCallback6(
+  const [selected, setSelected] = useState5(0);
+  const resolvedRef = useRef4(false);
+  const doSelect = useCallback3(
     (index) => {
       if (resolvedRef.current) return;
       resolvedRef.current = true;
@@ -2295,10 +1497,10 @@ function StreamingIndicator({ text, activeTools }) {
 }
 
 // src/ui/PluginTUI.tsx
-import { useState as useState9, useEffect as useEffect2, useCallback as useCallback9 } from "react";
+import { useState as useState8, useEffect as useEffect3, useCallback as useCallback6 } from "react";
 
 // src/ui/MenuSelect.tsx
-import { useState as useState7, useCallback as useCallback7, useRef as useRef6 } from "react";
+import { useState as useState6, useCallback as useCallback4, useRef as useRef5 } from "react";
 import { Box as Box9, Text as Text11, useInput as useInput5 } from "ink";
 import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
 function MenuSelect({
@@ -2309,10 +1511,10 @@ function MenuSelect({
   loading,
   error
 }) {
-  const [selected, setSelected] = useState7(0);
-  const selectedRef = useRef6(0);
-  const resolvedRef = useRef6(false);
-  const doSelect = useCallback7(
+  const [selected, setSelected] = useState6(0);
+  const selectedRef = useRef5(0);
+  const resolvedRef = useRef5(false);
+  const doSelect = useCallback4(
     (index) => {
       if (resolvedRef.current || items.length === 0) return;
       resolvedRef.current = true;
@@ -2362,7 +1564,7 @@ function MenuSelect({
 }
 
 // src/ui/TextPrompt.tsx
-import { useState as useState8, useRef as useRef7, useCallback as useCallback8 } from "react";
+import { useState as useState7, useRef as useRef6, useCallback as useCallback5 } from "react";
 import { Box as Box10, Text as Text12, useInput as useInput6 } from "ink";
 import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
 function TextPrompt({
@@ -2372,11 +1574,11 @@ function TextPrompt({
   onCancel,
   validate
 }) {
-  const [value, setValue] = useState8("");
-  const [error, setError] = useState8();
-  const resolvedRef = useRef7(false);
-  const valueRef = useRef7("");
-  const handleSubmit = useCallback8(() => {
+  const [value, setValue] = useState7("");
+  const [error, setError] = useState7();
+  const resolvedRef = useRef6(false);
+  const valueRef = useRef6("");
+  const handleSubmit = useCallback5(() => {
     if (resolvedRef.current) return;
     const trimmed = valueRef.current.trim();
     if (!trimmed) return;
@@ -2520,19 +1722,19 @@ function handleInstalledActionSelect(value, pluginId, callbacks, nav) {
 // src/ui/PluginTUI.tsx
 import { jsx as jsx12 } from "react/jsx-runtime";
 function PluginTUI({ callbacks, onClose, addMessage }) {
-  const [stack, setStack] = useState9([{ screen: "main" }]);
-  const [items, setItems] = useState9([]);
-  const [loading, setLoading] = useState9(false);
-  const [error, setError] = useState9();
-  const [confirm, setConfirm] = useState9();
-  const [refreshCounter, setRefreshCounter] = useState9(0);
+  const [stack, setStack] = useState8([{ screen: "main" }]);
+  const [items, setItems] = useState8([]);
+  const [loading, setLoading] = useState8(false);
+  const [error, setError] = useState8();
+  const [confirm, setConfirm] = useState8();
+  const [refreshCounter, setRefreshCounter] = useState8(0);
   const current = stack[stack.length - 1] ?? { screen: "main" };
-  const push = useCallback9((state) => {
+  const push = useCallback6((state) => {
     setStack((prev) => [...prev, state]);
     setItems([]);
     setError(void 0);
   }, []);
-  const pop = useCallback9(() => {
+  const pop = useCallback6(() => {
     setStack((prev) => {
       if (prev.length <= 1) {
         onClose();
@@ -2543,7 +1745,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     setItems([]);
     setError(void 0);
   }, [onClose]);
-  const popN = useCallback9(
+  const popN = useCallback6(
     (n) => {
       setStack((prev) => {
         const next = prev.slice(0, Math.max(1, prev.length - n));
@@ -2558,18 +1760,18 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     },
     [onClose]
   );
-  const notify = useCallback9(
+  const notify = useCallback6(
     (content) => {
       addMessage?.({ role: "system", content });
     },
     [addMessage]
   );
-  const refresh = useCallback9(() => {
+  const refresh = useCallback6(() => {
     setItems([]);
     setRefreshCounter((c) => c + 1);
   }, []);
   const nav = { push, pop, popN, notify, setConfirm, refresh };
-  useEffect2(() => {
+  useEffect3(() => {
     const screen2 = current.screen;
     if (screen2 === "marketplace-list") {
       setLoading(true);
@@ -2619,7 +1821,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
       });
     }
   }, [stack.length, current.screen, current.context?.marketplace, callbacks, refreshCounter]);
-  const handleSelect = useCallback9(
+  const handleSelect = useCallback6(
     (value) => {
       const screen2 = current.screen;
       const ctx = current.context;
@@ -2637,7 +1839,7 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
     },
     [current, items, callbacks, push, pop, popN, notify, setConfirm, refresh]
   );
-  const handleTextSubmit = useCallback9(
+  const handleTextSubmit = useCallback6(
     (value) => {
       if (current.screen === "marketplace-add") {
         callbacks.marketplaceAdd(value).then((name) => {
@@ -2747,104 +1949,90 @@ function PluginTUI({ callbacks, onClose, addMessage }) {
 
 // src/ui/App.tsx
 import { jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
-var EXIT_DELAY_MS2 = 500;
-function mergeHooksIntoConfig(configHooks, pluginHooks) {
-  const pluginKeys = Object.keys(pluginHooks);
-  if (pluginKeys.length === 0) return configHooks;
-  const merged = {};
-  for (const [event, groups] of Object.entries(pluginHooks)) {
-    merged[event] = [...groups];
-  }
-  if (configHooks) {
-    for (const [event, groups] of Object.entries(configHooks)) {
-      if (!Array.isArray(groups)) continue;
-      if (!merged[event]) merged[event] = [];
-      merged[event].push(...groups);
-    }
-  }
-  return merged;
-}
+var EXIT_DELAY_MS = 500;
 function App(props) {
   const { exit } = useApp();
-  const { registry, pluginHooks } = useCommandRegistry(props.cwd ?? process.cwd());
-  const configWithPluginHooks = {
-    ...props.config,
-    hooks: mergeHooksIntoConfig(
-      props.config.hooks,
-      pluginHooks
-    )
-  };
-  const { session, permissionRequest, streamingText, clearStreamingText, activeTools } = useSession(
-    { ...props, config: configWithPluginHooks }
-  );
-  const { messages, setMessages, addMessage } = useMessages();
-  const [isThinking, setIsThinking] = useState10(false);
-  const initialCtx = session.getContextState();
-  const [contextState, setContextState] = useState10({
-    percentage: initialCtx.usedPercentage,
-    usedTokens: initialCtx.usedTokens,
-    maxTokens: initialCtx.maxTokens
-  });
-  const pendingModelChangeRef = useRef8(null);
-  const [pendingModelId, setPendingModelId] = useState10(null);
-  const [showPluginTUI, setShowPluginTUI] = useState10(false);
-  const [isAborting, setIsAborting] = useState10(false);
-  const [pendingPrompt, setPendingPrompt] = useState10(null);
-  const pendingPromptRef = useRef8(null);
-  const pluginCallbacks = usePluginCallbacks(props.cwd ?? process.cwd());
-  const handleSlashCommand = useSlashCommands(
-    session,
-    addMessage,
-    setMessages,
-    exit,
+  const cwd = props.cwd ?? process.cwd();
+  const {
+    interactiveSession,
     registry,
-    pendingModelChangeRef,
-    setPendingModelId,
-    pluginCallbacks,
-    setShowPluginTUI
-  );
-  const executePrompt = useSubmitHandler(
-    session,
+    messages,
     addMessage,
-    handleSlashCommand,
-    clearStreamingText,
-    setIsThinking,
-    setContextState,
-    registry
-  );
-  const handleSubmit = useCallback10(
-    async (input) => {
-      if (isThinking) {
-        setPendingPrompt(input);
-        pendingPromptRef.current = input;
-        return;
+    streamingText,
+    activeTools,
+    isThinking,
+    isAborting,
+    pendingPrompt,
+    permissionRequest,
+    contextState,
+    handleSubmit: baseHandleSubmit,
+    handleAbort,
+    handleCancelQueue
+  } = useInteractiveSession({
+    config: props.config,
+    context: props.context,
+    projectInfo: props.projectInfo,
+    sessionStore: props.sessionStore,
+    permissionMode: props.permissionMode,
+    maxTurns: props.maxTurns,
+    cwd
+  });
+  const pluginCallbacks = usePluginCallbacks(cwd);
+  const [pendingModelId, setPendingModelId] = useState9(null);
+  const pendingModelChangeRef = useRef7(null);
+  const [showPluginTUI, setShowPluginTUI] = useState9(false);
+  const handleSubmit = async (input) => {
+    await baseHandleSubmit(input);
+    const sideEffects = interactiveSession;
+    if (sideEffects._pendingModelId) {
+      const modelId = sideEffects._pendingModelId;
+      delete sideEffects._pendingModelId;
+      pendingModelChangeRef.current = modelId;
+      setPendingModelId(modelId);
+      return;
+    }
+    if (sideEffects._pendingLanguage) {
+      const lang = sideEffects._pendingLanguage;
+      delete sideEffects._pendingLanguage;
+      const settingsPath = getUserSettingsPath();
+      const settings = readSettings(settingsPath);
+      settings.language = lang;
+      writeSettings(settingsPath, settings);
+      addMessage(createSystemMessage2(`Language set to "${lang}". Restarting...`));
+      setTimeout(() => exit(), EXIT_DELAY_MS);
+      return;
+    }
+    if (sideEffects._resetRequested) {
+      delete sideEffects._resetRequested;
+      const settingsPath = getUserSettingsPath();
+      if (deleteSettings(settingsPath)) {
+        addMessage(createSystemMessage2(`Deleted ${settingsPath}. Exiting...`));
+      } else {
+        addMessage(createSystemMessage2("No user settings found."));
       }
-      await executePrompt(input);
-    },
-    [isThinking, executePrompt]
-  );
+      setTimeout(() => exit(), EXIT_DELAY_MS);
+      return;
+    }
+    if (sideEffects._exitRequested) {
+      delete sideEffects._exitRequested;
+      setTimeout(() => exit(), EXIT_DELAY_MS);
+      return;
+    }
+    if (sideEffects._triggerPluginTUI) {
+      delete sideEffects._triggerPluginTUI;
+      setShowPluginTUI(true);
+      return;
+    }
+  };
   useInput7(
     (_input, key) => {
       if (key.escape && isThinking) {
-        setIsAborting(true);
-        setPendingPrompt(null);
-        pendingPromptRef.current = null;
-        session.abort();
+        handleAbort();
       }
     },
     { isActive: !permissionRequest && !showPluginTUI }
   );
-  useEffect3(() => {
-    if (!isThinking) {
-      setIsAborting(false);
-      if (pendingPromptRef.current) {
-        const prompt = pendingPromptRef.current;
-        setPendingPrompt(null);
-        pendingPromptRef.current = null;
-        setTimeout(() => executePrompt(prompt), 0);
-      }
-    }
-  }, [isThinking, pendingPrompt, executePrompt]);
+  const session = interactiveSession.getSession();
   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: `
@@ -2876,20 +2064,20 @@ function App(props) {
               const settingsPath = getUserSettingsPath();
               updateModelInSettings(settingsPath, pendingModelId);
               addMessage(
-                createSystemMessage3(
+                createSystemMessage2(
                   `Model changed to ${getModelName(pendingModelId)}. Restarting...`
                 )
               );
-              setTimeout(() => exit(), EXIT_DELAY_MS2);
+              setTimeout(() => exit(), EXIT_DELAY_MS);
             } catch (err) {
               addMessage(
-                createSystemMessage3(
+                createSystemMessage2(
                   `Failed: ${err instanceof Error ? err.message : String(err)}`
                 )
               );
             }
           } else {
-            addMessage(createSystemMessage3("Model change cancelled."));
+            addMessage(createSystemMessage2("Model change cancelled."));
           }
         }
       }
@@ -2899,7 +2087,7 @@ function App(props) {
       {
         callbacks: pluginCallbacks,
         onClose: () => setShowPluginTUI(false),
-        addMessage: (msg) => addMessage(createSystemMessage3(msg.content))
+        addMessage: (msg) => addMessage(createSystemMessage2(msg.content))
       }
     ),
     /* @__PURE__ */ jsx13(
@@ -2919,10 +2107,7 @@ function App(props) {
       InputArea,
       {
         onSubmit: handleSubmit,
-        onCancelQueue: () => {
-          setPendingPrompt(null);
-          pendingPromptRef.current = null;
-        },
+        onCancelQueue: handleCancelQueue,
         isDisabled: !!permissionRequest || showPluginTUI || isThinking && !!pendingPrompt,
         isAborting,
         pendingPrompt,
@@ -2968,9 +2153,9 @@ function renderApp(options) {
 
 // src/cli.ts
 function checkSettingsFile(filePath) {
-  if (!existsSync3(filePath)) return "missing";
+  if (!existsSync2(filePath)) return "missing";
   try {
-    const raw = readFileSync4(filePath, "utf8").trim();
+    const raw = readFileSync2(filePath, "utf8").trim();
     if (raw.length === 0) return "incomplete";
     const parsed = JSON.parse(raw);
     const provider = parsed.provider;
@@ -2987,7 +2172,7 @@ function readVersion() {
     const candidates = [join5(dir, "..", "..", "package.json"), join5(dir, "..", "package.json")];
     for (const pkgPath of candidates) {
       try {
-        const raw = readFileSync4(pkgPath, "utf-8");
+        const raw = readFileSync2(pkgPath, "utf-8");
         const pkg = JSON.parse(raw);
         if (pkg.version !== void 0 && pkg.name !== void 0) {
           return pkg.version;
@@ -3133,12 +2318,12 @@ async function startCli() {
       process.exit(1);
     }
     const terminal = new PrintTerminal();
-    const paths = projectPaths2(cwd);
-    const session = createSession2({
+    const paths = projectPaths(cwd);
+    const session = createSession({
       config,
       context,
       terminal,
-      sessionLogger: new FileSessionLogger2(paths.logs),
+      sessionLogger: new FileSessionLogger(paths.logs),
       projectInfo,
       permissionMode: args.permissionMode,
       promptForApproval