@robota-sdk/agent-sdk 3.0.0-beta.3 → 3.0.0-beta.30

package/dist/node/index.js

@@ -1,13 +1,328 @@
 // src/types.ts
 import { TRUST_TO_MODE } from "@robota-sdk/agent-core";
 
-// src/session.ts
+// 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 } 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/assembly/create-provider.ts
+import { AnthropicProvider } from "@robota-sdk/agent-provider-anthropic";
+function createProvider(config) {
+  const apiKey = config.provider.apiKey ?? process.env["ANTHROPIC_API_KEY"];
+  if (!apiKey) {
+    throw new Error(
+      "ANTHROPIC_API_KEY is not set. Set the environment variable or configure provider.apiKey in ~/.robota/settings.json"
+    );
+  }
+  return new AnthropicProvider({ apiKey });
+}
+
+// src/assembly/create-session.ts
+function createSession(options) {
+  const provider = options.provider ?? createProvider(options.config);
+  const defaultTools = createDefaultTools();
+  const tools = [...defaultTools, ...options.additionalTools ?? []];
+  const buildPrompt = options.systemPromptBuilder ?? buildSystemPrompt;
+  const systemMessage = buildPrompt({
+    agentsMd: options.context.agentsMd,
+    claudeMd: options.context.claudeMd,
+    toolDescriptions: options.toolDescriptions ?? DEFAULT_TOOL_DESCRIPTIONS,
+    trustLevel: options.config.defaultTrustLevel,
+    projectInfo: options.projectInfo ?? { type: "unknown", language: "unknown" },
+    cwd: process.cwd(),
+    language: options.config.language
+  });
+  const defaultAllow = [
+    "Read(.agents/**)",
+    "Read(.claude/**)",
+    "Read(.robota/**)",
+    "Glob(.agents/**)",
+    "Glob(.claude/**)",
+    "Glob(.robota/**)"
+  ];
+  const mergedPermissions = {
+    allow: [...defaultAllow, ...options.config.permissions.allow ?? []],
+    deny: options.config.permissions.deny ?? []
+  };
+  const hookTypeExecutors = [];
+  if (options.providerFactory) {
+    hookTypeExecutors.push(
+      new PromptExecutor({
+        providerFactory: options.providerFactory,
+        defaultModel: options.config.provider.model
+      })
+    );
+  }
+  if (options.sessionFactory) {
+    hookTypeExecutors.push(
+      new AgentExecutor({
+        sessionFactory: options.sessionFactory
+      })
+    );
+  }
+  if (options.additionalHookExecutors) {
+    hookTypeExecutors.push(...options.additionalHookExecutors);
+  }
+  return new Session({
+    tools,
+    provider,
+    systemMessage,
+    terminal: options.terminal,
+    permissions: mergedPermissions,
+    hooks: options.config.hooks,
+    permissionMode: options.permissionMode,
+    defaultTrustLevel: options.config.defaultTrustLevel,
+    model: options.config.provider.model,
+    maxTurns: options.maxTurns,
+    sessionStore: options.sessionStore,
+    permissionHandler: options.permissionHandler,
+    onTextDelta: options.onTextDelta,
+    onToolExecution: options.onToolExecution,
+    promptForApproval: options.promptForApproval,
+    onCompact: options.onCompact,
+    compactInstructions: options.compactInstructions ?? options.context.compactInstructions,
+    sessionLogger: options.sessionLogger,
+    hookTypeExecutors: hookTypeExecutors.length > 0 ? hookTypeExecutors : void 0
+  });
+}
+
 // src/index.ts
+import { Session as Session2 } from "@robota-sdk/agent-sessions";
 import { FileSessionLogger, SilentSessionLogger } from "@robota-sdk/agent-sessions";
-
-// src/session-store.ts
 import { SessionStore } from "@robota-sdk/agent-sessions";
 
 // src/config/config-loader.ts
@@ -28,10 +343,34 @@ var PermissionsSchema = z.object({
   deny: z.array(z.string()).optional()
 });
 var EnvSchema = z.record(z.string()).optional();
