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

package/dist/node/index.cjs

@@ -70,6 +70,386 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/interactive/interactive-session.ts
+var import_agent_core = require("@robota-sdk/agent-core");
+
+// 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);
+    }
+  }
+  /** Register an additional command. */
+  register(command) {
+    this.commands.set(command.name, command);
+  }
+  /** 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);
+  }
+  /** List all registered commands. */
+  listCommands() {
+    return [...this.commands.values()];
+  }
+  /** Check if a command exists. */
+  hasCommand(name) {
+    return this.commands.has(name);
+  }
+};
+
+// 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 summaries;
+}
+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/interactive/interactive-session-streaming.ts
+var import_node_crypto = require("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: (0, import_node_crypto.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: (0, import_node_crypto.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: (0, import_node_crypto.randomUUID)(),
+    timestamp: /* @__PURE__ */ new Date(),
+    category: "event",
+    type: "tool-end",
+    data: {
+      toolName: finished.toolName,
+      firstArg: finished.firstArg,
+      isRunning: false,
+      result
+    }
+  });
+  return finished;
+}
+
 // src/hooks/prompt-executor.ts
 function extractJson(raw) {
   const codeBlockMatch = /```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/.exec(raw);
@@ -740,7 +1120,7 @@ function resolveSubagentLogDir(parentSessionId, baseLogsDir) {
   return (0, import_node_path2.join)(baseLogsDir, parentSessionId, "subagents");
 }
 
-// src/interactive/interactive-session.ts
+// src/interactive/interactive-session-init.ts
 var import_agent_sessions4 = require("@robota-sdk/agent-sessions");
 
 // src/paths.ts
@@ -1050,278 +1430,50 @@ function detectPackageManager(cwd) {
     return "bun";
   }
   if ((0, import_fs3.existsSync)((0, import_path3.join)(cwd, "package-lock.json"))) {
-    return "npm";
-  }
-  return void 0;
-}
-async function detectProject(cwd) {
-  const pkgJsonPath = (0, import_path3.join)(cwd, "package.json");
-  const tsconfigPath = (0, import_path3.join)(cwd, "tsconfig.json");
-  const pyprojectPath = (0, import_path3.join)(cwd, "pyproject.toml");
-  const cargoPath = (0, import_path3.join)(cwd, "Cargo.toml");
-  const goModPath = (0, import_path3.join)(cwd, "go.mod");
-  if ((0, import_fs3.existsSync)(pkgJsonPath)) {
-    const pkgJson = tryReadJson(pkgJsonPath);
-    const language = (0, import_fs3.existsSync)(tsconfigPath) ? "typescript" : "javascript";
-    const packageManager = detectPackageManager(cwd);
-    return {
-      type: "node",
-      name: pkgJson?.name,
-      packageManager,
-      language
-    };
-  }
-  if ((0, import_fs3.existsSync)(pyprojectPath) || (0, import_fs3.existsSync)((0, import_path3.join)(cwd, "setup.py"))) {
-    return {
-      type: "python",
-      language: "python"
-    };
-  }
-  if ((0, import_fs3.existsSync)(cargoPath)) {
-    return {
-      type: "rust",
-      language: "rust"
-    };
-  }
-  if ((0, import_fs3.existsSync)(goModPath)) {
-    return {
-      type: "go",
-      language: "go"
-    };
-  }
-  return {
-    type: "unknown",
-    language: "unknown"
-  };
-}
-
-// src/interactive/interactive-session.ts
-var import_agent_core = require("@robota-sdk/agent-core");
-var import_node_crypto = require("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);
-    }
-  }
-  /** Register an additional command. */
-  register(command) {
-    this.commands.set(command.name, command);
+    return "npm";
   }
-  /** 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);
+  return void 0;
+}
+async function detectProject(cwd) {
+  const pkgJsonPath = (0, import_path3.join)(cwd, "package.json");
+  const tsconfigPath = (0, import_path3.join)(cwd, "tsconfig.json");
+  const pyprojectPath = (0, import_path3.join)(cwd, "pyproject.toml");
+  const cargoPath = (0, import_path3.join)(cwd, "Cargo.toml");
+  const goModPath = (0, import_path3.join)(cwd, "go.mod");
+  if ((0, import_fs3.existsSync)(pkgJsonPath)) {
+    const pkgJson = tryReadJson(pkgJsonPath);
+    const language = (0, import_fs3.existsSync)(tsconfigPath) ? "typescript" : "javascript";
+    const packageManager = detectPackageManager(cwd);
+    return {
+      type: "node",
+      name: pkgJson?.name,
+      packageManager,
+      language
+    };
   }
-  /** List all registered commands. */
-  listCommands() {
-    return [...this.commands.values()];
+  if ((0, import_fs3.existsSync)(pyprojectPath) || (0, import_fs3.existsSync)((0, import_path3.join)(cwd, "setup.py"))) {
+    return {
+      type: "python",
+      language: "python"
+    };
   }
-  /** Check if a command exists. */
-  hasCommand(name) {
-    return this.commands.has(name);
+  if ((0, import_fs3.existsSync)(cargoPath)) {
+    return {
+      type: "rust",
+      language: "rust"
+    };
   }
-};
+  if ((0, import_fs3.existsSync)(goModPath)) {
+    return {
+      type: "go",
+      language: "go"
+    };
+  }
+  return {
+    type: "unknown",
+    language: "unknown"
+  };
+}
 
 // src/plugins/plugin-settings-store.ts
 var import_node_fs3 = require("fs");
@@ -1425,8 +1577,11 @@ var PluginSettingsStore = class {
 };
 
 // src/plugins/bundle-plugin-loader.ts
-var import_node_fs4 = require("fs");
+var import_node_fs5 = require("fs");
 var import_node_path5 = require("path");
+
+// src/plugins/bundle-plugin-utils.ts
+var import_node_fs4 = require("fs");
 function parseSkillFrontmatter(raw) {
   const trimmed = raw.trimStart();
   if (!trimmed.startsWith("---")) {
@@ -1483,6 +1638,8 @@ function getSortedSubdirs(dirPath) {
     return [];
   }
 }
+
+// src/plugins/bundle-plugin-loader.ts
 var BundlePluginLoader = class {
   pluginsDir;
   enabledPlugins;
@@ -1506,7 +1663,7 @@ var BundlePluginLoader = class {
    */
   discoverAndLoad() {
     const cacheDir = (0, import_node_path5.join)(this.pluginsDir, "cache");
-    if (!(0, import_node_fs4.existsSync)(cacheDir)) {
+    if (!(0, import_node_fs5.existsSync)(cacheDir)) {
       return [];
     }
     const results = [];
@@ -1521,7 +1678,7 @@ var BundlePluginLoader = class {
         const latestVersion = versions[versions.length - 1];
         const versionDir = (0, import_node_path5.join)(pluginDir, latestVersion);
         const manifestPath = (0, import_node_path5.join)(versionDir, ".claude-plugin", "plugin.json");
-        if (!(0, import_node_fs4.existsSync)(manifestPath)) continue;
+        if (!(0, import_node_fs5.existsSync)(manifestPath)) continue;
         const manifest = this.readManifest(manifestPath);
         if (!manifest) continue;
         const pluginId = `${manifest.name}@${marketplace}`;
@@ -1535,7 +1692,7 @@ var BundlePluginLoader = class {
   /** Read and validate a plugin.json manifest. Returns null on failure. */
   readManifest(path) {
     try {
-      const raw = (0, import_node_fs4.readFileSync)(path, "utf-8");
+      const raw = (0, import_node_fs5.readFileSync)(path, "utf-8");
       const data = JSON.parse(raw);
       return validateManifest(data);
     } catch {
@@ -1571,14 +1728,14 @@ var BundlePluginLoader = class {
   /** Load skills from the plugin's skills/ directory. */
   loadSkills(pluginDir, pluginName) {
     const skillsDir = (0, import_node_path5.join)(pluginDir, "skills");
-    if (!(0, import_node_fs4.existsSync)(skillsDir)) return [];
-    const entries = (0, import_node_fs4.readdirSync)(skillsDir, { withFileTypes: true });
+    if (!(0, import_node_fs5.existsSync)(skillsDir)) return [];
+    const entries = (0, import_node_fs5.readdirSync)(skillsDir, { withFileTypes: true });
     const skills = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const skillFile = (0, import_node_path5.join)(skillsDir, entry.name, "SKILL.md");
-      if (!(0, import_node_fs4.existsSync)(skillFile)) continue;
-      const raw = (0, import_node_fs4.readFileSync)(skillFile, "utf-8");
+      if (!(0, import_node_fs5.existsSync)(skillFile)) continue;
+      const raw = (0, import_node_fs5.readFileSync)(skillFile, "utf-8");
       const { metadata, content } = parseSkillFrontmatter(raw);
       const description = typeof metadata.description === "string" ? metadata.description : "";
       const skill = {
@@ -1594,12 +1751,12 @@ var BundlePluginLoader = class {
   /** Load commands from the plugin's commands/ directory (flat .md files). */
   loadCommands(pluginDir, pluginName) {
     const commandsDir = (0, import_node_path5.join)(pluginDir, "commands");
-    if (!(0, import_node_fs4.existsSync)(commandsDir)) return [];
-    const entries = (0, import_node_fs4.readdirSync)(commandsDir, { withFileTypes: true });
+    if (!(0, import_node_fs5.existsSync)(commandsDir)) return [];
+    const entries = (0, import_node_fs5.readdirSync)(commandsDir, { withFileTypes: true });
     const commands = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const raw = (0, import_node_fs4.readFileSync)((0, import_node_path5.join)(commandsDir, entry.name), "utf-8");
+      const raw = (0, import_node_fs5.readFileSync)((0, import_node_path5.join)(commandsDir, entry.name), "utf-8");
       const { metadata, content } = parseSkillFrontmatter(raw);
       const name = typeof metadata.name === "string" ? metadata.name : entry.name.replace(/\.md$/, "");
       const description = typeof metadata.description === "string" ? metadata.description : "";
@@ -1615,9 +1772,9 @@ var BundlePluginLoader = class {
   /** Load hooks from hooks/hooks.json if present. */
   loadHooks(pluginDir) {
     const hooksPath = (0, import_node_path5.join)(pluginDir, "hooks", "hooks.json");
-    if (!(0, import_node_fs4.existsSync)(hooksPath)) return {};
+    if (!(0, import_node_fs5.existsSync)(hooksPath)) return {};
     try {
-      const raw = (0, import_node_fs4.readFileSync)(hooksPath, "utf-8");
+      const raw = (0, import_node_fs5.readFileSync)(hooksPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data === "object" && data !== null) {
         return data;
@@ -1631,10 +1788,10 @@ var BundlePluginLoader = class {
   loadMcpConfig(pluginDir) {
     const primaryPath = (0, import_node_path5.join)(pluginDir, ".mcp.json");
     const fallbackPath = (0, import_node_path5.join)(pluginDir, ".claude-plugin", "mcp.json");
-    const mcpPath = (0, import_node_fs4.existsSync)(primaryPath) ? primaryPath : fallbackPath;
-    if (!(0, import_node_fs4.existsSync)(mcpPath)) return void 0;
+    const mcpPath = (0, import_node_fs5.existsSync)(primaryPath) ? primaryPath : fallbackPath;
+    if (!(0, import_node_fs5.existsSync)(mcpPath)) return void 0;
     try {
-      const raw = (0, import_node_fs4.readFileSync)(mcpPath, "utf-8");
+      const raw = (0, import_node_fs5.readFileSync)(mcpPath, "utf-8");
       return JSON.parse(raw);
     } catch {
       return void 0;
@@ -1643,9 +1800,9 @@ var BundlePluginLoader = class {
   /** Load agent definitions from agents/ directory if present. */
   loadAgents(pluginDir) {
     const agentsDir = (0, import_node_path5.join)(pluginDir, "agents");
-    if (!(0, import_node_fs4.existsSync)(agentsDir)) return [];
+    if (!(0, import_node_fs5.existsSync)(agentsDir)) return [];
     try {
-      const entries = (0, import_node_fs4.readdirSync)(agentsDir, { withFileTypes: true });
+      const entries = (0, import_node_fs5.readdirSync)(agentsDir, { withFileTypes: true });
       return entries.filter((e) => e.isDirectory() || e.name.endsWith(".md")).map((e) => e.name.replace(/\.md$/, ""));
     } catch {
       return [];
@@ -1655,7 +1812,7 @@ var BundlePluginLoader = class {
 
 // src/plugins/bundle-plugin-installer.ts
 var import_node_child_process = require("child_process");
-var import_node_fs5 = require("fs");
+var import_node_fs6 = require("fs");
 var import_node_path6 = require("path");
 var GIT_CLONE_TIMEOUT_MS = 6e4;
 var BundlePluginInstaller = class {
@@ -1689,7 +1846,7 @@ var BundlePluginInstaller = class {
     }
     const version = this.resolveVersion(entry, marketplaceName);
     const targetDir = (0, import_node_path6.join)(this.cacheDir, marketplaceName, pluginName, version);
-    if ((0, import_node_fs5.existsSync)(targetDir)) {
+    if ((0, import_node_fs6.existsSync)(targetDir)) {
       throw new Error(
         `Plugin "${pluginName}" version "${version}" is already installed from "${marketplaceName}"`
       );
@@ -1716,8 +1873,8 @@ var BundlePluginInstaller = class {
     if (!record) {
       throw new Error(`Plugin "${pluginId}" is not installed`);
     }
-    if ((0, import_node_fs5.existsSync)(record.installPath)) {
-      (0, import_node_fs5.rmSync)(record.installPath, { recursive: true, force: true });
+    if ((0, import_node_fs6.existsSync)(record.installPath)) {
+      (0, import_node_fs6.rmSync)(record.installPath, { recursive: true, force: true });
     }
     delete registry[pluginId];
     this.writeRegistry(registry);
@@ -1763,18 +1920,18 @@ var BundlePluginInstaller = class {
   }
   /** Resolve the source and install the plugin. */
   resolveAndInstall(rawSource, marketplaceName, pluginName, targetDir) {
-    (0, import_node_fs5.mkdirSync)(targetDir, { recursive: true });
+    (0, import_node_fs6.mkdirSync)(targetDir, { recursive: true });
     const source = this.normalizeSource(rawSource);
     try {
       if (typeof source === "string") {
         const marketplaceDir = this.marketplaceClient.getMarketplaceDir(marketplaceName);
         const sourcePath = (0, import_node_path6.join)(marketplaceDir, source);
-        if (!(0, import_node_fs5.existsSync)(sourcePath)) {
+        if (!(0, import_node_fs6.existsSync)(sourcePath)) {
           throw new Error(
             `Plugin source path "${source}" not found in marketplace "${marketplaceName}"`
           );
         }
-        (0, import_node_fs5.cpSync)(sourcePath, targetDir, { recursive: true });
+        (0, import_node_fs6.cpSync)(sourcePath, targetDir, { recursive: true });
       } else if (source.type === "github") {
         const repoUrl = `https://github.com/${source.repo}.git`;
         this.cloneToDir(repoUrl, targetDir, pluginName);
@@ -1786,15 +1943,15 @@ var BundlePluginInstaller = class {
         throw new Error(`Unknown source type: ${JSON.stringify(source)}`);
       }
     } catch (err) {
-      if ((0, import_node_fs5.existsSync)(targetDir)) {
-        (0, import_node_fs5.rmSync)(targetDir, { recursive: true, force: true });
+      if ((0, import_node_fs6.existsSync)(targetDir)) {
+        (0, import_node_fs6.rmSync)(targetDir, { recursive: true, force: true });
       }
       throw err;
     }
   }
   /** Clone a git repository to the target directory. */
   cloneToDir(repoUrl, targetDir, pluginName) {
-    (0, import_node_fs5.rmSync)(targetDir, { recursive: true, force: true });
+    (0, import_node_fs6.rmSync)(targetDir, { recursive: true, force: true });
     const command = `git clone --depth 1 ${repoUrl} ${targetDir}`;
     try {
       this.exec(command, { timeout: GIT_CLONE_TIMEOUT_MS, stdio: "pipe" });
@@ -1805,11 +1962,11 @@ var BundlePluginInstaller = class {
   }
   /** Read the installed_plugins.json registry. */
   readRegistry() {
-    if (!(0, import_node_fs5.existsSync)(this.registryPath)) {
+    if (!(0, import_node_fs6.existsSync)(this.registryPath)) {
       return {};
     }
     try {
-      const raw = (0, import_node_fs5.readFileSync)(this.registryPath, "utf-8");
+      const raw = (0, import_node_fs6.readFileSync)(this.registryPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data === "object" && data !== null) {
         return data;
@@ -1822,10 +1979,10 @@ var BundlePluginInstaller = class {
   /** Write the installed_plugins.json registry. */
   writeRegistry(registry) {
     const dir = (0, import_node_path6.dirname)(this.registryPath);
-    if (!(0, import_node_fs5.existsSync)(dir)) {
-      (0, import_node_fs5.mkdirSync)(dir, { recursive: true });
+    if (!(0, import_node_fs6.existsSync)(dir)) {
+      (0, import_node_fs6.mkdirSync)(dir, { recursive: true });
     }
-    (0, import_node_fs5.writeFileSync)(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
+    (0, import_node_fs6.writeFileSync)(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
   }
   /** Default exec implementation using child_process. */
   defaultExec(command, options) {
@@ -1835,8 +1992,66 @@ var BundlePluginInstaller = class {
 
 // src/plugins/marketplace-client.ts
 var import_node_child_process2 = require("child_process");
-var import_node_fs6 = require("fs");
+var import_node_fs8 = require("fs");
+var import_node_path8 = require("path");
+
+// src/plugins/marketplace-registry.ts
+var import_node_fs7 = require("fs");
 var import_node_path7 = require("path");
+function readRegistry(registryPath) {
+  if (!(0, import_node_fs7.existsSync)(registryPath)) {
+    return {};
+  }
+  try {
+    const raw = (0, import_node_fs7.readFileSync)(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 = (0, import_node_path7.dirname)(registryPath);
+  if (!(0, import_node_fs7.existsSync)(dir)) {
+    (0, import_node_fs7.mkdirSync)(dir, { recursive: true });
+  }
+  (0, import_node_fs7.writeFileSync)(registryPath, JSON.stringify(registry, null, 2), "utf-8");
+}
+function removeInstalledPluginsForMarketplace(pluginsDir, marketplaceName) {
+  const installedPath = (0, import_node_path7.join)(pluginsDir, "installed_plugins.json");
+  if (!(0, import_node_fs7.existsSync)(installedPath)) return;
+  let registry;
+  try {
+    const raw = (0, import_node_fs7.readFileSync)(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 && (0, import_node_fs7.existsSync)(record.installPath)) {
+        (0, import_node_fs7.rmSync)(record.installPath, { recursive: true, force: true });
+      }
+      delete registry[pluginId];
+      changed = true;
+    }
+  }
+  if (changed) {
+    const dir = (0, import_node_path7.dirname)(installedPath);
+    if (!(0, import_node_fs7.existsSync)(dir)) {
+      (0, import_node_fs7.mkdirSync)(dir, { recursive: true });
+    }
+    (0, import_node_fs7.writeFileSync)(installedPath, JSON.stringify(registry, null, 2), "utf-8");
+  }
+}
+
+// src/plugins/marketplace-client.ts
 var GIT_TIMEOUT_MS = 6e4;
 var MarketplaceClient = class {
   pluginsDir;
@@ -1846,28 +2061,27 @@ var MarketplaceClient = class {
   constructor(options) {
     this.pluginsDir = options.pluginsDir;
     this.exec = options.exec ?? this.defaultExec;
-    this.marketplacesDir = (0, import_node_path7.join)(this.pluginsDir, "marketplaces");
-    this.registryPath = (0, import_node_path7.join)(this.pluginsDir, "known_marketplaces.json");
+    this.marketplacesDir = (0, import_node_path8.join)(this.pluginsDir, "marketplaces");
+    this.registryPath = (0, import_node_path8.join)(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 = (0, import_node_path7.join)(this.marketplacesDir, tempName);
-    (0, import_node_fs6.mkdirSync)(this.marketplacesDir, { recursive: true });
+    const tempDir = (0, import_node_path8.join)(this.marketplacesDir, tempName);
+    (0, import_node_fs8.mkdirSync)(this.marketplacesDir, { recursive: true });
     if (source.type === "local") {
-      if (!(0, import_node_fs6.existsSync)(source.path)) {
+      if (!(0, import_node_fs8.existsSync)(source.path)) {
         throw new Error(`Local marketplace path does not exist: ${source.path}`);
       }
-      (0, import_node_fs6.cpSync)(source.path, tempDir, { recursive: true });
+      (0, import_node_fs8.cpSync)(source.path, tempDir, { recursive: true });
     } else {
       const cloneUrl = this.resolveCloneUrl(source);
       const command = `git clone --depth 1 ${cloneUrl} ${tempDir}`;
@@ -1878,9 +2092,9 @@ var MarketplaceClient = class {
         throw new Error(`Failed to clone marketplace: ${message}`);
       }
     }
-    const manifestPath = (0, import_node_path7.join)(tempDir, ".claude-plugin", "marketplace.json");
-    if (!(0, import_node_fs6.existsSync)(manifestPath)) {
-      (0, import_node_fs6.rmSync)(tempDir, { recursive: true, force: true });
+    const manifestPath = (0, import_node_path8.join)(tempDir, ".claude-plugin", "marketplace.json");
+    if (!(0, import_node_fs8.existsSync)(manifestPath)) {
+      (0, import_node_fs8.rmSync)(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"
       );
@@ -1888,22 +2102,22 @@ var MarketplaceClient = class {
     const manifest = this.readManifestFromPath(manifestPath);
     const name = manifest.name;
     if (!name) {
-      (0, import_node_fs6.rmSync)(tempDir, { recursive: true, force: true });
+      (0, import_node_fs8.rmSync)(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]) {
-      (0, import_node_fs6.rmSync)(tempDir, { recursive: true, force: true });
+      (0, import_node_fs8.rmSync)(tempDir, { recursive: true, force: true });
       throw new Error(`Marketplace "${name}" already exists`);
     }
-    const finalDir = (0, import_node_path7.join)(this.marketplacesDir, name);
-    (0, import_node_fs6.renameSync)(tempDir, finalDir);
+    const finalDir = (0, import_node_path8.join)(this.marketplacesDir, name);
+    (0, import_node_fs8.renameSync)(tempDir, finalDir);
     registry[name] = {
       source,
       installLocation: finalDir,
       lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
     };
-    this.writeRegistry(registry);
+    writeRegistry(this.registryPath, registry);
     return name;
   }
   /**
@@ -1912,42 +2126,39 @@ 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 ((0, import_node_fs6.existsSync)(entry.installLocation)) {
-      (0, import_node_fs6.rmSync)(entry.installLocation, { recursive: true, force: true });
+    removeInstalledPluginsForMarketplace(this.pluginsDir, name);
+    if ((0, import_node_fs8.existsSync)(entry.installLocation)) {
+      (0, import_node_fs8.rmSync)(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 (!(0, import_node_fs6.existsSync)(entry.installLocation)) {
+    if (!(0, import_node_fs8.existsSync)(entry.installLocation)) {
       throw new Error(`Marketplace directory for "${name}" does not exist`);
     }
     if (entry.source.type === "local") {
       const localSource = entry.source;
-      if (!(0, import_node_fs6.existsSync)(localSource.path)) {
+      if (!(0, import_node_fs8.existsSync)(localSource.path)) {
         throw new Error(`Local marketplace path does not exist: ${localSource.path}`);
       }
-      (0, import_node_fs6.rmSync)(entry.installLocation, { recursive: true, force: true });
-      (0, import_node_fs6.cpSync)(localSource.path, entry.installLocation, { recursive: true });
+      (0, import_node_fs8.rmSync)(entry.installLocation, { recursive: true, force: true });
+      (0, import_node_fs8.cpSync)(localSource.path, entry.installLocation, { recursive: true });
     } else {
       const command = `git -C ${entry.installLocation} pull`;
       try {
@@ -1958,28 +2169,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 = (0, import_node_path7.join)(entry.installLocation, ".claude-plugin", "marketplace.json");
-    if (!(0, import_node_fs6.existsSync)(manifestPath)) {
+    const manifestPath = (0, import_node_path8.join)(entry.installLocation, ".claude-plugin", "marketplace.json");
+    if (!(0, import_node_fs8.existsSync)(manifestPath)) {
       throw new Error(
         `Marketplace "${marketplaceName}" does not contain .claude-plugin/marketplace.json`
       );
@@ -1988,7 +2197,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`);
@@ -2040,44 +2249,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 = (0, import_node_path7.join)(this.pluginsDir, "installed_plugins.json");
-    if (!(0, import_node_fs6.existsSync)(installedPath)) return;
-    let registry;
-    try {
-      const raw = (0, import_node_fs6.readFileSync)(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 && (0, import_node_fs6.existsSync)(record.installPath)) {
-          (0, import_node_fs6.rmSync)(record.installPath, { recursive: true, force: true });
-        }
-        delete registry[pluginId];
-        changed = true;
-      }
-    }
-    if (changed) {
-      const dir = (0, import_node_path7.dirname)(installedPath);
-      if (!(0, import_node_fs6.existsSync)(dir)) {
-        (0, import_node_fs6.mkdirSync)(dir, { recursive: true });
-      }
-      (0, import_node_fs6.writeFileSync)(installedPath, JSON.stringify(registry, null, 2), "utf-8");
-    }
-  }
   /** Read and parse a marketplace.json from a file path. */
   readManifestFromPath(path) {
-    const raw = (0, import_node_fs6.readFileSync)(path, "utf-8");
+    const raw = (0, import_node_fs8.readFileSync)(path, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data !== "object" || data === null) {
       throw new Error("Invalid marketplace manifest: not an object");
@@ -2088,30 +2262,6 @@ var MarketplaceClient = class {
     }
     return data;
   }
-  /** Read the known_marketplaces.json registry. */
-  readRegistry() {
-    if (!(0, import_node_fs6.existsSync)(this.registryPath)) {
-      return {};
-    }
-    try {
-      const raw = (0, import_node_fs6.readFileSync)(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 = (0, import_node_path7.dirname)(this.registryPath);
-    if (!(0, import_node_fs6.existsSync)(dir)) {
-      (0, import_node_fs6.mkdirSync)(dir, { recursive: true });
-    }
-    (0, import_node_fs6.writeFileSync)(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
-  }
   /** Default exec implementation using child_process. */
   defaultExec(command, options) {
     return (0, import_node_child_process2.execSync)(command, { timeout: options.timeout, stdio: "pipe" });
@@ -2119,9 +2269,9 @@ var MarketplaceClient = class {
 };
 
 // src/plugins/plugin-hooks-merger.ts
-var import_node_path8 = require("path");
+var import_node_path9 = require("path");
 function buildPluginEnv(plugin) {
-  const dataDir = (0, import_node_path8.join)((0, import_node_path8.dirname)((0, import_node_path8.dirname)(plugin.pluginDir)), "data", plugin.manifest.name);
+  const dataDir = (0, import_node_path9.join)((0, import_node_path9.dirname)((0, import_node_path9.dirname)(plugin.pluginDir)), "data", plugin.manifest.name);
   return {
     CLAUDE_PLUGIN_ROOT: plugin.pluginDir,
     CLAUDE_PLUGIN_PATH: plugin.pluginDir,
@@ -2182,41 +2332,111 @@ function mergeHooksIntoConfig(configHooks, pluginHooks) {
   return merged;
 }
 
-// src/interactive/interactive-session.ts
+// src/interactive/interactive-session-init.ts
 var import_node_os3 = require("os");
-var import_node_path9 = require("path");
-var TOOL_ARG_DISPLAY_MAX = 80;
-var TAIL_KEEP = 30;
-var MAX_COMPLETED_TOOLS = 50;
-var STREAMING_FLUSH_INTERVAL_MS = 16;
+var import_node_path10 = require("path");
+async function createInteractiveSession(options) {
+  const cwd = options.cwd;
+  const [config, context, projectInfo] = await Promise.all([
+    loadConfig(cwd),
+    loadContext(cwd),
+    detectProject(cwd)
+  ]);
+  const pluginsDir = (0, import_node_path10.join)((0, import_node_os3.homedir)(), ".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 import_agent_sessions4.FileSessionLogger(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;
@@ -2224,98 +2444,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 = (0, import_node_path9.join)((0, import_node_os3.homedir)(), ".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 import_agent_sessions4.FileSessionLogger(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) {
@@ -2323,14 +2491,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) {
@@ -2341,27 +2503,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;
@@ -2372,11 +2531,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);
   }
@@ -2389,11 +2546,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) {
@@ -2409,15 +2567,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();
@@ -2427,25 +2579,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((0, import_agent_core.messageToHistoryEntry)((0, import_agent_core.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((0, import_agent_core.messageToHistoryEntry)((0, import_agent_core.createAssistantMessage)(result.response)));
-        }
         this.history.push((0, import_agent_core.messageToHistoryEntry)((0, import_agent_core.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((0, import_agent_core.messageToHistoryEntry)((0, import_agent_core.createSystemMessage)(`Error: ${errMsg}`)));
@@ -2455,33 +2617,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);
@@ -2492,67 +2644,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: (0, import_node_crypto.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: (0, import_node_crypto.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: (0, import_node_crypto.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 = [];
@@ -2567,81 +2669,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
@@ -2796,8 +2823,8 @@ var BuiltinCommandSource = class {
 };
 
 // src/commands/skill-source.ts
-var import_node_fs7 = require("fs");
-var import_node_path10 = require("path");
+var import_node_fs9 = require("fs");
+var import_node_path11 = require("path");
 var import_node_os4 = require("os");
 var BOOLEAN_KEYS = /* @__PURE__ */ new Set(["disable-model-invocation", "user-invocable"]);
 var LIST_KEYS2 = /* @__PURE__ */ new Set(["allowed-tools"]);
@@ -2845,29 +2872,29 @@ function buildCommand(frontmatter, content, fallbackName) {
   return cmd;
 }
 function scanSkillsDir(skillsDir) {
-  if (!(0, import_node_fs7.existsSync)(skillsDir)) return [];
+  if (!(0, import_node_fs9.existsSync)(skillsDir)) return [];
   const commands = [];
-  const entries = (0, import_node_fs7.readdirSync)(skillsDir, { withFileTypes: true });
+  const entries = (0, import_node_fs9.readdirSync)(skillsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    const skillFile = (0, import_node_path10.join)(skillsDir, entry.name, "SKILL.md");
-    if (!(0, import_node_fs7.existsSync)(skillFile)) continue;
-    const content = (0, import_node_fs7.readFileSync)(skillFile, "utf-8");
+    const skillFile = (0, import_node_path11.join)(skillsDir, entry.name, "SKILL.md");
+    if (!(0, import_node_fs9.existsSync)(skillFile)) continue;
+    const content = (0, import_node_fs9.readFileSync)(skillFile, "utf-8");
     const frontmatter = parseFrontmatter2(content);
     commands.push(buildCommand(frontmatter, content, entry.name));
   }
   return commands;
 }
 function scanCommandsDir(commandsDir) {
-  if (!(0, import_node_fs7.existsSync)(commandsDir)) return [];
+  if (!(0, import_node_fs9.existsSync)(commandsDir)) return [];
   const commands = [];
-  const entries = (0, import_node_fs7.readdirSync)(commandsDir, { withFileTypes: true });
+  const entries = (0, import_node_fs9.readdirSync)(commandsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const filePath = (0, import_node_path10.join)(commandsDir, entry.name);
-    const content = (0, import_node_fs7.readFileSync)(filePath, "utf-8");
+    const filePath = (0, import_node_path11.join)(commandsDir, entry.name);
+    const content = (0, import_node_fs9.readFileSync)(filePath, "utf-8");
     const frontmatter = parseFrontmatter2(content);
-    const fallbackName = (0, import_node_path10.basename)(entry.name, ".md");
+    const fallbackName = (0, import_node_path11.basename)(entry.name, ".md");
     commands.push(buildCommand(frontmatter, content, fallbackName));
   }
   return commands;
@@ -2884,10 +2911,10 @@ var SkillCommandSource = class {
   getCommands() {
     if (this.cachedCommands) return this.cachedCommands;
     const sources = [
-      scanSkillsDir((0, import_node_path10.join)(this.cwd, ".claude", "skills")),
-      scanCommandsDir((0, import_node_path10.join)(this.cwd, ".claude", "commands")),
-      scanSkillsDir((0, import_node_path10.join)(this.home, ".robota", "skills")),
-      scanSkillsDir((0, import_node_path10.join)(this.cwd, ".agents", "skills"))
+      scanSkillsDir((0, import_node_path11.join)(this.cwd, ".claude", "skills")),
+      scanCommandsDir((0, import_node_path11.join)(this.cwd, ".claude", "commands")),
+      scanSkillsDir((0, import_node_path11.join)(this.home, ".robota", "skills")),
+      scanSkillsDir((0, import_node_path11.join)(this.cwd, ".agents", "skills"))
     ];
     const seen = /* @__PURE__ */ new Set();
     const merged = [];