@robota-sdk/agent-sdk 3.0.0-beta.52 → 3.0.0-beta.53

package/dist/node/index.js

@@ -1,247 +1,632 @@
-// src/hooks/prompt-executor.ts
-function extractJson(raw) {
-  const codeBlockMatch = /```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/.exec(raw);
-  if (codeBlockMatch) {
-    return codeBlockMatch[1].trim();
-  }
-  return raw.trim();
-}
-var PromptExecutor = class {
-  type = "prompt";
-  providerFactory;
-  defaultModel;
-  constructor(options) {
-    this.providerFactory = options.providerFactory;
-    this.defaultModel = options.defaultModel;
-  }
-  async execute(definition, input) {
-    const promptDef = definition;
-    const model = promptDef.model ?? this.defaultModel;
-    try {
-      const provider = this.providerFactory(model);
-      const prompt = `${promptDef.prompt}
-
-Context:
-${JSON.stringify(input)}
+// src/interactive/interactive-session.ts
+import {
+  createUserMessage,
+  createAssistantMessage,
+  createSystemMessage,
+  messageToHistoryEntry
+} from "@robota-sdk/agent-core";
 
-Respond with JSON: { "ok": boolean, "reason"?: string }`;
-      const rawResponse = await provider.complete(prompt);
-      const jsonStr = extractJson(rawResponse);
-      let parsed;
-      try {
-        parsed = JSON.parse(jsonStr);
-      } catch {
+// src/commands/system-command.ts
+var VALID_MODES = ["plan", "default", "acceptEdits", "bypassPermissions"];
+function createSystemCommands() {
+  return [
+    {
+      name: "help",
+      description: "Show available commands",
+      execute: (_session, _args) => ({
+        message: [
+          "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",
+          "  model <id>        \u2014 Change AI model",
+          "  language <code>   \u2014 Set response language (ko, en, ja, zh)",
+          "  cost              \u2014 Show session info",
+          "  context           \u2014 Context window info",
+          "  permissions       \u2014 Permission rules",
+          "  resume            \u2014 Resume a previous session",
+          "  rename <name>     \u2014 Rename the current session",
+          "  reset             \u2014 Delete settings and exit"
+        ].join("\n"),
+        success: true
+      })
+    },
+    {
+      name: "clear",
+      description: "Clear conversation history",
+      execute: (session, _args) => {
+        const underlying = session.getSession();
+        underlying.clearHistory();
+        return { message: "Conversation cleared.", success: true };
+      }
+    },
+    {
+      name: "compact",
+      description: "Compress context window",
+      execute: async (session, args) => {
+        const underlying = session.getSession();
+        const instructions = args.trim() || void 0;
+        const before = underlying.getContextState().usedPercentage;
+        await underlying.compact(instructions);
+        const after = underlying.getContextState().usedPercentage;
         return {
-          exitCode: 1,
-          stdout: "",
-          stderr: `Failed to parse AI response as JSON: ${rawResponse}`
+          message: `Context compacted: ${Math.round(before)}% -> ${Math.round(after)}%`,
+          success: true,
+          data: { before, after }
         };
       }
-      if (parsed.ok) {
-        return { exitCode: 0, stdout: JSON.stringify(parsed), stderr: "" };
+    },
+    {
+      name: "mode",
+      description: "Show/change permission mode",
+      execute: (session, args) => {
+        const underlying = session.getSession();
+        const arg = args.trim().split(/\s+/)[0];
+        if (!arg) {
+          return {
+            message: `Current mode: ${underlying.getPermissionMode()}`,
+            success: true,
+            data: { mode: underlying.getPermissionMode() }
+          };
+        }
+        if (VALID_MODES.includes(arg)) {
+          underlying.setPermissionMode(arg);
+          return {
+            message: `Permission mode set to: ${arg}`,
+            success: true,
+            data: { mode: arg }
+          };
+        }
+        return {
+          message: `Invalid mode. Valid: ${VALID_MODES.join(" | ")}`,
+          success: false
+        };
       }
-      return {
-        exitCode: 2,
-        stdout: "",
-        stderr: parsed.reason ?? "Blocked by prompt hook"
-      };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return { exitCode: 1, stdout: "", stderr: message };
-    }
-  }
-};
-
-// src/hooks/agent-executor.ts
-var DEFAULT_MAX_TURNS = 50;
-var DEFAULT_TIMEOUT_SECONDS = 60;
-function extractJson2(raw) {
-  const codeBlockMatch = /```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/.exec(raw);
-  if (codeBlockMatch) {
-    return codeBlockMatch[1].trim();
-  }
-  return raw.trim();
-}
-var AgentExecutor = class {
-  type = "agent";
-  sessionFactory;
-  constructor(options) {
-    this.sessionFactory = options.sessionFactory;
-  }
-  async execute(definition, input) {
-    const agentDef = definition;
-    const maxTurns = agentDef.maxTurns ?? DEFAULT_MAX_TURNS;
-    const timeout = agentDef.timeout ?? DEFAULT_TIMEOUT_SECONDS;
-    try {
-      const session = this.sessionFactory({ maxTurns, timeout });
-      const prompt = `Hook input:
-${JSON.stringify(input)}
-
-Respond with JSON: { "ok": boolean, "reason"?: string }`;
-      const rawResponse = await session.run(prompt);
-      const jsonStr = extractJson2(rawResponse);
-      let parsed;
-      try {
-        parsed = JSON.parse(jsonStr);
-      } catch {
+    },
+    {
+      name: "model",
+      description: "Change AI model",
+      execute: (_session, args) => {
+        const modelId = args.trim().split(/\s+/)[0];
+        if (!modelId) {
+          return { message: "Usage: model <model-id>", success: false };
+        }
         return {
-          exitCode: 1,
-          stdout: "",
-          stderr: `Failed to parse agent response as JSON: ${rawResponse}`
+          message: `Model change requested: ${modelId}`,
+          success: true,
+          data: { modelId }
         };
       }
-      if (parsed.ok) {
-        return { exitCode: 0, stdout: JSON.stringify(parsed), stderr: "" };
+    },
+    {
+      name: "language",
+      description: "Set response language",
+      execute: (_session, args) => {
+        const lang = args.trim().split(/\s+/)[0];
+        if (!lang) {
+          return { message: "Usage: language <code> (e.g., ko, en, ja, zh)", success: false };
+        }
+        return {
+          message: `Language set to "${lang}".`,
+          success: true,
+          data: { language: lang }
+        };
       }
-      return {
-        exitCode: 2,
-        stdout: "",
-        stderr: parsed.reason ?? "Blocked by agent hook"
-      };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return { exitCode: 1, stdout: "", stderr: message };
-    }
-  }
-};
-
-// src/assembly/create-session.ts
-import { Session as Session2 } from "@robota-sdk/agent-sessions";
-
-// src/context/system-prompt-builder.ts
-var TRUST_LEVEL_DESCRIPTIONS = {
-  safe: "safe (read-only / plan mode \u2014 only read-access tools are available)",
-  moderate: "moderate (default mode \u2014 write and bash tools require approval)",
-  full: "full (acceptEdits mode \u2014 file writes are auto-approved; bash requires approval)"
-};
-function buildProjectSection(info) {
-  const lines = ["## Current Project"];
-  if (info.name !== void 0) {
-    lines.push(`- **Name:** ${info.name}`);
-  }
-  if (info.type !== "unknown") {
-    lines.push(`- **Type:** ${info.type}`);
-  }
-  if (info.language !== "unknown") {
-    lines.push(`- **Language:** ${info.language}`);
-  }
-  if (info.packageManager !== void 0) {
-    lines.push(`- **Package manager:** ${info.packageManager}`);
-  }
-  return lines.join("\n");
-}
-function buildToolsSection(descriptions) {
-  if (descriptions.length === 0) {
-    return "";
-  }
-  const lines = ["## Available Tools", ...descriptions.map((d) => `- ${d}`)];
-  return lines.join("\n");
-}
-function buildSkillsSection(skills) {
-  const invocable = skills.filter((s) => s.disableModelInvocation !== true);
-  if (invocable.length === 0) {
-    return "";
-  }
-  const lines = [
-    "## Skills",
-    "The following skills are available:",
-    "",
-    ...invocable.map((s) => `- ${s.name}: ${s.description}`)
-  ];
-  return lines.join("\n");
-}
-function buildSystemPrompt(params) {
-  const { agentsMd, claudeMd, toolDescriptions, trustLevel, projectInfo, cwd, language } = params;
-  const sections = [];
-  const roleLines = [
-    "## Role",
-    "You are an AI coding assistant with access to tools that let you read and modify code.",
-    "You help developers understand, write, and improve their codebase.",
-    "Always be precise, follow existing code conventions, and prefer minimal changes."
+    },
+    {
+      name: "cost",
+      description: "Show session info",
+      execute: (session, _args) => {
+        const underlying = session.getSession();
+        const sessionId = underlying.getSessionId();
+        const messageCount = underlying.getMessageCount();
+        return {
+          message: `Session: ${sessionId}
+Messages: ${messageCount}`,
+          success: true,
+          data: { sessionId, messageCount }
+        };
+      }
+    },
+    {
+      name: "context",
+      description: "Context window info",
+      execute: (session, _args) => {
+        const ctx = session.getContextState();
+        return {
+          message: `Context: ${ctx.usedTokens.toLocaleString()} / ${ctx.maxTokens.toLocaleString()} tokens (${Math.round(ctx.usedPercentage)}%)`,
+          success: true,
+          data: {
+            usedTokens: ctx.usedTokens,
+            maxTokens: ctx.maxTokens,
+            percentage: ctx.usedPercentage
+          }
+        };
+      }
+    },
+    {
+      name: "permissions",
+      description: "Show permission rules",
+      execute: (session, _args) => {
+        const underlying = session.getSession();
+        const mode = underlying.getPermissionMode();
+        const sessionAllowed = underlying.getSessionAllowedTools();
+        const lines = [`Permission mode: ${mode}`];
+        if (sessionAllowed.length > 0) {
+          lines.push(`Session-approved tools: ${sessionAllowed.join(", ")}`);
+        } else {
+          lines.push("No session-approved tools.");
+        }
+        return {
+          message: lines.join("\n"),
+          success: true,
+          data: { mode, sessionAllowed }
+        };
+      }
+    },
+    {
+      name: "resume",
+      description: "Resume a previous session",
+      execute: (_session, _args) => ({
+        message: "Opening session picker...",
+        success: true,
+        data: { triggerResumePicker: true }
+      })
+    },
+    {
+      name: "rename",
+      description: "Rename the current session",
+      execute: (_session, args) => {
+        const name = args.trim();
+        if (!name) {
+          return { message: "Usage: rename <name>", success: false };
+        }
+        return {
+          message: `Session renamed to "${name}".`,
+          success: true,
+          data: { name }
+        };
+      }
+    },
+    {
+      name: "reset",
+      description: "Delete settings",
+      execute: (_session, _args) => {
+        return {
+          message: "Reset requested.",
+          success: true,
+          data: { resetRequested: true }
+        };
+      }
+    }
   ];
-  if (language) {
-    roleLines.push(
-      `Always respond in ${language}. Use ${language} for all explanations and communications.`
-    );
+}
+var SystemCommandExecutor = class {
+  commands;
+  constructor(commands) {
+    this.commands = /* @__PURE__ */ new Map();
+    for (const cmd of commands ?? createSystemCommands()) {
+      this.commands.set(cmd.name, cmd);
+    }
   }
-  sections.push(roleLines.join("\n"));
-  if (cwd) {
-    sections.push(`## Working Directory
-\`${cwd}\``);
+  /** Register an additional command. */
+  register(command) {
+    this.commands.set(command.name, command);
   }
-  sections.push(buildProjectSection(projectInfo));
-  sections.push(
-    [
-      "## Permission Mode",
-      `Your current trust level is **${TRUST_LEVEL_DESCRIPTIONS[trustLevel]}**.`
-    ].join("\n")
-  );
-  if (agentsMd.trim().length > 0) {
-    sections.push(["## Agent Instructions", agentsMd].join("\n"));
+  /** Execute a command by name. Returns null if command not found. */
+  async execute(name, session, args) {
+    const cmd = this.commands.get(name);
+    if (!cmd) return null;
+    return await cmd.execute(session, args);
   }
-  if (claudeMd.trim().length > 0) {
-    sections.push(["## Project Notes", claudeMd].join("\n"));
+  /** List all registered commands. */
+  listCommands() {
+    return [...this.commands.values()];
   }
-  sections.push(
-    [
-      "## Web Search",
-      "You have access to web search. When the user asks to search, look up, or find current/latest information,",
-      "you MUST use the web_search tool. Do NOT answer from training data when the user explicitly asks to search.",
-      "Always prefer web search for: news, latest versions, current events, live documentation."
-    ].join("\n")
-  );
-  const toolsSection = buildToolsSection(toolDescriptions);
-  if (toolsSection.length > 0) {
-    sections.push(toolsSection);
+  /** Check if a command exists. */
+  hasCommand(name) {
+    return this.commands.has(name);
   }
-  if (params.skills !== void 0 && params.skills.length > 0) {
-    const skillsSection = buildSkillsSection(params.skills);
-    if (skillsSection.length > 0) {
-      sections.push(skillsSection);
+};
+
+// src/interactive/interactive-session-execution.ts
+function isAbortError(err) {
+  return err instanceof DOMException && err.name === "AbortError" || err instanceof Error && (err.message.includes("aborted") || err.message.includes("abort"));
+}
+function extractToolSummaries(history, historyBefore) {
+  const summaries = [];
+  for (let i = historyBefore; i < history.length; i++) {
+    const msg = history[i];
+    if (msg?.role === "assistant" && msg.toolCalls) {
+      for (const tc of msg.toolCalls) {
+        summaries.push({ name: tc.function.name, args: tc.function.arguments });
+      }
     }
   }
-  return sections.join("\n\n");
+  return summaries;
 }
-
-// src/assembly/create-tools.ts
-import {
-  bashTool,
-  readTool,
-  writeTool,
-  editTool,
-  globTool,
-  grepTool,
-  webFetchTool,
-  webSearchTool
-} from "@robota-sdk/agent-tools";
-var DEFAULT_TOOL_DESCRIPTIONS = [
-  "Bash \u2014 execute shell commands",
-  "Read \u2014 read file contents with line numbers",
-  "Write \u2014 write content to a file",
-  "Edit \u2014 replace a string in a file",
-  "Glob \u2014 find files matching a pattern",
-  "Grep \u2014 search file contents with regex",
-  "WebSearch \u2014 search the internet (Anthropic built-in)"
-];
-function createDefaultTools() {
-  return [
-    bashTool,
-    readTool,
-    writeTool,
-    editTool,
-    globTool,
-    grepTool,
-    webFetchTool,
-    webSearchTool
-  ];
+function buildResult(response, sessionHistory, interactiveHistory, historyBefore, contextState) {
+  const toolSummaries = extractToolSummaries(sessionHistory, historyBefore);
+  return {
+    response,
+    history: interactiveHistory,
+    toolSummaries,
+    contextState
+  };
+}
+function buildInterruptedResult(sessionHistory, interactiveHistory, historyBefore, contextState) {
+  const toolSummaries = extractToolSummaries(sessionHistory, historyBefore);
+  const parts = [];
+  for (let i = historyBefore; i < sessionHistory.length; i++) {
+    const msg = sessionHistory[i];
+    if (msg?.role === "assistant" && msg.content) parts.push(msg.content);
+  }
+  return {
+    response: parts.join("\n\n"),
+    history: interactiveHistory,
+    toolSummaries,
+    contextState
+  };
+}
+function persistSession(sessionStore, session, sessionName, cwd, history) {
+  try {
+    const sessionId = session.getSessionId();
+    const existing = sessionStore.load(sessionId);
+    sessionStore.save({
+      id: sessionId,
+      name: sessionName ?? existing?.name,
+      cwd,
+      createdAt: existing?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      messages: session.getHistory(),
+      history
+    });
+  } catch {
+  }
 }
+var NOOP_TERMINAL = {
+  write: () => {
+  },
+  writeLine: () => {
+  },
+  writeMarkdown: () => {
+  },
+  writeError: () => {
+  },
+  prompt: () => Promise.resolve(""),
+  select: () => Promise.resolve(0),
+  spinner: () => ({ stop: () => {
+  }, update: () => {
+  } })
+};
 
-// src/tools/agent-tool.ts
-import { z } from "zod";
-import { createZodFunctionTool } from "@robota-sdk/agent-tools";
+// src/interactive/interactive-session-streaming.ts
+import { randomUUID } from "crypto";
+var TOOL_ARG_DISPLAY_MAX = 80;
+var TAIL_KEEP = 30;
+var MAX_COMPLETED_TOOLS = 50;
+var STREAMING_FLUSH_INTERVAL_MS = 16;
+function extractFirstArg(toolArgs) {
+  if (!toolArgs) return "";
+  const firstVal = Object.values(toolArgs)[0];
+  const raw = typeof firstVal === "string" ? firstVal : JSON.stringify(firstVal ?? "");
+  return raw.length > TOOL_ARG_DISPLAY_MAX ? raw.slice(0, TOOL_ARG_DISPLAY_MAX - TAIL_KEEP - 3) + "..." + raw.slice(-TAIL_KEEP) : raw;
+}
+function pushToolSummaryToHistory(state) {
+  if (state.activeTools.length === 0) return;
+  const summary = state.activeTools.map((t) => {
+    const status = t.isRunning ? "\u27F3" : t.result === "success" ? "\u2713" : t.result === "error" ? "\u2717" : "\u2298";
+    return `${status} ${t.toolName}${t.firstArg ? `(${t.firstArg})` : ""}`;
+  }).join("\n");
+  state.history.push({
+    id: randomUUID(),
+    timestamp: /* @__PURE__ */ new Date(),
+    category: "event",
+    type: "tool-summary",
+    data: {
+      tools: state.activeTools.map((t) => ({
+        toolName: t.toolName,
+        firstArg: t.firstArg,
+        isRunning: t.isRunning,
+        result: t.result
+      })),
+      summary
+    }
+  });
+}
+function trimCompletedTools(activeTools) {
+  const completed = activeTools.filter((t) => !t.isRunning);
+  if (completed.length <= MAX_COMPLETED_TOOLS) return activeTools;
+  const excess = completed.length - MAX_COMPLETED_TOOLS;
+  let removed = 0;
+  return activeTools.filter((t) => {
+    if (!t.isRunning && removed < excess) {
+      removed++;
+      return false;
+    }
+    return true;
+  });
+}
+function applyToolStart(state, event) {
+  const firstArg = extractFirstArg(event.toolArgs);
+  const toolState = { toolName: event.toolName, firstArg, isRunning: true };
+  state.activeTools.push(toolState);
+  state.history.push({
+    id: randomUUID(),
+    timestamp: /* @__PURE__ */ new Date(),
+    category: "event",
+    type: "tool-start",
+    data: { toolName: event.toolName, firstArg, isRunning: true }
+  });
+  return toolState;
+}
+function applyToolEnd(state, event) {
+  const result = event.denied ? "denied" : event.success === false ? "error" : "success";
+  const idx = state.activeTools.findIndex((t) => t.toolName === event.toolName && t.isRunning);
+  if (idx === -1) return null;
+  const finished = { ...state.activeTools[idx], isRunning: false, result };
+  state.activeTools[idx] = finished;
+  state.activeTools = trimCompletedTools(state.activeTools);
+  state.history.push({
+    id: randomUUID(),
+    timestamp: /* @__PURE__ */ new Date(),
+    category: "event",
+    type: "tool-end",
+    data: {
+      toolName: finished.toolName,
+      firstArg: finished.firstArg,
+      isRunning: false,
+      result
+    }
+  });
+  return finished;
+}
 
-// src/agents/built-in-agents.ts
-var GENERAL_PURPOSE_SYSTEM_PROMPT = `You are a general-purpose task execution agent. You have access to all tools available in the parent session and can perform any task delegated to you.
+// src/hooks/prompt-executor.ts
+function extractJson(raw) {
+  const codeBlockMatch = /```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/.exec(raw);
+  if (codeBlockMatch) {
+    return codeBlockMatch[1].trim();
+  }
+  return raw.trim();
+}
+var PromptExecutor = class {
+  type = "prompt";
+  providerFactory;
+  defaultModel;
+  constructor(options) {
+    this.providerFactory = options.providerFactory;
+    this.defaultModel = options.defaultModel;
+  }
+  async execute(definition, input) {
+    const promptDef = definition;
+    const model = promptDef.model ?? this.defaultModel;
+    try {
+      const provider = this.providerFactory(model);
+      const prompt = `${promptDef.prompt}
+
+Context:
+${JSON.stringify(input)}
+
+Respond with JSON: { "ok": boolean, "reason"?: string }`;
+      const rawResponse = await provider.complete(prompt);
+      const jsonStr = extractJson(rawResponse);
+      let parsed;
+      try {
+        parsed = JSON.parse(jsonStr);
+      } catch {
+        return {
+          exitCode: 1,
+          stdout: "",
+          stderr: `Failed to parse AI response as JSON: ${rawResponse}`
+        };
+      }
+      if (parsed.ok) {
+        return { exitCode: 0, stdout: JSON.stringify(parsed), stderr: "" };
+      }
+      return {
+        exitCode: 2,
+        stdout: "",
+        stderr: parsed.reason ?? "Blocked by prompt hook"
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { exitCode: 1, stdout: "", stderr: message };
+    }
+  }
+};
+
+// src/hooks/agent-executor.ts
+var DEFAULT_MAX_TURNS = 50;
+var DEFAULT_TIMEOUT_SECONDS = 60;
+function extractJson2(raw) {
+  const codeBlockMatch = /```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/.exec(raw);
+  if (codeBlockMatch) {
+    return codeBlockMatch[1].trim();
+  }
+  return raw.trim();
+}
+var AgentExecutor = class {
+  type = "agent";
+  sessionFactory;
+  constructor(options) {
+    this.sessionFactory = options.sessionFactory;
+  }
+  async execute(definition, input) {
+    const agentDef = definition;
+    const maxTurns = agentDef.maxTurns ?? DEFAULT_MAX_TURNS;
+    const timeout = agentDef.timeout ?? DEFAULT_TIMEOUT_SECONDS;
+    try {
+      const session = this.sessionFactory({ maxTurns, timeout });
+      const prompt = `Hook input:
+${JSON.stringify(input)}
+
+Respond with JSON: { "ok": boolean, "reason"?: string }`;
+      const rawResponse = await session.run(prompt);
+      const jsonStr = extractJson2(rawResponse);
+      let parsed;
+      try {
+        parsed = JSON.parse(jsonStr);
+      } catch {
+        return {
+          exitCode: 1,
+          stdout: "",
+          stderr: `Failed to parse agent response as JSON: ${rawResponse}`
+        };
+      }
+      if (parsed.ok) {
+        return { exitCode: 0, stdout: JSON.stringify(parsed), stderr: "" };
+      }
+      return {
+        exitCode: 2,
+        stdout: "",
+        stderr: parsed.reason ?? "Blocked by agent hook"
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { exitCode: 1, stdout: "", stderr: message };
+    }
+  }
+};
+
+// src/assembly/create-session.ts
+import { Session as Session2 } from "@robota-sdk/agent-sessions";
+
+// src/context/system-prompt-builder.ts
+var TRUST_LEVEL_DESCRIPTIONS = {
+  safe: "safe (read-only / plan mode \u2014 only read-access tools are available)",
+  moderate: "moderate (default mode \u2014 write and bash tools require approval)",
+  full: "full (acceptEdits mode \u2014 file writes are auto-approved; bash requires approval)"
+};
+function buildProjectSection(info) {
+  const lines = ["## Current Project"];
+  if (info.name !== void 0) {
+    lines.push(`- **Name:** ${info.name}`);
+  }
+  if (info.type !== "unknown") {
+    lines.push(`- **Type:** ${info.type}`);
+  }
+  if (info.language !== "unknown") {
+    lines.push(`- **Language:** ${info.language}`);
+  }
+  if (info.packageManager !== void 0) {
+    lines.push(`- **Package manager:** ${info.packageManager}`);
+  }
+  return lines.join("\n");
+}
+function buildToolsSection(descriptions) {
+  if (descriptions.length === 0) {
+    return "";
+  }
+  const lines = ["## Available Tools", ...descriptions.map((d) => `- ${d}`)];
+  return lines.join("\n");
+}
+function buildSkillsSection(skills) {
+  const invocable = skills.filter((s) => s.disableModelInvocation !== true);
+  if (invocable.length === 0) {
+    return "";
+  }
+  const lines = [
+    "## Skills",
+    "The following skills are available:",
+    "",
+    ...invocable.map((s) => `- ${s.name}: ${s.description}`)
+  ];
+  return lines.join("\n");
+}
+function buildSystemPrompt(params) {
+  const { agentsMd, claudeMd, toolDescriptions, trustLevel, projectInfo, cwd, language } = params;
+  const sections = [];
+  const roleLines = [
+    "## Role",
+    "You are an AI coding assistant with access to tools that let you read and modify code.",
+    "You help developers understand, write, and improve their codebase.",
+    "Always be precise, follow existing code conventions, and prefer minimal changes."
+  ];
+  if (language) {
+    roleLines.push(
+      `Always respond in ${language}. Use ${language} for all explanations and communications.`
+    );
+  }
+  sections.push(roleLines.join("\n"));
+  if (cwd) {
+    sections.push(`## Working Directory
+\`${cwd}\``);
+  }
+  sections.push(buildProjectSection(projectInfo));
+  sections.push(
+    [
+      "## Permission Mode",
+      `Your current trust level is **${TRUST_LEVEL_DESCRIPTIONS[trustLevel]}**.`
+    ].join("\n")
+  );
+  if (agentsMd.trim().length > 0) {
+    sections.push(["## Agent Instructions", agentsMd].join("\n"));
+  }
+  if (claudeMd.trim().length > 0) {
+    sections.push(["## Project Notes", claudeMd].join("\n"));
+  }
+  sections.push(
+    [
+      "## Web Search",
+      "You have access to web search. When the user asks to search, look up, or find current/latest information,",
+      "you MUST use the web_search tool. Do NOT answer from training data when the user explicitly asks to search.",
+      "Always prefer web search for: news, latest versions, current events, live documentation."
+    ].join("\n")
+  );
+  const toolsSection = buildToolsSection(toolDescriptions);
+  if (toolsSection.length > 0) {
+    sections.push(toolsSection);
+  }
+  if (params.skills !== void 0 && params.skills.length > 0) {
+    const skillsSection = buildSkillsSection(params.skills);
+    if (skillsSection.length > 0) {
+      sections.push(skillsSection);
+    }
+  }
+  return sections.join("\n\n");
+}
+
+// src/assembly/create-tools.ts
+import {
+  bashTool,
+  readTool,
+  writeTool,
+  editTool,
+  globTool,
+  grepTool,
+  webFetchTool,
+  webSearchTool
+} from "@robota-sdk/agent-tools";
+var DEFAULT_TOOL_DESCRIPTIONS = [
+  "Bash \u2014 execute shell commands",
+  "Read \u2014 read file contents with line numbers",
+  "Write \u2014 write content to a file",
+  "Edit \u2014 replace a string in a file",
+  "Glob \u2014 find files matching a pattern",
+  "Grep \u2014 search file contents with regex",
+  "WebSearch \u2014 search the internet (Anthropic built-in)"
+];
+function createDefaultTools() {
+  return [
+    bashTool,
+    readTool,
+    writeTool,
+    editTool,
+    globTool,
+    grepTool,
+    webFetchTool,
+    webSearchTool
+  ];
+}
+
+// src/tools/agent-tool.ts
+import { z } from "zod";
+import { createZodFunctionTool } from "@robota-sdk/agent-tools";
+
+// src/agents/built-in-agents.ts
+var GENERAL_PURPOSE_SYSTEM_PROMPT = `You are a general-purpose task execution agent. You have access to all tools available in the parent session and can perform any task delegated to you.
 
 Your role is to complete the assigned task thoroughly and accurately. Follow these guidelines:
 
@@ -677,7 +1062,7 @@ function resolveSubagentLogDir(parentSessionId, baseLogsDir) {
   return join2(baseLogsDir, parentSessionId, "subagents");
 }
 
-// src/interactive/interactive-session.ts
+// src/interactive/interactive-session-init.ts
 import { FileSessionLogger as FileSessionLogger2 } from "@robota-sdk/agent-sessions";
 
 // src/paths.ts
@@ -972,298 +1357,65 @@ function tryReadJson(filePath) {
   if (!existsSync4(filePath)) return void 0;
   try {
     return JSON.parse(readFileSync4(filePath, "utf-8"));
-  } catch {
-    return void 0;
-  }
-}
-function detectPackageManager(cwd) {
-  if (existsSync4(join6(cwd, "pnpm-workspace.yaml")) || existsSync4(join6(cwd, "pnpm-lock.yaml"))) {
-    return "pnpm";
-  }
-  if (existsSync4(join6(cwd, "yarn.lock"))) {
-    return "yarn";
-  }
-  if (existsSync4(join6(cwd, "bun.lockb"))) {
-    return "bun";
-  }
-  if (existsSync4(join6(cwd, "package-lock.json"))) {
-    return "npm";
-  }
-  return void 0;
-}
-async function detectProject(cwd) {
-  const pkgJsonPath = join6(cwd, "package.json");
-  const tsconfigPath = join6(cwd, "tsconfig.json");
-  const pyprojectPath = join6(cwd, "pyproject.toml");
-  const cargoPath = join6(cwd, "Cargo.toml");
-  const goModPath = join6(cwd, "go.mod");
-  if (existsSync4(pkgJsonPath)) {
-    const pkgJson = tryReadJson(pkgJsonPath);
-    const language = existsSync4(tsconfigPath) ? "typescript" : "javascript";
-    const packageManager = detectPackageManager(cwd);
-    return {
-      type: "node",
-      name: pkgJson?.name,
-      packageManager,
-      language
-    };
-  }
-  if (existsSync4(pyprojectPath) || existsSync4(join6(cwd, "setup.py"))) {
-    return {
-      type: "python",
-      language: "python"
-    };
-  }
-  if (existsSync4(cargoPath)) {
-    return {
-      type: "rust",
-      language: "rust"
-    };
-  }
-  if (existsSync4(goModPath)) {
-    return {
-      type: "go",
-      language: "go"
-    };
-  }
-  return {
-    type: "unknown",
-    language: "unknown"
-  };
-}
-
-// src/interactive/interactive-session.ts
-import {
-  createUserMessage,
-  createAssistantMessage,
-  createSystemMessage,
-  messageToHistoryEntry
-} from "@robota-sdk/agent-core";
-import { randomUUID } from "crypto";
-
-// src/commands/system-command.ts
-var VALID_MODES = ["plan", "default", "acceptEdits", "bypassPermissions"];
-function createSystemCommands() {
-  return [
-    {
-      name: "help",
-      description: "Show available commands",
-      execute: (_session, _args) => ({
-        message: [
-          "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",
-          "  model <id>        \u2014 Change AI model",
-          "  language <code>   \u2014 Set response language (ko, en, ja, zh)",
-          "  cost              \u2014 Show session info",
-          "  context           \u2014 Context window info",
-          "  permissions       \u2014 Permission rules",
-          "  resume            \u2014 Resume a previous session",
-          "  rename <name>     \u2014 Rename the current session",
-          "  reset             \u2014 Delete settings and exit"
-        ].join("\n"),
-        success: true
-      })
-    },
-    {
-      name: "clear",
-      description: "Clear conversation history",
-      execute: (session, _args) => {
-        const underlying = session.getSession();
-        underlying.clearHistory();
-        return { message: "Conversation cleared.", success: true };
-      }
-    },
-    {
-      name: "compact",
-      description: "Compress context window",
-      execute: async (session, args) => {
-        const underlying = session.getSession();
-        const instructions = args.trim() || void 0;
-        const before = underlying.getContextState().usedPercentage;
-        await underlying.compact(instructions);
-        const after = underlying.getContextState().usedPercentage;
-        return {
-          message: `Context compacted: ${Math.round(before)}% -> ${Math.round(after)}%`,
-          success: true,
-          data: { before, after }
-        };
-      }
-    },
-    {
-      name: "mode",
-      description: "Show/change permission mode",
-      execute: (session, args) => {
-        const underlying = session.getSession();
-        const arg = args.trim().split(/\s+/)[0];
-        if (!arg) {
-          return {
-            message: `Current mode: ${underlying.getPermissionMode()}`,
-            success: true,
-            data: { mode: underlying.getPermissionMode() }
-          };
-        }
-        if (VALID_MODES.includes(arg)) {
-          underlying.setPermissionMode(arg);
-          return {
-            message: `Permission mode set to: ${arg}`,
-            success: true,
-            data: { mode: arg }
-          };
-        }
-        return {
-          message: `Invalid mode. Valid: ${VALID_MODES.join(" | ")}`,
-          success: false
-        };
-      }
-    },
-    {
-      name: "model",
-      description: "Change AI model",
-      execute: (_session, args) => {
-        const modelId = args.trim().split(/\s+/)[0];
-        if (!modelId) {
-          return { message: "Usage: model <model-id>", success: false };
-        }
-        return {
-          message: `Model change requested: ${modelId}`,
-          success: true,
-          data: { modelId }
-        };
-      }
-    },
-    {
-      name: "language",
-      description: "Set response language",
-      execute: (_session, args) => {
-        const lang = args.trim().split(/\s+/)[0];
-        if (!lang) {
-          return { message: "Usage: language <code> (e.g., ko, en, ja, zh)", success: false };
-        }
-        return {
-          message: `Language set to "${lang}".`,
-          success: true,
-          data: { language: lang }
-        };
-      }
-    },
-    {
-      name: "cost",
-      description: "Show session info",
-      execute: (session, _args) => {
-        const underlying = session.getSession();
-        const sessionId = underlying.getSessionId();
-        const messageCount = underlying.getMessageCount();
-        return {
-          message: `Session: ${sessionId}
-Messages: ${messageCount}`,
-          success: true,
-          data: { sessionId, messageCount }
-        };
-      }
-    },
-    {
-      name: "context",
-      description: "Context window info",
-      execute: (session, _args) => {
-        const ctx = session.getContextState();
-        return {
-          message: `Context: ${ctx.usedTokens.toLocaleString()} / ${ctx.maxTokens.toLocaleString()} tokens (${Math.round(ctx.usedPercentage)}%)`,
-          success: true,
-          data: {
-            usedTokens: ctx.usedTokens,
-            maxTokens: ctx.maxTokens,
-            percentage: ctx.usedPercentage
-          }
-        };
-      }
-    },
-    {
-      name: "permissions",
-      description: "Show permission rules",
-      execute: (session, _args) => {
-        const underlying = session.getSession();
-        const mode = underlying.getPermissionMode();
-        const sessionAllowed = underlying.getSessionAllowedTools();
-        const lines = [`Permission mode: ${mode}`];
-        if (sessionAllowed.length > 0) {
-          lines.push(`Session-approved tools: ${sessionAllowed.join(", ")}`);
-        } else {
-          lines.push("No session-approved tools.");
-        }
-        return {
-          message: lines.join("\n"),
-          success: true,
-          data: { mode, sessionAllowed }
-        };
-      }
-    },
-    {
-      name: "resume",
-      description: "Resume a previous session",
-      execute: (_session, _args) => ({
-        message: "Opening session picker...",
-        success: true,
-        data: { triggerResumePicker: true }
-      })
-    },
-    {
-      name: "rename",
-      description: "Rename the current session",
-      execute: (_session, args) => {
-        const name = args.trim();
-        if (!name) {
-          return { message: "Usage: rename <name>", success: false };
-        }
-        return {
-          message: `Session renamed to "${name}".`,
-          success: true,
-          data: { name }
-        };
-      }
-    },
-    {
-      name: "reset",
-      description: "Delete settings",
-      execute: (_session, _args) => {
-        return {
-          message: "Reset requested.",
-          success: true,
-          data: { resetRequested: true }
-        };
-      }
-    }
-  ];
-}
-var SystemCommandExecutor = class {
-  commands;
-  constructor(commands) {
-    this.commands = /* @__PURE__ */ new Map();
-    for (const cmd of commands ?? createSystemCommands()) {
-      this.commands.set(cmd.name, cmd);
-    }
+  } catch {
+    return void 0;
   }
-  /** Register an additional command. */
-  register(command) {
-    this.commands.set(command.name, command);
+}
+function detectPackageManager(cwd) {
+  if (existsSync4(join6(cwd, "pnpm-workspace.yaml")) || existsSync4(join6(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm";
   }
-  /** Execute a command by name. Returns null if command not found. */
-  async execute(name, session, args) {
-    const cmd = this.commands.get(name);
-    if (!cmd) return null;
-    return await cmd.execute(session, args);
+  if (existsSync4(join6(cwd, "yarn.lock"))) {
+    return "yarn";
   }
-  /** List all registered commands. */
-  listCommands() {
-    return [...this.commands.values()];
+  if (existsSync4(join6(cwd, "bun.lockb"))) {
+    return "bun";
   }
-  /** Check if a command exists. */
-  hasCommand(name) {
-    return this.commands.has(name);
+  if (existsSync4(join6(cwd, "package-lock.json"))) {
+    return "npm";
   }
-};
+  return void 0;
+}
+async function detectProject(cwd) {
+  const pkgJsonPath = join6(cwd, "package.json");
+  const tsconfigPath = join6(cwd, "tsconfig.json");
+  const pyprojectPath = join6(cwd, "pyproject.toml");
+  const cargoPath = join6(cwd, "Cargo.toml");
+  const goModPath = join6(cwd, "go.mod");
+  if (existsSync4(pkgJsonPath)) {
+    const pkgJson = tryReadJson(pkgJsonPath);
+    const language = existsSync4(tsconfigPath) ? "typescript" : "javascript";
+    const packageManager = detectPackageManager(cwd);
+    return {
+      type: "node",
+      name: pkgJson?.name,
+      packageManager,
+      language
+    };
+  }
+  if (existsSync4(pyprojectPath) || existsSync4(join6(cwd, "setup.py"))) {
+    return {
+      type: "python",
+      language: "python"
+    };
+  }
+  if (existsSync4(cargoPath)) {
+    return {
+      type: "rust",
+      language: "rust"
+    };
+  }
+  if (existsSync4(goModPath)) {
+    return {
+      type: "go",
+      language: "go"
+    };
+  }
+  return {
+    type: "unknown",
+    language: "unknown"
+  };
+}
 
 // src/plugins/plugin-settings-store.ts
 import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
@@ -1367,8 +1519,11 @@ var PluginSettingsStore = class {
 };
 
 // src/plugins/bundle-plugin-loader.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync6 } from "fs";
 import { join as join7 } from "path";
+
+// src/plugins/bundle-plugin-utils.ts
+import { existsSync as existsSync6, readdirSync as readdirSync2 } from "fs";
 function parseSkillFrontmatter(raw) {
   const trimmed = raw.trimStart();
   if (!trimmed.startsWith("---")) {
@@ -1425,6 +1580,8 @@ function getSortedSubdirs(dirPath) {
     return [];
   }
 }
+
+// src/plugins/bundle-plugin-loader.ts
 var BundlePluginLoader = class {
   pluginsDir;
   enabledPlugins;
@@ -1448,7 +1605,7 @@ var BundlePluginLoader = class {
    */
   discoverAndLoad() {
     const cacheDir = join7(this.pluginsDir, "cache");
-    if (!existsSync6(cacheDir)) {
+    if (!existsSync7(cacheDir)) {
       return [];
     }
     const results = [];
@@ -1463,7 +1620,7 @@ var BundlePluginLoader = class {
         const latestVersion = versions[versions.length - 1];
         const versionDir = join7(pluginDir, latestVersion);
         const manifestPath = join7(versionDir, ".claude-plugin", "plugin.json");
-        if (!existsSync6(manifestPath)) continue;
+        if (!existsSync7(manifestPath)) continue;
         const manifest = this.readManifest(manifestPath);
         if (!manifest) continue;
         const pluginId = `${manifest.name}@${marketplace}`;
@@ -1513,13 +1670,13 @@ var BundlePluginLoader = class {
   /** Load skills from the plugin's skills/ directory. */
   loadSkills(pluginDir, pluginName) {
     const skillsDir = join7(pluginDir, "skills");
-    if (!existsSync6(skillsDir)) return [];
-    const entries = readdirSync2(skillsDir, { withFileTypes: true });
+    if (!existsSync7(skillsDir)) return [];
+    const entries = readdirSync3(skillsDir, { withFileTypes: true });
     const skills = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const skillFile = join7(skillsDir, entry.name, "SKILL.md");
-      if (!existsSync6(skillFile)) continue;
+      if (!existsSync7(skillFile)) continue;
       const raw = readFileSync6(skillFile, "utf-8");
       const { metadata, content } = parseSkillFrontmatter(raw);
       const description = typeof metadata.description === "string" ? metadata.description : "";
@@ -1536,8 +1693,8 @@ var BundlePluginLoader = class {
   /** Load commands from the plugin's commands/ directory (flat .md files). */
   loadCommands(pluginDir, pluginName) {
     const commandsDir = join7(pluginDir, "commands");
-    if (!existsSync6(commandsDir)) return [];
-    const entries = readdirSync2(commandsDir, { withFileTypes: true });
+    if (!existsSync7(commandsDir)) return [];
+    const entries = readdirSync3(commandsDir, { withFileTypes: true });
     const commands = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
@@ -1557,7 +1714,7 @@ var BundlePluginLoader = class {
   /** Load hooks from hooks/hooks.json if present. */
   loadHooks(pluginDir) {
     const hooksPath = join7(pluginDir, "hooks", "hooks.json");
-    if (!existsSync6(hooksPath)) return {};
+    if (!existsSync7(hooksPath)) return {};
     try {
       const raw = readFileSync6(hooksPath, "utf-8");
       const data = JSON.parse(raw);
@@ -1573,8 +1730,8 @@ var BundlePluginLoader = class {
   loadMcpConfig(pluginDir) {
     const primaryPath = join7(pluginDir, ".mcp.json");
     const fallbackPath = join7(pluginDir, ".claude-plugin", "mcp.json");
-    const mcpPath = existsSync6(primaryPath) ? primaryPath : fallbackPath;
-    if (!existsSync6(mcpPath)) return void 0;
+    const mcpPath = existsSync7(primaryPath) ? primaryPath : fallbackPath;
+    if (!existsSync7(mcpPath)) return void 0;
     try {
       const raw = readFileSync6(mcpPath, "utf-8");
       return JSON.parse(raw);
@@ -1585,9 +1742,9 @@ var BundlePluginLoader = class {
   /** Load agent definitions from agents/ directory if present. */
   loadAgents(pluginDir) {
     const agentsDir = join7(pluginDir, "agents");
-    if (!existsSync6(agentsDir)) return [];
+    if (!existsSync7(agentsDir)) return [];
     try {
-      const entries = readdirSync2(agentsDir, { withFileTypes: true });
+      const entries = readdirSync3(agentsDir, { withFileTypes: true });
       return entries.filter((e) => e.isDirectory() || e.name.endsWith(".md")).map((e) => e.name.replace(/\.md$/, ""));
     } catch {
       return [];
@@ -1597,7 +1754,7 @@ var BundlePluginLoader = class {
 
 // src/plugins/bundle-plugin-installer.ts
 import { execSync } from "child_process";
-import { cpSync, existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync7, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { cpSync, existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync7, rmSync, writeFileSync as writeFileSync2 } from "fs";
 import { join as join8, dirname as dirname3 } from "path";
 var GIT_CLONE_TIMEOUT_MS = 6e4;
 var BundlePluginInstaller = class {
@@ -1631,7 +1788,7 @@ var BundlePluginInstaller = class {
     }
     const version = this.resolveVersion(entry, marketplaceName);
     const targetDir = join8(this.cacheDir, marketplaceName, pluginName, version);
-    if (existsSync7(targetDir)) {
+    if (existsSync8(targetDir)) {
       throw new Error(
         `Plugin "${pluginName}" version "${version}" is already installed from "${marketplaceName}"`
       );
@@ -1658,7 +1815,7 @@ var BundlePluginInstaller = class {
     if (!record) {
       throw new Error(`Plugin "${pluginId}" is not installed`);
     }
-    if (existsSync7(record.installPath)) {
+    if (existsSync8(record.installPath)) {
       rmSync(record.installPath, { recursive: true, force: true });
     }
     delete registry[pluginId];
@@ -1711,7 +1868,7 @@ var BundlePluginInstaller = class {
       if (typeof source === "string") {
         const marketplaceDir = this.marketplaceClient.getMarketplaceDir(marketplaceName);
         const sourcePath = join8(marketplaceDir, source);
-        if (!existsSync7(sourcePath)) {
+        if (!existsSync8(sourcePath)) {
           throw new Error(
             `Plugin source path "${source}" not found in marketplace "${marketplaceName}"`
           );
@@ -1728,7 +1885,7 @@ var BundlePluginInstaller = class {
         throw new Error(`Unknown source type: ${JSON.stringify(source)}`);
       }
     } catch (err) {
-      if (existsSync7(targetDir)) {
+      if (existsSync8(targetDir)) {
         rmSync(targetDir, { recursive: true, force: true });
       }
       throw err;
@@ -1747,7 +1904,7 @@ var BundlePluginInstaller = class {
   }
   /** Read the installed_plugins.json registry. */
   readRegistry() {
-    if (!existsSync7(this.registryPath)) {
+    if (!existsSync8(this.registryPath)) {
       return {};
     }
     try {
@@ -1764,7 +1921,7 @@ var BundlePluginInstaller = class {
   /** Write the installed_plugins.json registry. */
   writeRegistry(registry) {
     const dir = dirname3(this.registryPath);
-    if (!existsSync7(dir)) {
+    if (!existsSync8(dir)) {
       mkdirSync3(dir, { recursive: true });
     }
     writeFileSync2(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
@@ -1777,16 +1934,66 @@ var BundlePluginInstaller = class {
 
 // src/plugins/marketplace-client.ts
 import { execSync as execSync2 } from "child_process";
-import {
-  cpSync as cpSync2,
-  existsSync as existsSync8,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync8,
-  renameSync,
-  rmSync as rmSync2,
-  writeFileSync as writeFileSync3
-} from "fs";
+import { cpSync as cpSync2, existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync9, renameSync, rmSync as rmSync3 } from "fs";
+import { join as join10 } from "path";
+
+// src/plugins/marketplace-registry.ts
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
 import { join as join9, dirname as dirname4 } from "path";
+function readRegistry(registryPath) {
+  if (!existsSync9(registryPath)) {
+    return {};
+  }
+  try {
+    const raw = readFileSync8(registryPath, "utf-8");
+    const data = JSON.parse(raw);
+    if (typeof data === "object" && data !== null) {
+      return data;
+    }
+    return {};
+  } catch {
+    return {};
+  }
+}
+function writeRegistry(registryPath, registry) {
+  const dir = dirname4(registryPath);
+  if (!existsSync9(dir)) {
+    mkdirSync4(dir, { recursive: true });
+  }
+  writeFileSync3(registryPath, JSON.stringify(registry, null, 2), "utf-8");
+}
+function removeInstalledPluginsForMarketplace(pluginsDir, marketplaceName) {
+  const installedPath = join9(pluginsDir, "installed_plugins.json");
+  if (!existsSync9(installedPath)) return;
+  let registry;
+  try {
+    const raw = readFileSync8(installedPath, "utf-8");
+    const data = JSON.parse(raw);
+    if (typeof data !== "object" || data === null) return;
+    registry = data;
+  } catch {
+    return;
+  }
+  let changed = false;
+  for (const [pluginId, record] of Object.entries(registry)) {
+    if (record.marketplace === marketplaceName) {
+      if (record.installPath && existsSync9(record.installPath)) {
+        rmSync2(record.installPath, { recursive: true, force: true });
+      }
+      delete registry[pluginId];
+      changed = true;
+    }
+  }
+  if (changed) {
+    const dir = dirname4(installedPath);
+    if (!existsSync9(dir)) {
+      mkdirSync4(dir, { recursive: true });
+    }
+    writeFileSync3(installedPath, JSON.stringify(registry, null, 2), "utf-8");
+  }
+}
+
+// src/plugins/marketplace-client.ts
 var GIT_TIMEOUT_MS = 6e4;
 var MarketplaceClient = class {
   pluginsDir;
@@ -1796,25 +2003,24 @@ var MarketplaceClient = class {
   constructor(options) {
     this.pluginsDir = options.pluginsDir;
     this.exec = options.exec ?? this.defaultExec;
-    this.marketplacesDir = join9(this.pluginsDir, "marketplaces");
-    this.registryPath = join9(this.pluginsDir, "known_marketplaces.json");
+    this.marketplacesDir = join10(this.pluginsDir, "marketplaces");
+    this.registryPath = join10(this.pluginsDir, "known_marketplaces.json");
   }
   /**
    * Add a marketplace by cloning its repository.
    *
-   * 1. Parse source: `owner/repo` string becomes a GitHub source.
-   * 2. Shallow git clone (`--depth 1`) to `marketplaces/<name>/`.
-   * 3. Read `.claude-plugin/marketplace.json` for the `name` field.
-   * 4. Register in `known_marketplaces.json`.
+   * 1. Shallow git clone (`--depth 1`) to `marketplaces/<name>/`.
+   * 2. Read `.claude-plugin/marketplace.json` for the `name` field.
+   * 3. Register in `known_marketplaces.json`.
    *
    * Returns the registered marketplace name from the manifest.
    */
   addMarketplace(source) {
     const tempName = "temp-" + Date.now().toString(36);
-    const tempDir = join9(this.marketplacesDir, tempName);
-    mkdirSync4(this.marketplacesDir, { recursive: true });
+    const tempDir = join10(this.marketplacesDir, tempName);
+    mkdirSync5(this.marketplacesDir, { recursive: true });
     if (source.type === "local") {
-      if (!existsSync8(source.path)) {
+      if (!existsSync10(source.path)) {
         throw new Error(`Local marketplace path does not exist: ${source.path}`);
       }
       cpSync2(source.path, tempDir, { recursive: true });
@@ -1828,9 +2034,9 @@ var MarketplaceClient = class {
         throw new Error(`Failed to clone marketplace: ${message}`);
       }
     }
-    const manifestPath = join9(tempDir, ".claude-plugin", "marketplace.json");
-    if (!existsSync8(manifestPath)) {
-      rmSync2(tempDir, { recursive: true, force: true });
+    const manifestPath = join10(tempDir, ".claude-plugin", "marketplace.json");
+    if (!existsSync10(manifestPath)) {
+      rmSync3(tempDir, { recursive: true, force: true });
       throw new Error(
         source.type === "local" ? "Local directory does not contain .claude-plugin/marketplace.json" : "Cloned repository does not contain .claude-plugin/marketplace.json"
       );
@@ -1838,22 +2044,22 @@ var MarketplaceClient = class {
     const manifest = this.readManifestFromPath(manifestPath);
     const name = manifest.name;
     if (!name) {
-      rmSync2(tempDir, { recursive: true, force: true });
+      rmSync3(tempDir, { recursive: true, force: true });
       throw new Error('Marketplace manifest does not contain a "name" field');
     }
-    const registry = this.readRegistry();
+    const registry = readRegistry(this.registryPath);
     if (registry[name]) {
-      rmSync2(tempDir, { recursive: true, force: true });
+      rmSync3(tempDir, { recursive: true, force: true });
       throw new Error(`Marketplace "${name}" already exists`);
     }
-    const finalDir = join9(this.marketplacesDir, name);
+    const finalDir = join10(this.marketplacesDir, name);
     renameSync(tempDir, finalDir);
     registry[name] = {
       source,
       installLocation: finalDir,
       lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
     };
-    this.writeRegistry(registry);
+    writeRegistry(this.registryPath, registry);
     return name;
   }
   /**
@@ -1862,41 +2068,38 @@ var MarketplaceClient = class {
    * and removes from the registry.
    */
   removeMarketplace(name) {
-    const registry = this.readRegistry();
+    const registry = readRegistry(this.registryPath);
     const entry = registry[name];
     if (!entry) {
       throw new Error(`Marketplace "${name}" not found`);
     }
-    this.removeInstalledPluginsForMarketplace(name);
-    if (existsSync8(entry.installLocation)) {
-      rmSync2(entry.installLocation, { recursive: true, force: true });
+    removeInstalledPluginsForMarketplace(this.pluginsDir, name);
+    if (existsSync10(entry.installLocation)) {
+      rmSync3(entry.installLocation, { recursive: true, force: true });
     }
     delete registry[name];
-    this.writeRegistry(registry);
+    writeRegistry(this.registryPath, registry);
   }
   /**
    * Update a marketplace by running git pull on its clone.
    * The manifest is re-read from disk on demand (via fetchManifest), so the
    * updated manifest is automatically available after pull.
-   *
-   * TODO: After pull, detect version changes in installed plugins and offer
-   * to update them (re-install at new version).
    */
   updateMarketplace(name) {
-    const registry = this.readRegistry();
+    const registry = readRegistry(this.registryPath);
     const entry = registry[name];
     if (!entry) {
       throw new Error(`Marketplace "${name}" not found`);
     }
-    if (!existsSync8(entry.installLocation)) {
+    if (!existsSync10(entry.installLocation)) {
       throw new Error(`Marketplace directory for "${name}" does not exist`);
     }
     if (entry.source.type === "local") {
       const localSource = entry.source;
-      if (!existsSync8(localSource.path)) {
+      if (!existsSync10(localSource.path)) {
         throw new Error(`Local marketplace path does not exist: ${localSource.path}`);
       }
-      rmSync2(entry.installLocation, { recursive: true, force: true });
+      rmSync3(entry.installLocation, { recursive: true, force: true });
       cpSync2(localSource.path, entry.installLocation, { recursive: true });
     } else {
       const command = `git -C ${entry.installLocation} pull`;
@@ -1908,28 +2111,26 @@ var MarketplaceClient = class {
       }
     }
     entry.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-    this.writeRegistry(registry);
+    writeRegistry(this.registryPath, registry);
   }
   /** List all registered marketplaces. */
   listMarketplaces() {
-    const registry = this.readRegistry();
+    const registry = readRegistry(this.registryPath);
     return Object.entries(registry).map(([name, entry]) => ({
       name,
       source: entry.source,
       lastUpdated: entry.lastUpdated
     }));
   }
-  /**
-   * Read the marketplace manifest from a registered marketplace's clone.
-   */
+  /** Read the marketplace manifest from a registered marketplace's clone. */
   fetchManifest(marketplaceName) {
-    const registry = this.readRegistry();
+    const registry = readRegistry(this.registryPath);
     const entry = registry[marketplaceName];
     if (!entry) {
       throw new Error(`Marketplace "${marketplaceName}" not found`);
     }
-    const manifestPath = join9(entry.installLocation, ".claude-plugin", "marketplace.json");
-    if (!existsSync8(manifestPath)) {
+    const manifestPath = join10(entry.installLocation, ".claude-plugin", "marketplace.json");
+    if (!existsSync10(manifestPath)) {
       throw new Error(
         `Marketplace "${marketplaceName}" does not contain .claude-plugin/marketplace.json`
       );
@@ -1938,7 +2139,7 @@ var MarketplaceClient = class {
   }
   /** Get the clone directory path for a registered marketplace. */
   getMarketplaceDir(name) {
-    const registry = this.readRegistry();
+    const registry = readRegistry(this.registryPath);
     const entry = registry[name];
     if (!entry) {
       throw new Error(`Marketplace "${name}" not found`);
@@ -1990,44 +2191,9 @@ var MarketplaceClient = class {
         throw new Error("URL marketplace source is not yet supported");
     }
   }
-  /**
-   * Remove all installed plugins that belong to a given marketplace.
-   * Reads installed_plugins.json, deletes cache directories for matching plugins,
-   * and updates the registry.
-   */
-  removeInstalledPluginsForMarketplace(marketplaceName) {
-    const installedPath = join9(this.pluginsDir, "installed_plugins.json");
-    if (!existsSync8(installedPath)) return;
-    let registry;
-    try {
-      const raw = readFileSync8(installedPath, "utf-8");
-      const data = JSON.parse(raw);
-      if (typeof data !== "object" || data === null) return;
-      registry = data;
-    } catch {
-      return;
-    }
-    let changed = false;
-    for (const [pluginId, record] of Object.entries(registry)) {
-      if (record.marketplace === marketplaceName) {
-        if (record.installPath && existsSync8(record.installPath)) {
-          rmSync2(record.installPath, { recursive: true, force: true });
-        }
-        delete registry[pluginId];
-        changed = true;
-      }
-    }
-    if (changed) {
-      const dir = dirname4(installedPath);
-      if (!existsSync8(dir)) {
-        mkdirSync4(dir, { recursive: true });
-      }
-      writeFileSync3(installedPath, JSON.stringify(registry, null, 2), "utf-8");
-    }
-  }
   /** Read and parse a marketplace.json from a file path. */
   readManifestFromPath(path) {
-    const raw = readFileSync8(path, "utf-8");
+    const raw = readFileSync9(path, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data !== "object" || data === null) {
       throw new Error("Invalid marketplace manifest: not an object");
@@ -2038,30 +2204,6 @@ var MarketplaceClient = class {
     }
     return data;
   }
-  /** Read the known_marketplaces.json registry. */
-  readRegistry() {
-    if (!existsSync8(this.registryPath)) {
-      return {};
-    }
-    try {
-      const raw = readFileSync8(this.registryPath, "utf-8");
-      const data = JSON.parse(raw);
-      if (typeof data === "object" && data !== null) {
-        return data;
-      }
-      return {};
-    } catch {
-      return {};
-    }
-  }
-  /** Write the known_marketplaces.json registry. */
-  writeRegistry(registry) {
-    const dir = dirname4(this.registryPath);
-    if (!existsSync8(dir)) {
-      mkdirSync4(dir, { recursive: true });
-    }
-    writeFileSync3(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
-  }
   /** Default exec implementation using child_process. */
   defaultExec(command, options) {
     return execSync2(command, { timeout: options.timeout, stdio: "pipe" });
@@ -2069,9 +2211,9 @@ var MarketplaceClient = class {
 };
 
 // src/plugins/plugin-hooks-merger.ts
-import { join as join10, dirname as dirname5 } from "path";
+import { join as join11, dirname as dirname5 } from "path";
 function buildPluginEnv(plugin) {
-  const dataDir = join10(dirname5(dirname5(plugin.pluginDir)), "data", plugin.manifest.name);
+  const dataDir = join11(dirname5(dirname5(plugin.pluginDir)), "data", plugin.manifest.name);
   return {
     CLAUDE_PLUGIN_ROOT: plugin.pluginDir,
     CLAUDE_PLUGIN_PATH: plugin.pluginDir,
@@ -2132,41 +2274,111 @@ function mergeHooksIntoConfig(configHooks, pluginHooks) {
   return merged;
 }
 
-// src/interactive/interactive-session.ts
+// src/interactive/interactive-session-init.ts
 import { homedir as homedir3 } from "os";
-import { join as join11 } from "path";
-var TOOL_ARG_DISPLAY_MAX = 80;
-var TAIL_KEEP = 30;
-var MAX_COMPLETED_TOOLS = 50;
-var STREAMING_FLUSH_INTERVAL_MS = 16;
+import { join as join12 } from "path";
+async function createInteractiveSession(options) {
+  const cwd = options.cwd;
+  const [config, context, projectInfo] = await Promise.all([
+    loadConfig(cwd),
+    loadContext(cwd),
+    detectProject(cwd)
+  ]);
+  const pluginsDir = join12(homedir3(), ".robota", "plugins");
+  const pluginLoader = new BundlePluginLoader(pluginsDir);
+  let mergedConfig = config;
+  try {
+    const plugins = pluginLoader.loadPluginsSync();
+    if (plugins.length > 0) {
+      const pluginHooks = mergePluginHooks(plugins);
+      mergedConfig = {
+        ...config,
+        hooks: mergeHooksIntoConfig(
+          config.hooks,
+          pluginHooks
+        )
+      };
+    }
+  } catch {
+  }
+  const paths = projectPaths(cwd);
+  const sessionId = options.resumeSessionId && !options.forkSession ? options.resumeSessionId : void 0;
+  return createSession({
+    config: mergedConfig,
+    context,
+    projectInfo,
+    permissionMode: options.permissionMode,
+    maxTurns: options.maxTurns,
+    terminal: NOOP_TERMINAL,
+    sessionLogger: new FileSessionLogger2(paths.logs),
+    permissionHandler: options.permissionHandler,
+    provider: options.provider,
+    onTextDelta: options.onTextDelta,
+    onToolExecution: options.onToolExecution,
+    sessionId
+  });
+}
+function injectSavedMessage(session, msg) {
+  if (!msg || typeof msg !== "object") return;
+  const m = msg;
+  if (!m.role || !m.content) return;
+  const role = m.role;
+  if (role === "tool") {
+    const toolCallId = m.toolCallId ?? "";
+    const name = m.name ?? void 0;
+    session.injectMessage("tool", m.content, { toolCallId, name });
+  } else if (role === "user" || role === "assistant" || role === "system") {
+    session.injectMessage(role, m.content);
+  }
+}
+function loadSessionRecord(sessionStore, resumeSessionId, forkSession, existingSession) {
+  const record = sessionStore.load(resumeSessionId);
+  if (!record) {
+    return { history: [], sessionName: void 0, pendingRestoreMessages: null };
+  }
+  const history = record.history ?? [];
+  const sessionName = record.name;
+  let pendingRestoreMessages = null;
+  if (!forkSession && record.messages) {
+    if (existingSession) {
+      for (const msg of record.messages) {
+        injectSavedMessage(existingSession, msg);
+      }
+    } else {
+      pendingRestoreMessages = record.messages;
+    }
+  }
+  return { history, sessionName, pendingRestoreMessages };
+}
+
+// src/interactive/interactive-session.ts
 var InteractiveSession = class {
   session = null;
   commandExecutor;
   listeners = /* @__PURE__ */ new Map();
   initialized = false;
   initPromise = null;
-  // Streaming state
   streamingText = "";
   flushTimer = null;
-  // Tool state
   activeTools = [];
-  // Execution state
   executing = false;
   pendingPrompt = null;
   pendingDisplayInput;
   pendingRawInput;
-  // Full history timeline (chat messages + events)
   history = [];
-  // Session persistence
   sessionStore;
   sessionName;
   cwd;
-  // Session restore state
   pendingRestoreMessages = null;
   resumeSessionId;
   forkSession;
   constructor(options) {
     this.commandExecutor = new SystemCommandExecutor(createSystemCommands());
+    this.sessionStore = options.sessionStore;
+    this.sessionName = options.sessionName;
+    this.cwd = ("cwd" in options ? options.cwd : void 0) ?? "";
+    this.resumeSessionId = options.resumeSessionId;
+    this.forkSession = options.forkSession ?? false;
     if ("session" in options && options.session) {
       this.session = options.session;
       this.initialized = true;
@@ -2174,98 +2386,46 @@ var InteractiveSession = class {
       const stdOpts = options;
       this.initPromise = this.initializeAsync(stdOpts);
     }
-    this.sessionStore = options.sessionStore;
-    this.sessionName = options.sessionName;
-    this.cwd = ("cwd" in options ? options.cwd : void 0) ?? "";
-    this.resumeSessionId = options.resumeSessionId;
-    this.forkSession = options.forkSession ?? false;
     if (options.resumeSessionId && this.sessionStore) {
-      const record = this.sessionStore.load(options.resumeSessionId);
-      if (record) {
-        this.history = record.history ?? [];
-        this.sessionName = record.name;
-        if (record.messages) {
-          if (this.session) {
-            for (const msg of record.messages) {
-              const m = msg;
-              if (m.role && m.content) {
-                this.session.injectMessage(m.role, m.content);
-              }
-            }
-          } else {
-            this.pendingRestoreMessages = record.messages;
-          }
-        }
-      }
+      const restored = loadSessionRecord(
+        this.sessionStore,
+        options.resumeSessionId,
+        this.forkSession,
+        this.session
+      );
+      if (restored.history.length > 0) this.history = restored.history;
+      if (restored.sessionName) this.sessionName = restored.sessionName;
+      this.pendingRestoreMessages = restored.pendingRestoreMessages;
     }
   }
   async initializeAsync(options) {
-    const cwd = options.cwd;
-    const [config, context, projectInfo] = await Promise.all([
-      loadConfig(cwd),
-      loadContext(cwd),
-      detectProject(cwd)
-    ]);
-    const pluginsDir = join11(homedir3(), ".robota", "plugins");
-    const pluginLoader = new BundlePluginLoader(pluginsDir);
-    let mergedConfig = config;
-    try {
-      const plugins = pluginLoader.loadPluginsSync();
-      if (plugins.length > 0) {
-        const pluginHooks = mergePluginHooks(plugins);
-        mergedConfig = {
-          ...config,
-          hooks: mergeHooksIntoConfig(
-            config.hooks,
-            pluginHooks
-          )
-        };
-      }
-    } catch {
-    }
-    const paths = projectPaths(cwd);
-    const sessionId = this.resumeSessionId && !this.forkSession ? this.resumeSessionId : void 0;
-    this.session = createSession({
-      config: mergedConfig,
-      context,
-      projectInfo,
+    this.session = await createInteractiveSession({
+      cwd: options.cwd,
+      provider: options.provider,
       permissionMode: options.permissionMode,
       maxTurns: options.maxTurns,
-      terminal: NOOP_TERMINAL,
-      sessionLogger: new FileSessionLogger2(paths.logs),
       permissionHandler: options.permissionHandler,
-      provider: options.provider,
+      resumeSessionId: this.resumeSessionId,
+      forkSession: this.forkSession,
       onTextDelta: (delta) => this.handleTextDelta(delta),
-      onToolExecution: (event) => this.handleToolExecution(event),
-      sessionId
+      onToolExecution: (event) => this.handleToolExecution(event)
     });
     if (this.pendingRestoreMessages) {
-      for (const msg of this.pendingRestoreMessages) {
-        if (msg && typeof msg === "object" && "role" in msg && "content" in msg) {
-          this.session.injectMessage(
-            msg.role,
-            msg.content
-          );
-        }
-      }
+      for (const msg of this.pendingRestoreMessages) injectSavedMessage(this.session, msg);
       this.pendingRestoreMessages = null;
     }
     this.initialized = true;
   }
   async ensureInitialized() {
-    if (this.initialized) return;
-    if (this.initPromise) await this.initPromise;
+    if (!this.initialized && this.initPromise) await this.initPromise;
   }
   getSessionOrThrow() {
     if (!this.session)
       throw new Error("InteractiveSession not initialized. Call submit() or await initialization.");
     return this.session;
   }
-  // ── Event system ──────────────────────────────────────────────
   on(event, handler) {
-    if (!this.listeners.has(event)) {
-      this.listeners.set(event, /* @__PURE__ */ new Set());
-    }
+    if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
     this.listeners.get(event).add(handler);
   }
   off(event, handler) {
@@ -2273,14 +2433,8 @@ var InteractiveSession = class {
   }
   emit(event, ...args) {
     const handlers = this.listeners.get(event);
-    if (handlers) {
-      for (const handler of handlers) {
-        handler(...args);
-      }
-    }
+    if (handlers) for (const handler of handlers) handler(...args);
   }
-  // ── Public API ────────────────────────────────────────────────
-  /** Submit a prompt. Queues if already executing (max 1 queued). */
   async submit(input, displayInput, rawInput) {
     await this.ensureInitialized();
     if (this.executing) {
@@ -2291,27 +2445,24 @@ var InteractiveSession = class {
     }
     await this.executePrompt(input, displayInput, rawInput);
   }
-  /** Execute a system command by name. Returns null if not found. */
   async executeCommand(name, args) {
     await this.ensureInitialized();
     return this.commandExecutor.execute(name, this, args);
   }
-  /** List all registered system commands. */
   listCommands() {
     return this.commandExecutor.listCommands().map((cmd) => ({
       name: cmd.name,
       description: cmd.description
     }));
   }
-  /** Abort current execution and clear queue. */
   abort() {
-    this.pendingPrompt = null;
-    this.pendingDisplayInput = void 0;
-    this.pendingRawInput = void 0;
+    this.clearPendingQueue();
     this.session?.abort();
   }
-  /** Cancel queued prompt without aborting current execution. */
   cancelQueue() {
+    this.clearPendingQueue();
+  }
+  clearPendingQueue() {
     this.pendingPrompt = null;
     this.pendingDisplayInput = void 0;
     this.pendingRawInput = void 0;
@@ -2322,11 +2473,9 @@ var InteractiveSession = class {
   getPendingPrompt() {
     return this.pendingPrompt;
   }
-  /** Get full history timeline (chat + events) for TUI rendering */
   getFullHistory() {
     return this.history;
   }
-  /** Get chat messages only (backward compatible) */
   getMessages() {
     return this.history.filter((e) => e.category === "chat").map((e) => e.data);
   }
@@ -2339,11 +2488,12 @@ var InteractiveSession = class {
   getContextState() {
     return this.getSessionOrThrow().getContextState();
   }
-  /** Get session name. */
   getName() {
     return this.sessionName;
   }
-  /** Set session name and persist if store is available. */
+  getSession() {
+    return this.getSessionOrThrow();
+  }
   setName(name) {
     this.sessionName = name;
     if (this.sessionStore && this.session) {
@@ -2359,15 +2509,9 @@ var InteractiveSession = class {
       }
     }
   }
-  /** Attach a transport adapter to this session. Calls transport.attach(this). */
   attachTransport(transport) {
     transport.attach(this);
   }
-  /** Access underlying Session. For advanced use / testing only. */
-  getSession() {
-    return this.getSessionOrThrow();
-  }
-  // ── Execution ─────────────────────────────────────────────────
   async executePrompt(input, displayInput, rawInput) {
     this.executing = true;
     this.clearStreaming();
@@ -2377,25 +2521,35 @@ var InteractiveSession = class {
     try {
       const response = await this.getSessionOrThrow().run(input, rawInput);
       this.flushStreaming();
-      this.pushToolSummaryMessage();
+      pushToolSummaryToHistory({ activeTools: this.activeTools, history: this.history });
       this.clearStreaming();
-      const result = this.buildResult(response || "(empty response)", historyBefore);
+      const result = buildResult(
+        response || "(empty response)",
+        this.getSessionOrThrow().getHistory(),
+        this.history,
+        historyBefore,
+        this.getContextState()
+      );
       this.history.push(messageToHistoryEntry(createAssistantMessage(result.response)));
       this.emit("complete", result);
       this.emit("context_update", this.getContextState());
     } catch (err) {
       this.flushStreaming();
       if (isAbortError(err)) {
-        const result = this.buildInterruptedResult(historyBefore);
-        this.pushToolSummaryMessage();
+        const result = buildInterruptedResult(
+          this.getSessionOrThrow().getHistory(),
+          this.history,
+          historyBefore,
+          this.getContextState()
+        );
+        pushToolSummaryToHistory({ activeTools: this.activeTools, history: this.history });
         this.clearStreaming();
-        if (result.response) {
+        if (result.response)
           this.history.push(messageToHistoryEntry(createAssistantMessage(result.response)));
-        }
         this.history.push(messageToHistoryEntry(createSystemMessage("Interrupted by user.")));
         this.emit("interrupted", result);
       } else {
-        this.pushToolSummaryMessage();
+        pushToolSummaryToHistory({ activeTools: this.activeTools, history: this.history });
         this.clearStreaming();
         const errMsg = err instanceof Error ? err.message : String(err);
         this.history.push(messageToHistoryEntry(createSystemMessage(`Error: ${errMsg}`)));
@@ -2405,33 +2559,23 @@ var InteractiveSession = class {
       this.executing = false;
       this.emit("thinking", false);
       if (this.sessionStore && this.session) {
-        try {
-          const sessionId = this.getSessionOrThrow().getSessionId();
-          const existing = this.sessionStore.load(sessionId);
-          this.sessionStore.save({
-            id: sessionId,
-            name: this.sessionName ?? existing?.name,
-            cwd: this.cwd ?? "",
-            createdAt: existing?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-            updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-            messages: this.getSessionOrThrow().getHistory(),
-            history: this.history
-          });
-        } catch {
-        }
+        persistSession(
+          this.sessionStore,
+          this.session,
+          this.sessionName,
+          this.cwd ?? "",
+          this.history
+        );
       }
       if (this.pendingPrompt) {
         const queued = this.pendingPrompt;
         const queuedDisplay = this.pendingDisplayInput;
         const queuedRaw = this.pendingRawInput;
-        this.pendingPrompt = null;
-        this.pendingDisplayInput = void 0;
-        this.pendingRawInput = void 0;
+        this.clearPendingQueue();
         setTimeout(() => this.executePrompt(queued, queuedDisplay, queuedRaw), 0);
       }
     }
   }
-  // ── Streaming callbacks ───────────────────────────────────────
   handleTextDelta(delta) {
     this.streamingText += delta;
     this.emit("text_delta", delta);
@@ -2442,67 +2586,17 @@ var InteractiveSession = class {
     }
   }
   handleToolExecution(event) {
+    const streamingState = { activeTools: this.activeTools, history: this.history };
     if (event.type === "start") {
-      const firstArg = extractFirstArg(event.toolArgs);
-      const state = { toolName: event.toolName, firstArg, isRunning: true };
-      this.activeTools.push(state);
-      this.emit("tool_start", state);
-      this.history.push({
-        id: randomUUID(),
-        timestamp: /* @__PURE__ */ new Date(),
-        category: "event",
-        type: "tool-start",
-        data: { toolName: event.toolName, firstArg, isRunning: true }
-      });
+      const toolState = applyToolStart(streamingState, event);
+      this.activeTools = streamingState.activeTools;
+      this.emit("tool_start", toolState);
     } else {
-      const result = event.denied ? "denied" : event.success === false ? "error" : "success";
-      const idx = this.activeTools.findIndex((t) => t.toolName === event.toolName && t.isRunning);
-      if (idx !== -1) {
-        const finished = { ...this.activeTools[idx], isRunning: false, result };
-        this.activeTools[idx] = finished;
-        this.trimCompletedTools();
-        this.emit("tool_end", finished);
-        this.history.push({
-          id: randomUUID(),
-          timestamp: /* @__PURE__ */ new Date(),
-          category: "event",
-          type: "tool-end",
-          data: {
-            toolName: finished.toolName,
-            firstArg: finished.firstArg,
-            isRunning: false,
-            result
-          }
-        });
-      }
+      const finished = applyToolEnd(streamingState, event);
+      this.activeTools = streamingState.activeTools;
+      if (finished) this.emit("tool_end", finished);
     }
   }
-  // ── Helpers ───────────────────────────────────────────────────
-  /** Push tool execution summary into messages (before Robota response).
-   *  Moves tool info from activeTools (real-time display) to messages (permanent display).
-   *  After this, activeTools will be cleared by clearStreaming(). */
-  pushToolSummaryMessage() {
-    if (this.activeTools.length === 0) return;
-    const summary = this.activeTools.map((t) => {
-      const status = t.isRunning ? "\u27F3" : t.result === "success" ? "\u2713" : t.result === "error" ? "\u2717" : "\u2298";
-      return `${status} ${t.toolName}${t.firstArg ? `(${t.firstArg})` : ""}`;
-    }).join("\n");
-    this.history.push({
-      id: randomUUID(),
-      timestamp: /* @__PURE__ */ new Date(),
-      category: "event",
-      type: "tool-summary",
-      data: {
-        tools: this.activeTools.map((t) => ({
-          toolName: t.toolName,
-          firstArg: t.firstArg,
-          isRunning: t.isRunning,
-          result: t.result
-        })),
-        summary
-      }
-    });
-  }
   clearStreaming() {
     this.streamingText = "";
     this.activeTools = [];
@@ -2517,81 +2611,6 @@ var InteractiveSession = class {
       this.flushTimer = null;
     }
   }
-  buildResult(response, historyBefore) {
-    const toolSummaries = this.extractToolSummaries(historyBefore);
-    return {
-      response,
-      history: this.history,
-      toolSummaries,
-      contextState: this.getContextState()
-    };
-  }
-  buildInterruptedResult(historyBefore) {
-    const history = this.getSessionOrThrow().getHistory();
-    const toolSummaries = this.extractToolSummaries(historyBefore);
-    const parts = [];
-    for (let i = historyBefore; i < history.length; i++) {
-      const msg = history[i];
-      if (msg?.role === "assistant" && msg.content) parts.push(msg.content);
-    }
-    return {
-      response: parts.join("\n\n"),
-      history: this.history,
-      toolSummaries,
-      contextState: this.getContextState()
-    };
-  }
-  extractToolSummaries(historyBefore) {
-    const history = this.getSessionOrThrow().getHistory();
-    const summaries = [];
-    for (let i = historyBefore; i < history.length; i++) {
-      const msg = history[i];
-      if (msg?.role === "assistant" && msg.toolCalls) {
-        for (const tc of msg.toolCalls) {
-          summaries.push({ name: tc.function.name, args: tc.function.arguments });
-        }
-      }
-    }
-    return summaries;
-  }
-  trimCompletedTools() {
-    const completed = this.activeTools.filter((t) => !t.isRunning);
-    if (completed.length > MAX_COMPLETED_TOOLS) {
-      const excess = completed.length - MAX_COMPLETED_TOOLS;
-      let removed = 0;
-      this.activeTools = this.activeTools.filter((t) => {
-        if (!t.isRunning && removed < excess) {
-          removed++;
-          return false;
-        }
-        return true;
-      });
-    }
-  }
-};
-function isAbortError(err) {
-  return err instanceof DOMException && err.name === "AbortError" || err instanceof Error && (err.message.includes("aborted") || err.message.includes("abort"));
-}
-function extractFirstArg(toolArgs) {
-  if (!toolArgs) return "";
-  const firstVal = Object.values(toolArgs)[0];
-  const raw = typeof firstVal === "string" ? firstVal : JSON.stringify(firstVal ?? "");
-  return raw.length > TOOL_ARG_DISPLAY_MAX ? raw.slice(0, TOOL_ARG_DISPLAY_MAX - TAIL_KEEP - 3) + "..." + raw.slice(-TAIL_KEEP) : raw;
-}
-var NOOP_TERMINAL = {
-  write: () => {
-  },
-  writeLine: () => {
-  },
-  writeMarkdown: () => {
-  },
-  writeError: () => {
-  },
-  prompt: () => Promise.resolve(""),
-  select: () => Promise.resolve(0),
-  spinner: () => ({ stop: () => {
-  }, update: () => {
-  } })
 };
 
 // src/query.ts
@@ -2746,8 +2765,8 @@ var BuiltinCommandSource = class {
 };
 
 // src/commands/skill-source.ts
-import { readdirSync as readdirSync3, readFileSync as readFileSync9, existsSync as existsSync9 } from "fs";
-import { join as join12, basename as basename2 } from "path";
+import { readdirSync as readdirSync4, readFileSync as readFileSync10, existsSync as existsSync11 } from "fs";
+import { join as join13, basename as basename2 } from "path";
 import { homedir as homedir4 } from "os";
 var BOOLEAN_KEYS = /* @__PURE__ */ new Set(["disable-model-invocation", "user-invocable"]);
 var LIST_KEYS2 = /* @__PURE__ */ new Set(["allowed-tools"]);
@@ -2795,27 +2814,27 @@ function buildCommand(frontmatter, content, fallbackName) {
   return cmd;
 }
 function scanSkillsDir(skillsDir) {
-  if (!existsSync9(skillsDir)) return [];
+  if (!existsSync11(skillsDir)) return [];
   const commands = [];
-  const entries = readdirSync3(skillsDir, { withFileTypes: true });
+  const entries = readdirSync4(skillsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const skillFile = join12(skillsDir, entry.name, "SKILL.md");
-    if (!existsSync9(skillFile)) continue;
-    const content = readFileSync9(skillFile, "utf-8");
+    const skillFile = join13(skillsDir, entry.name, "SKILL.md");
+    if (!existsSync11(skillFile)) continue;
+    const content = readFileSync10(skillFile, "utf-8");
     const frontmatter = parseFrontmatter2(content);
     commands.push(buildCommand(frontmatter, content, entry.name));
   }
   return commands;
 }
 function scanCommandsDir(commandsDir) {
-  if (!existsSync9(commandsDir)) return [];
+  if (!existsSync11(commandsDir)) return [];
   const commands = [];
-  const entries = readdirSync3(commandsDir, { withFileTypes: true });
+  const entries = readdirSync4(commandsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const filePath = join12(commandsDir, entry.name);
-    const content = readFileSync9(filePath, "utf-8");
+    const filePath = join13(commandsDir, entry.name);
+    const content = readFileSync10(filePath, "utf-8");
     const frontmatter = parseFrontmatter2(content);
     const fallbackName = basename2(entry.name, ".md");
     commands.push(buildCommand(frontmatter, content, fallbackName));
@@ -2834,10 +2853,10 @@ var SkillCommandSource = class {
   getCommands() {
     if (this.cachedCommands) return this.cachedCommands;
     const sources = [
-      scanSkillsDir(join12(this.cwd, ".claude", "skills")),
-      scanCommandsDir(join12(this.cwd, ".claude", "commands")),
-      scanSkillsDir(join12(this.home, ".robota", "skills")),
-      scanSkillsDir(join12(this.cwd, ".agents", "skills"))
+      scanSkillsDir(join13(this.cwd, ".claude", "skills")),
+      scanCommandsDir(join13(this.cwd, ".claude", "commands")),
+      scanSkillsDir(join13(this.home, ".robota", "skills")),
+      scanSkillsDir(join13(this.cwd, ".agents", "skills"))
     ];
     const seen = /* @__PURE__ */ new Set();
     const merged = [];