-var HookDefinitionSchema = z.object({
+var CommandHookDefinitionSchema = z.object({
   type: z.literal("command"),
-  command: z.string()
+  command: z.string(),
+  timeout: z.number().optional()
+});
+var HttpHookDefinitionSchema = z.object({
+  type: z.literal("http"),
+  url: z.string(),
+  headers: z.record(z.string()).optional(),
+  timeout: z.number().optional()
 });
+var PromptHookDefinitionSchema = z.object({
+  type: z.literal("prompt"),
+  prompt: z.string(),
+  model: z.string().optional()
+});
+var AgentHookDefinitionSchema = z.object({
+  type: z.literal("agent"),
+  agent: z.string(),
+  maxTurns: z.number().optional(),
+  timeout: z.number().optional()
+});
+var HookDefinitionSchema = z.discriminatedUnion("type", [
+  CommandHookDefinitionSchema,
+  HttpHookDefinitionSchema,
+  PromptHookDefinitionSchema,
+  AgentHookDefinitionSchema
+]);
 var HookGroupSchema = z.object({
   matcher: z.string(),
   hooks: z.array(HookDefinitionSchema)
@@ -40,15 +379,36 @@ var HooksSchema = z.object({
   PreToolUse: z.array(HookGroupSchema).optional(),
   PostToolUse: z.array(HookGroupSchema).optional(),
   SessionStart: z.array(HookGroupSchema).optional(),
-  Stop: z.array(HookGroupSchema).optional()
+  Stop: z.array(HookGroupSchema).optional(),
+  PreCompact: z.array(HookGroupSchema).optional(),
+  PostCompact: z.array(HookGroupSchema).optional(),
+  UserPromptSubmit: z.array(HookGroupSchema).optional(),
+  Notification: z.array(HookGroupSchema).optional()
 }).optional();
+var EnabledPluginsSchema = z.record(z.boolean()).optional();
+var MarketplaceSourceSchema = z.object({
+  source: z.object({
+    type: z.enum(["github", "git", "local", "url"]),
+    repo: z.string().optional(),
+    url: z.string().optional(),
+    path: z.string().optional(),
+    ref: z.string().optional()
+  })
+});
+var ExtraKnownMarketplacesSchema = z.record(MarketplaceSourceSchema).optional();
 var SettingsSchema = z.object({
   /** Trust level used when no --permission-mode flag is given */
   defaultTrustLevel: z.enum(["safe", "moderate", "full"]).optional(),
+  /** Response language (e.g., "ko", "en", "ja"). Injected into system prompt. */
+  language: z.string().optional(),
   provider: ProviderSchema.optional(),
   permissions: PermissionsSchema.optional(),
   env: EnvSchema,
-  hooks: HooksSchema
+  hooks: HooksSchema,
+  /** Plugin enablement map: plugin name -> enabled/disabled */
+  enabledPlugins: EnabledPluginsSchema,
+  /** Extra marketplace URLs for BundlePlugin discovery */
+  extraKnownMarketplaces: ExtraKnownMarketplacesSchema
 });
 
 // src/config/config-loader.ts
@@ -72,8 +432,15 @@ function readJsonFile(filePath) {
   if (!existsSync(filePath)) {
     return void 0;
   }
-  const raw = readFileSync(filePath, "utf-8");
-  return JSON.parse(raw);
+  const raw = readFileSync(filePath, "utf-8").trim();
+  if (raw.length === 0) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
 }
 function resolveEnvRef(value) {
   const ENV_PREFIX = "$ENV:";
@@ -108,13 +475,16 @@ function mergeSettings(layers) {
       env: {
         ...merged.env ?? {},
         ...layer.env ?? {}
-      }
+      },
+      enabledPlugins: merged.enabledPlugins !== void 0 || layer.enabledPlugins !== void 0 ? { ...merged.enabledPlugins ?? {}, ...layer.enabledPlugins ?? {} } : void 0,
+      extraKnownMarketplaces: layer.extraKnownMarketplaces ?? merged.extraKnownMarketplaces
     };
   }, {});
 }
 function toResolvedConfig(merged) {
   return {
     defaultTrustLevel: merged.defaultTrustLevel ?? DEFAULTS.defaultTrustLevel,
+    language: merged.language,
     provider: {
       name: merged.provider?.name ?? DEFAULTS.provider.name,
       model: merged.provider?.model ?? DEFAULTS.provider.model,
@@ -125,25 +495,39 @@ function toResolvedConfig(merged) {
       deny: merged.permissions?.deny ?? DEFAULTS.permissions.deny
     },
     env: merged.env ?? DEFAULTS.env,
-    hooks: merged.hooks ?? void 0
+    hooks: merged.hooks ?? void 0,
+    enabledPlugins: merged.enabledPlugins ?? void 0,
+    extraKnownMarketplaces: merged.extraKnownMarketplaces ?? void 0
   };
 }
+function getSettingsPaths(cwd) {
+  const home = getHomeDir();
+  return [
+    join(home, ".robota", "settings.json"),
+    // 1. user (lowest)
+    join(cwd, ".robota", "settings.json"),
+    // 2. project
+    join(cwd, ".robota", "settings.local.json"),
+    // 3. project-local
+    join(cwd, ".claude", "settings.json"),
+    // 4. project, Claude Code compat
+    join(cwd, ".claude", "settings.local.json")
+    // 5. project-local (highest)
+  ];
+}
 async function loadConfig(cwd) {
-  const userSettingsPath = join(getHomeDir(), ".robota", "settings.json");
-  const projectSettingsPath = join(cwd, ".robota", "settings.json");
-  const localSettingsPath = join(cwd, ".robota", "settings.local.json");
-  const rawLayers = [
-    readJsonFile(userSettingsPath),
-    readJsonFile(projectSettingsPath),
-    readJsonFile(localSettingsPath)
-  ].filter((v) => v !== void 0);
-  const parsedLayers = rawLayers.map((raw, index) => {
+  const allPaths = getSettingsPaths(cwd);
+  const rawEntries = [];
+  for (const filePath of allPaths) {
+    const raw = readJsonFile(filePath);
+    if (raw !== void 0) {
+      rawEntries.push({ raw, path: filePath });
+    }
+  }
+  const parsedLayers = rawEntries.map(({ raw, path }) => {
     const result = SettingsSchema.safeParse(raw);
     if (!result.success) {
-      const paths = [userSettingsPath, projectSettingsPath, localSettingsPath].filter(
-        (_, i) => rawLayers[i] !== void 0
-      );
-      throw new Error(`Invalid settings in ${paths[index] ?? "unknown"}: ${result.error.message}`);
+      throw new Error(`Invalid settings in ${path}: ${result.error.message}`);
     }
     return resolveEnvRefs(result.data);
   });
@@ -273,77 +657,6 @@ async function detectProject(cwd) {
   };
 }
 
-// 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 buildSystemPrompt(params) {
-  const { agentsMd, claudeMd, toolDescriptions, trustLevel, projectInfo } = params;
-  const sections = [];
-  sections.push(
-    [
-      "## 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."
-    ].join("\n")
-  );
-  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);
-  }
-  return sections.join("\n\n");
-}
-
-// src/query.ts
-import { Session as Session2 } from "@robota-sdk/agent-sessions";
-
 // src/permissions/permission-prompt.ts
 import chalk from "chalk";
 var PERMISSION_OPTIONS = ["Allow", "Deny"];
@@ -387,7 +700,7 @@ async function query(prompt, options) {
     }, update: () => {
     } })
   };
-  const session = new Session2({
+  const session = createSession({
     config,
     context,
     terminal: noopTerminal,
@@ -399,16 +712,13 @@ async function query(prompt, options) {
     onTextDelta: options?.onTextDelta,
     onCompact: options?.onCompact,
     compactInstructions: context.compactInstructions,
-    systemPromptBuilder: buildSystemPrompt,
     promptForApproval
   });
   return session.run(prompt);
 }
 
-// src/permissions/permission-gate.ts
+// src/index.ts
 import { evaluatePermission } from "@robota-sdk/agent-core";
-
-// src/hooks/hook-runner.ts
 import { runHooks } from "@robota-sdk/agent-core";
 
 // src/paths.ts
@@ -431,28 +741,790 @@ function userPaths() {
   };
 }
 
-// src/tools/bash-tool.ts
-import { bashTool } from "@robota-sdk/agent-tools";
-
-// src/tools/read-tool.ts
-import { readTool } from "@robota-sdk/agent-tools";
-
-// src/tools/write-tool.ts
-import { writeTool } from "@robota-sdk/agent-tools";
+// src/plugins/plugin-settings-store.ts
+import { existsSync as existsSync4, readFileSync as readFileSync4, writeFileSync, mkdirSync } from "fs";
+import { dirname as dirname2 } from "path";
+var PluginSettingsStore = class {
+  settingsPath;
+  constructor(settingsPath) {
+    this.settingsPath = settingsPath;
+  }
+  /** Read the full settings file from disk. */
+  readAll() {
+    if (!existsSync4(this.settingsPath)) {
+      return {};
+    }
+    try {
+      const raw = readFileSync4(this.settingsPath, "utf-8");
+      const data = JSON.parse(raw);
+      if (typeof data === "object" && data !== null) {
+        return data;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  /** Write the full settings file to disk. */
+  writeAll(settings) {
+    const dir = dirname2(this.settingsPath);
+    if (!existsSync4(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(this.settingsPath, JSON.stringify(settings, null, 2), "utf-8");
+  }
+  // --- enabledPlugins ---
+  /** Get the enabledPlugins map. */
+  getEnabledPlugins() {
+    const settings = this.readAll();
+    const ep = settings.enabledPlugins;
+    if (typeof ep === "object" && ep !== null) {
+      return ep;
+    }
+    return {};
+  }
+  /** Set a single plugin's enabled state. */
+  setPluginEnabled(pluginId, enabled) {
+    const settings = this.readAll();
+    const ep = this.getEnabledPluginsFrom(settings);
+    ep[pluginId] = enabled;
+    settings.enabledPlugins = ep;
+    this.writeAll(settings);
+  }
+  /** Remove a plugin from enabledPlugins. */
+  removePluginEntry(pluginId) {
+    const settings = this.readAll();
+    const ep = this.getEnabledPluginsFrom(settings);
+    delete ep[pluginId];
+    settings.enabledPlugins = ep;
+    this.writeAll(settings);
+  }
+  // --- extraKnownMarketplaces ---
+  /** Get all persisted marketplace sources. */
+  getMarketplaceSources() {
+    const settings = this.readAll();
+    const extra = settings.extraKnownMarketplaces;
+    if (typeof extra === "object" && extra !== null) {
+      return extra;
+    }
+    return {};
+  }
+  /** Add or update a marketplace source. */
+  setMarketplaceSource(name, source) {
+    const settings = this.readAll();
+    const extra = this.getMarketplaceSourcesFrom(settings);
+    extra[name] = { source };
+    settings.extraKnownMarketplaces = extra;
+    this.writeAll(settings);
+  }
+  /** Remove a marketplace source. */
+  removeMarketplaceSource(name) {
+    const settings = this.readAll();
+    const extra = this.getMarketplaceSourcesFrom(settings);
+    delete extra[name];
+    settings.extraKnownMarketplaces = extra;
+    this.writeAll(settings);
+  }
+  // --- helpers ---
+  getEnabledPluginsFrom(settings) {
+    const ep = settings.enabledPlugins;
+    if (typeof ep === "object" && ep !== null) {
+      return ep;
+    }
+    return {};
+  }
+  getMarketplaceSourcesFrom(settings) {
+    const extra = settings.extraKnownMarketplaces;
+    if (typeof extra === "object" && extra !== null) {
+      return extra;
+    }
+    return {};
+  }
+};
 
-// src/tools/edit-tool.ts
-import { editTool } from "@robota-sdk/agent-tools";
+// src/plugins/bundle-plugin-loader.ts
+import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync5 } from "fs";
+import { join as join5 } from "path";
+function parseSkillFrontmatter(raw) {
+  const trimmed = raw.trimStart();
+  if (!trimmed.startsWith("---")) {
+    return { metadata: {}, content: raw };
+  }
+  const endIndex = trimmed.indexOf("---", 3);
+  if (endIndex === -1) {
+    return { metadata: {}, content: raw };
+  }
+  const frontmatterBlock = trimmed.slice(3, endIndex).trim();
+  const content = trimmed.slice(endIndex + 3).trimStart();
+  const metadata = {};
+  for (const line of frontmatterBlock.split("\n")) {
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    let value = line.slice(colonIndex + 1).trim();
+    if (typeof value === "string" && value.startsWith("[") && value.endsWith("]")) {
+      const inner = value.slice(1, -1);
+      value = inner.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    }
+    if (key) {
+      metadata[key] = value;
+    }
+  }
+  return { metadata, content };
+}
+function validateManifest(data) {
+  if (typeof data !== "object" || data === null) return null;
+  const obj = data;
+  if (typeof obj.name !== "string") return null;
+  if (typeof obj.version !== "string") return null;
+  if (typeof obj.description !== "string") return null;
+  const features = typeof obj.features === "object" && obj.features !== null ? obj.features : {};
+  return {
+    name: obj.name,
+    version: obj.version,
+    description: obj.description,
+    features: {
+      commands: features.commands === true ? true : void 0,
+      agents: features.agents === true ? true : void 0,
+      skills: features.skills === true ? true : void 0,
+      hooks: features.hooks === true ? true : void 0,
+      mcp: features.mcp === true ? true : void 0
+    }
+  };
+}
+function getSortedSubdirs(dirPath) {
+  if (!existsSync5(dirPath)) return [];
+  try {
+    const entries = readdirSync(dirPath, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  } catch {
+    return [];
+  }
+}
+var BundlePluginLoader = class {
+  pluginsDir;
+  enabledPlugins;
+  constructor(pluginsDir, enabledPlugins) {
+    this.pluginsDir = pluginsDir;
+    this.enabledPlugins = enabledPlugins ?? {};
+  }
+  /** Load all discovered and enabled bundle plugins (sync). */
+  loadPluginsSync() {
+    return this.discoverAndLoad();
+  }
+  /** Load all discovered and enabled bundle plugins (async wrapper). */
+  async loadAll() {
+    return this.discoverAndLoad();
+  }
+  /**
+   * Discover and load plugins from the cache directory.
+   *
+   * Directory structure: `<pluginsDir>/cache/<marketplace>/<plugin>/<version>/`
+   * For each marketplace/plugin pair, the latest version (lexicographically last) is loaded.
+   */
+  discoverAndLoad() {
+    const cacheDir = join5(this.pluginsDir, "cache");
+    if (!existsSync5(cacheDir)) {
+      return [];
+    }
+    const results = [];
+    const marketplaces = getSortedSubdirs(cacheDir);
+    for (const marketplace of marketplaces) {
+      const marketplaceDir = join5(cacheDir, marketplace);
+      const plugins = getSortedSubdirs(marketplaceDir);
+      for (const pluginName of plugins) {
+        const pluginDir = join5(marketplaceDir, pluginName);
+        const versions = getSortedSubdirs(pluginDir);
+        if (versions.length === 0) continue;
+        const latestVersion = versions[versions.length - 1];
+        const versionDir = join5(pluginDir, latestVersion);
+        const manifestPath = join5(versionDir, ".claude-plugin", "plugin.json");
+        if (!existsSync5(manifestPath)) continue;
+        const manifest = this.readManifest(manifestPath);
+        if (!manifest) continue;
+        const pluginId = `${manifest.name}@${marketplace}`;
+        if (this.isDisabled(pluginId, manifest.name)) continue;
+        const loaded = this.loadPlugin(versionDir, manifest);
+        results.push(loaded);
+      }
+    }
+    return results;
+  }
+  /** Read and validate a plugin.json manifest. Returns null on failure. */
+  readManifest(path) {
+    try {
+      const raw = readFileSync5(path, "utf-8");
+      const data = JSON.parse(raw);
+      return validateManifest(data);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Check if a plugin is explicitly disabled.
+   * Checks both `name@marketplace` and `name` keys.
+   * Plugins not listed in enabledPlugins are enabled by default.
+   */
+  isDisabled(pluginId, pluginName) {
+    if (pluginId in this.enabledPlugins) {
+      return this.enabledPlugins[pluginId] === false;
+    }
+    if (pluginName in this.enabledPlugins) {
+      return this.enabledPlugins[pluginName] === false;
+    }
+    return false;
+  }
+  /** Load a single plugin's skills, hooks, agents, and MCP config. */
+  loadPlugin(pluginDir, manifest) {
+    return {
+      manifest,
+      skills: this.loadSkills(pluginDir, manifest.name),
+      commands: this.loadCommands(pluginDir, manifest.name),
+      hooks: this.loadHooks(pluginDir),
+      mcpConfig: this.loadMcpConfig(pluginDir),
+      agents: this.loadAgents(pluginDir),
+      pluginDir
+    };
+  }
+  /** Load skills from the plugin's skills/ directory. */
+  loadSkills(pluginDir, pluginName) {
+    const skillsDir = join5(pluginDir, "skills");
+    if (!existsSync5(skillsDir)) return [];
+    const entries = readdirSync(skillsDir, { withFileTypes: true });
+    const skills = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillFile = join5(skillsDir, entry.name, "SKILL.md");
+      if (!existsSync5(skillFile)) continue;
+      const raw = readFileSync5(skillFile, "utf-8");
+      const { metadata, content } = parseSkillFrontmatter(raw);
+      const description = typeof metadata.description === "string" ? metadata.description : "";
+      const skill = {
+        name: entry.name,
+        description,
+        skillContent: content,
+        ...metadata
+      };
+      skills.push(skill);
+    }
+    return skills;
+  }
+  /** Load commands from the plugin's commands/ directory (flat .md files). */
+  loadCommands(pluginDir, pluginName) {
+    const commandsDir = join5(pluginDir, "commands");
+    if (!existsSync5(commandsDir)) return [];
+    const entries = readdirSync(commandsDir, { withFileTypes: true });
+    const commands = [];
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+      const raw = readFileSync5(join5(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 : "";
+      commands.push({
+        ...metadata,
+        name: `${pluginName}:${name}`,
+        description,
+        skillContent: content
+      });
+    }
+    return commands;
+  }
+  /** Load hooks from hooks/hooks.json if present. */
+  loadHooks(pluginDir) {
+    const hooksPath = join5(pluginDir, "hooks", "hooks.json");
+    if (!existsSync5(hooksPath)) return {};
+    try {
+      const raw = readFileSync5(hooksPath, "utf-8");
+      const data = JSON.parse(raw);
+      if (typeof data === "object" && data !== null) {
+        return data;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  /** Load MCP server configuration if present. Checks `.mcp.json` at plugin root first. */
+  loadMcpConfig(pluginDir) {
+    const primaryPath = join5(pluginDir, ".mcp.json");
+    const fallbackPath = join5(pluginDir, ".claude-plugin", "mcp.json");
+    const mcpPath = existsSync5(primaryPath) ? primaryPath : fallbackPath;
+    if (!existsSync5(mcpPath)) return void 0;
+    try {
+      const raw = readFileSync5(mcpPath, "utf-8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  /** Load agent definitions from agents/ directory if present. */
+  loadAgents(pluginDir) {
+    const agentsDir = join5(pluginDir, "agents");
+    if (!existsSync5(agentsDir)) return [];
+    try {
+      const entries = readdirSync(agentsDir, { withFileTypes: true });
+      return entries.filter((e) => e.isDirectory() || e.name.endsWith(".md")).map((e) => e.name.replace(/\.md$/, ""));
+    } catch {
+      return [];
+    }
+  }
+};
 
-// src/tools/glob-tool.ts
-import { globTool } from "@robota-sdk/agent-tools";
+// src/plugins/bundle-plugin-installer.ts
+import { execSync } from "child_process";
+import { cpSync, existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync6, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join6, dirname as dirname3 } from "path";
+var GIT_CLONE_TIMEOUT_MS = 6e4;
+var BundlePluginInstaller = class {
+  pluginsDir;
+  cacheDir;
+  registryPath;
+  settingsStore;
+  marketplaceClient;
+  exec;
+  constructor(options) {
+    this.pluginsDir = options.pluginsDir;
+    this.cacheDir = join6(this.pluginsDir, "cache");
+    this.registryPath = join6(this.pluginsDir, "installed_plugins.json");
+    this.settingsStore = options.settingsStore;
+    this.marketplaceClient = options.marketplaceClient;
+    this.exec = options.exec ?? this.defaultExec;
+  }
+  /**
+   * Install a plugin from a marketplace.
+   *
+   * 1. Read marketplace manifest to find the plugin entry.
+   * 2. Resolve source (relative path, github, or url).
+   * 3. Copy/clone to `cache/<marketplace>/<plugin>/<version>/`.
+   * 4. Record in `installed_plugins.json`.
+   */
+  async install(pluginName, marketplaceName) {
+    const manifest = this.marketplaceClient.fetchManifest(marketplaceName);
+    const entry = manifest.plugins.find((p) => p.name === pluginName);
+    if (!entry) {
+      throw new Error(`Plugin "${pluginName}" not found in marketplace "${marketplaceName}"`);
+    }
+    const version = this.resolveVersion(entry, marketplaceName);
+    const targetDir = join6(this.cacheDir, marketplaceName, pluginName, version);
+    if (existsSync6(targetDir)) {
+      throw new Error(
+        `Plugin "${pluginName}" version "${version}" is already installed from "${marketplaceName}"`
+      );
+    }
+    this.resolveAndInstall(entry.source, marketplaceName, pluginName, targetDir);
+    const pluginId = `${pluginName}@${marketplaceName}`;
+    const registry = this.readRegistry();
+    registry[pluginId] = {
+      pluginName,
+      marketplace: marketplaceName,
+      version,
+      installPath: targetDir,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.writeRegistry(registry);
+  }
+  /**
+   * Uninstall a plugin.
+   * Removes from cache and from installed_plugins.json.
+   */
+  async uninstall(pluginId) {
+    const registry = this.readRegistry();
+    const record = registry[pluginId];
+    if (!record) {
+      throw new Error(`Plugin "${pluginId}" is not installed`);
+    }
+    if (existsSync6(record.installPath)) {
+      rmSync(record.installPath, { recursive: true, force: true });
+    }
+    delete registry[pluginId];
+    this.writeRegistry(registry);
+    this.settingsStore.removePluginEntry(pluginId);
+  }
+  /** Enable a plugin by setting its enabledPlugins entry to true. */
+  async enable(pluginId) {
+    this.settingsStore.setPluginEnabled(pluginId, true);
+  }
+  /** Disable a plugin by setting its enabledPlugins entry to false. */
+  async disable(pluginId) {
+    this.settingsStore.setPluginEnabled(pluginId, false);
+  }
+  /** Get all installed plugins. */
+  getInstalledPlugins() {
+    return this.readRegistry();
+  }
+  /** Get plugins installed from a specific marketplace. */
+  getPluginsByMarketplace(marketplaceName) {
+    const registry = this.readRegistry();
+    return Object.values(registry).filter((r) => r.marketplace === marketplaceName);
+  }
+  // --- Private helpers ---
+  /** Resolve the version for a plugin entry. */
+  resolveVersion(entry, marketplaceName) {
+    const entryWithVersion = entry;
+    if (typeof entryWithVersion.version === "string" && entryWithVersion.version) {
+      return entryWithVersion.version;
+    }
+    return this.marketplaceClient.getMarketplaceSha(marketplaceName);
+  }
+  /** Resolve the source and install the plugin. */
+  resolveAndInstall(source, marketplaceName, pluginName, targetDir) {
+    mkdirSync2(targetDir, { recursive: true });
+    if (typeof source === "string") {
+      const marketplaceDir = this.marketplaceClient.getMarketplaceDir(marketplaceName);
+      const sourcePath = join6(marketplaceDir, source);
+      if (!existsSync6(sourcePath)) {
+        rmSync(targetDir, { recursive: true, force: true });
+        throw new Error(
+          `Plugin source path "${source}" not found in marketplace "${marketplaceName}"`
+        );
+      }
+      cpSync(sourcePath, targetDir, { recursive: true });
+    } else if (source.type === "github") {
+      const repoUrl = `https://github.com/${source.repo}.git`;
+      this.cloneToDir(repoUrl, targetDir, pluginName);
+    } else if (source.type === "url") {
+      rmSync(targetDir, { recursive: true, force: true });
+      throw new Error("URL source installation is not yet supported");
+    }
+  }
+  /** Clone a git repository to the target directory. */
+  cloneToDir(repoUrl, targetDir, pluginName) {
+    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" });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to clone plugin "${pluginName}": ${message}`);
+    }
+  }
+  /** Read the installed_plugins.json registry. */
+  readRegistry() {
+    if (!existsSync6(this.registryPath)) {
+      return {};
+    }
+    try {
+      const raw = readFileSync6(this.registryPath, "utf-8");
+      const data = JSON.parse(raw);
+      if (typeof data === "object" && data !== null) {
+        return data;
+      }
+      return {};
+    } catch {
+      return {};
+    }
+  }
+  /** Write the installed_plugins.json registry. */
+  writeRegistry(registry) {
+    const dir = dirname3(this.registryPath);
+    if (!existsSync6(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    writeFileSync2(this.registryPath, JSON.stringify(registry, null, 2), "utf-8");
+  }
+  /** Default exec implementation using child_process. */
+  defaultExec(command, options) {
+    return execSync(command, { timeout: options.timeout, stdio: "pipe" });
+  }
+};
 
-// src/tools/grep-tool.ts
-import { grepTool } from "@robota-sdk/agent-tools";
+// src/plugins/marketplace-client.ts
+import { execSync as execSync2 } from "child_process";
+import {
+  cpSync as cpSync2,
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync3,
+  readFileSync as readFileSync7,
+  renameSync,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { join as join7, dirname as dirname4 } from "path";
+var GIT_TIMEOUT_MS = 6e4;
+var MarketplaceClient = class {
+  pluginsDir;
+  exec;
+  marketplacesDir;
+  registryPath;
+  constructor(options) {
+    this.pluginsDir = options.pluginsDir;
+    this.exec = options.exec ?? this.defaultExec;
+    this.marketplacesDir = join7(this.pluginsDir, "marketplaces");
+    this.registryPath = join7(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`.
+   *
+   * Returns the registered marketplace name from the manifest.
+   */
+  addMarketplace(source) {
+    const tempName = "temp-" + Date.now().toString(36);
+    const tempDir = join7(this.marketplacesDir, tempName);
+    mkdirSync3(this.marketplacesDir, { recursive: true });
+    if (source.type === "local") {
+      if (!existsSync7(source.path)) {
+        throw new Error(`Local marketplace path does not exist: ${source.path}`);
+      }
+      cpSync2(source.path, tempDir, { recursive: true });
+    } else {
+      const cloneUrl = this.resolveCloneUrl(source);
+      const command = `git clone --depth 1 ${cloneUrl} ${tempDir}`;
+      try {
+        this.exec(command, { timeout: GIT_TIMEOUT_MS, stdio: "pipe" });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to clone marketplace: ${message}`);
+      }
+    }
+    const manifestPath = join7(tempDir, ".claude-plugin", "marketplace.json");
+    if (!existsSync7(manifestPath)) {
+      rmSync2(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"
+      );
+    }
+    const manifest = this.readManifestFromPath(manifestPath);
+    const name = manifest.name;
+    if (!name) {
+      rmSync2(tempDir, { recursive: true, force: true });
+      throw new Error('Marketplace manifest does not contain a "name" field');
+    }
+    const registry = this.readRegistry();
+    if (registry[name]) {
+      rmSync2(tempDir, { recursive: true, force: true });
+      throw new Error(`Marketplace "${name}" already exists`);
+    }
+    const finalDir = join7(this.marketplacesDir, name);
+    renameSync(tempDir, finalDir);
+    registry[name] = {
+      source,
+      installLocation: finalDir,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.writeRegistry(registry);
+    return name;
+  }
+  /**
+   * Remove a marketplace.
+   * Uninstalls all plugins from that marketplace, then deletes the clone directory
+   * and removes from the registry.
+   */
+  removeMarketplace(name) {
+    const registry = this.readRegistry();
+    const entry = registry[name];
+    if (!entry) {
+      throw new Error(`Marketplace "${name}" not found`);
+    }
+    this.removeInstalledPluginsForMarketplace(name);
+    if (existsSync7(entry.installLocation)) {
+      rmSync2(entry.installLocation, { recursive: true, force: true });
+    }
+    delete registry[name];
+    this.writeRegistry(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 entry = registry[name];
+    if (!entry) {
+      throw new Error(`Marketplace "${name}" not found`);
+    }
+    if (!existsSync7(entry.installLocation)) {
+      throw new Error(`Marketplace directory for "${name}" does not exist`);
+    }
+    if (entry.source.type === "local") {
+      const localSource = entry.source;
+      if (!existsSync7(localSource.path)) {
+        throw new Error(`Local marketplace path does not exist: ${localSource.path}`);
+      }
+      rmSync2(entry.installLocation, { recursive: true, force: true });
+      cpSync2(localSource.path, entry.installLocation, { recursive: true });
+    } else {
+      const command = `git -C ${entry.installLocation} pull`;
+      try {
+        this.exec(command, { timeout: GIT_TIMEOUT_MS, stdio: "pipe" });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to update marketplace "${name}": ${message}`);
+      }
+    }
+    entry.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    this.writeRegistry(registry);
+  }
+  /** List all registered marketplaces. */
+  listMarketplaces() {
+    const registry = this.readRegistry();
+    return Object.entries(registry).map(([name, entry]) => ({
+      name,
+      source: entry.source,
+      lastUpdated: entry.lastUpdated
+    }));
+  }
+  /**
+   * Read the marketplace manifest from a registered marketplace's clone.
+   */
+  fetchManifest(marketplaceName) {
+    const registry = this.readRegistry();
+    const entry = registry[marketplaceName];
+    if (!entry) {
+      throw new Error(`Marketplace "${marketplaceName}" not found`);
+    }
+    const manifestPath = join7(entry.installLocation, ".claude-plugin", "marketplace.json");
+    if (!existsSync7(manifestPath)) {
+      throw new Error(
+        `Marketplace "${marketplaceName}" does not contain .claude-plugin/marketplace.json`
+      );
+    }
+    return this.readManifestFromPath(manifestPath);
+  }
+  /** Get the clone directory path for a registered marketplace. */
+  getMarketplaceDir(name) {
+    const registry = this.readRegistry();
+    const entry = registry[name];
+    if (!entry) {
+      throw new Error(`Marketplace "${name}" not found`);
+    }
+    return entry.installLocation;
+  }
+  /**
+   * Get the current git SHA (first 12 chars) for a marketplace clone.
+   * Used as a version identifier when plugins lack explicit versions.
+   */
+  getMarketplaceSha(name) {
+    const dir = this.getMarketplaceDir(name);
+    try {
+      const result = this.exec(`git -C ${dir} rev-parse HEAD`, {
+        timeout: GIT_TIMEOUT_MS,
+        stdio: "pipe"
+      });
+      return result.toString().trim().slice(0, 12);
+    } catch {
+      return "unknown";
+    }
+  }
+  /** List all available plugins across all marketplaces. */
+  listAvailablePlugins() {
+    const results = [];
+    const marketplaces = this.listMarketplaces();
+    for (const { name } of marketplaces) {
+      try {
+        const manifest = this.fetchManifest(name);
+        for (const plugin of manifest.plugins) {
+          results.push({ ...plugin, marketplace: name });
+        }
+      } catch {
+      }
+    }
+    return results;
+  }
+  // --- Private helpers ---
+  /** Resolve a marketplace source to a git clone URL. */
+  resolveCloneUrl(source) {
+    switch (source.type) {
+      case "github":
+        return `https://github.com/${source.repo}.git`;
+      case "git":
+        return source.url;
+      case "local":
+        throw new Error("Local source type does not use git cloning");
+      case "url":
+        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 = join7(this.pluginsDir, "installed_plugins.json");
+    if (!existsSync7(installedPath)) return;
+    let registry;
+    try {
+      const raw = readFileSync7(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 && existsSync7(record.installPath)) {
+          rmSync2(record.installPath, { recursive: true, force: true });
+        }
+        delete registry[pluginId];
+        changed = true;
+      }
+    }
+    if (changed) {
+      const dir = dirname4(installedPath);
+      if (!existsSync7(dir)) {
+        mkdirSync3(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 = readFileSync7(path, "utf-8");
+    const data = JSON.parse(raw);
+    if (typeof data !== "object" || data === null) {
+      throw new Error("Invalid marketplace manifest: not an object");
+    }
+    const obj = data;
+    if (typeof obj.name !== "string") {
+      throw new Error('Invalid marketplace manifest: missing "name" field');
+    }
+    return data;
+  }
+  /** Read the known_marketplaces.json registry. */
+  readRegistry() {
+    if (!existsSync7(this.registryPath)) {
+      return {};
+    }
+    try {
+      const raw = readFileSync7(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 (!existsSync7(dir)) {
+      mkdirSync3(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" });
+  }
+};
 
 // src/tools/agent-tool.ts
 import { z as z2 } from "zod";
 import { createZodFunctionTool } from "@robota-sdk/agent-tools";
-import { Session as Session3 } from "@robota-sdk/agent-sessions";
 function asZodSchema(schema) {
   return schema;
 }
@@ -473,26 +1545,26 @@ async function runAgent(args) {
     };
     return JSON.stringify(result);
   }
-  const subSession = new Session3({
+  const noopTerminal = {
+    write: () => {
+    },
+    writeLine: () => {
+    },
+    writeMarkdown: () => {
+    },
+    writeError: () => {
+    },
+    prompt: () => Promise.resolve(""),
+    select: () => Promise.resolve(0),
+    spinner: () => ({ stop: () => {
+    }, update: () => {
+    } })
+  };
+  const subSession = createSession({
     config: agentToolDeps.config,
     context: agentToolDeps.context,
     projectInfo: agentToolDeps.projectInfo,
-    // No terminal needed — sub-agents don't prompt for permissions
-    terminal: {
-      write: () => {
-      },
-      writeLine: () => {
-      },
-      writeMarkdown: () => {
-      },
-      writeError: () => {
-      },
-      prompt: () => Promise.resolve(""),
-      select: () => Promise.resolve(0),
-      spinner: () => ({ stop: () => {
-      }, update: () => {
-      } })
-    },
+    terminal: noopTerminal,
     // Sub-agents bypass permissions — they inherit parent's trust
     permissionMode: "bypassPermissions"
   });
@@ -521,28 +1593,46 @@ var agentTool = createZodFunctionTool(
     return runAgent(params);
   }
 );
+
+// src/index.ts
+import { bashTool as bashTool2 } from "@robota-sdk/agent-tools";
+import { readTool as readTool2 } from "@robota-sdk/agent-tools";
+import { writeTool as writeTool2 } from "@robota-sdk/agent-tools";
+import { editTool as editTool2 } from "@robota-sdk/agent-tools";
+import { globTool as globTool2 } from "@robota-sdk/agent-tools";
+import { grepTool as grepTool2 } from "@robota-sdk/agent-tools";
 export {
+  AgentExecutor,
+  BundlePluginInstaller,
+  BundlePluginLoader,
+  DEFAULT_TOOL_DESCRIPTIONS,
   FileSessionLogger,
-  Session,
+  MarketplaceClient,
+  PluginSettingsStore,
+  PromptExecutor,
+  Session2 as Session,
   SessionStore,
   SilentSessionLogger,
   TRUST_TO_MODE,
   agentTool,
-  bashTool,
+  bashTool2 as bashTool,
   buildSystemPrompt,
+  createDefaultTools,
+  createProvider,
+  createSession,
   detectProject,
-  editTool,
+  editTool2 as editTool,
   evaluatePermission,
-  globTool,
-  grepTool,
+  globTool2 as globTool,
+  grepTool2 as grepTool,
   loadConfig,
   loadContext,
   projectPaths,
   promptForApproval,
   query,
-  readTool,
+  readTool2 as readTool,
   runHooks,
   setAgentToolDeps,
   userPaths,
-  writeTool
+  writeTool2 as writeTool
 };