@robota-sdk/agent-sdk 3.0.0-beta.34 → 3.0.0-beta.35

package/dist/node/index.js

@@ -686,7 +686,7 @@ function resolveSubagentLogDir(parentSessionId, baseLogsDir) {
 
 // src/index.ts
 import { Session as Session3 } from "@robota-sdk/agent-sessions";
-import { FileSessionLogger as FileSessionLogger2, SilentSessionLogger } from "@robota-sdk/agent-sessions";
+import { FileSessionLogger as FileSessionLogger3, SilentSessionLogger } from "@robota-sdk/agent-sessions";
 import { SessionStore } from "@robota-sdk/agent-sessions";
 
 // src/config/config-loader.ts
@@ -1908,6 +1908,715 @@ var MarketplaceClient = class {
   }
 };
 
+// src/commands/command-registry.ts
+var CommandRegistry = class {
+  sources = [];
+  addSource(source) {
+    this.sources.push(source);
+  }
+  /** Get all commands, optionally filtered by prefix */
+  getCommands(filter) {
+    const all = [];
+    for (const source of this.sources) {
+      all.push(...source.getCommands());
+    }
+    if (!filter) return all;
+    const lower = filter.toLowerCase();
+    return all.filter((cmd) => cmd.name.toLowerCase().startsWith(lower));
+  }
+  /** Resolve a short name to its fully qualified plugin:name form */
+  resolveQualifiedName(shortName) {
+    const matches = this.getCommands().filter(
+      (c) => c.source === "plugin" && c.name.includes(":") && c.name.endsWith(`:${shortName}`)
+    );
+    if (matches.length !== 1) return null;
+    return matches[0].name;
+  }
+  /** Get subcommands for a specific command */
+  getSubcommands(commandName) {
+    const lower = commandName.toLowerCase();
+    for (const source of this.sources) {
+      for (const cmd of source.getCommands()) {
+        if (cmd.name.toLowerCase() === lower && cmd.subcommands) {
+          return cmd.subcommands;
+        }
+      }
+    }
+    return [];
+  }
+};
+
+// src/commands/builtin-source.ts
+import { CLAUDE_MODELS, formatTokenCount } from "@robota-sdk/agent-core";
+function buildModelSubcommands() {
+  const seen = /* @__PURE__ */ new Set();
+  const commands = [];
+  for (const model of Object.values(CLAUDE_MODELS)) {
+    if (seen.has(model.name)) continue;
+    seen.add(model.name);
+    commands.push({
+      name: model.id,
+      description: `${model.name} (${formatTokenCount(model.contextWindow).toUpperCase()})`,
+      source: "builtin"
+    });
+  }
+  return commands;
+}
+function createBuiltinCommands() {
+  return [
+    { name: "help", description: "Show available commands", source: "builtin" },
+    { name: "clear", description: "Clear conversation history", source: "builtin" },
+    {
+      name: "mode",
+      description: "Permission mode",
+      source: "builtin",
+      subcommands: [
+        { name: "plan", description: "Plan only, no execution", source: "builtin" },
+        { name: "default", description: "Ask before risky actions", source: "builtin" },
+        { name: "acceptEdits", description: "Auto-approve file edits", source: "builtin" },
+        { name: "bypassPermissions", description: "Skip all permission checks", source: "builtin" }
+      ]
+    },
+    {
+      name: "model",
+      description: "Select AI model",
+      source: "builtin",
+      subcommands: buildModelSubcommands()
+    },
+    {
+      name: "language",
+      description: "Set response language",
+      source: "builtin",
+      subcommands: [
+        { name: "ko", description: "Korean", source: "builtin" },
+        { name: "en", description: "English", source: "builtin" },
+        { name: "ja", description: "Japanese", source: "builtin" },
+        { name: "zh", description: "Chinese", source: "builtin" }
+      ]
+    },
+    { name: "compact", description: "Compress context window", source: "builtin" },
+    { name: "cost", description: "Show session info", source: "builtin" },
+    { name: "context", description: "Context window info", source: "builtin" },
+    { name: "permissions", description: "Permission rules", source: "builtin" },
+    { name: "plugin", description: "Manage plugins", source: "builtin" },
+    { name: "reload-plugins", description: "Reload all plugin resources", source: "builtin" },
+    { name: "reset", description: "Delete settings and exit", source: "builtin" },
+    { name: "exit", description: "Exit CLI", source: "builtin" }
+  ];
+}
+var BuiltinCommandSource = class {
+  name = "builtin";
+  commands;
+  constructor() {
+    this.commands = createBuiltinCommands();
+  }
+  getCommands() {
+    return this.commands;
+  }
+};
+
+// src/commands/skill-source.ts
+import { readdirSync as readdirSync3, readFileSync as readFileSync9, existsSync as existsSync9 } from "fs";
+import { join as join10, basename as basename2 } from "path";
+import { homedir as homedir3 } from "os";
+var BOOLEAN_KEYS = /* @__PURE__ */ new Set(["disable-model-invocation", "user-invocable"]);
+var LIST_KEYS2 = /* @__PURE__ */ new Set(["allowed-tools"]);
+function kebabToCamel(key) {
+  return key.replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase());
+}
+function parseFrontmatter2(content) {
+  const lines = content.split("\n");
+  if (lines[0]?.trim() !== "---") return null;
+  const result = {};
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "---") break;
+    const match = line.match(/^([a-z][a-z0-9-]*):\s*(.+)/);
+    if (!match) continue;
+    const key = match[1];
+    const rawValue = match[2].trim();
+    const camelKey = kebabToCamel(key);
+    if (BOOLEAN_KEYS.has(key)) {
+      result[camelKey] = rawValue === "true";
+    } else if (LIST_KEYS2.has(key)) {
+      result[camelKey] = rawValue.split(",").map((s) => s.trim());
+    } else {
+      result[camelKey] = rawValue;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : null;
+}
+function buildCommand(frontmatter, content, fallbackName) {
+  const cmd = {
+    name: frontmatter?.name ?? fallbackName,
+    description: frontmatter?.description ?? `Skill: ${fallbackName}`,
+    source: "skill",
+    skillContent: content
+  };
+  if (frontmatter?.argumentHint !== void 0) cmd.argumentHint = frontmatter.argumentHint;
+  if (frontmatter?.disableModelInvocation !== void 0)
+    cmd.disableModelInvocation = frontmatter.disableModelInvocation;
+  if (frontmatter?.userInvocable !== void 0) cmd.userInvocable = frontmatter.userInvocable;
+  if (frontmatter?.allowedTools !== void 0) cmd.allowedTools = frontmatter.allowedTools;
+  if (frontmatter?.model !== void 0) cmd.model = frontmatter.model;
+  if (frontmatter?.effort !== void 0) cmd.effort = frontmatter.effort;
+  if (frontmatter?.context !== void 0) cmd.context = frontmatter.context;
+  if (frontmatter?.agent !== void 0) cmd.agent = frontmatter.agent;
+  return cmd;
+}
+function scanSkillsDir(skillsDir) {
+  if (!existsSync9(skillsDir)) return [];
+  const commands = [];
+  const entries = readdirSync3(skillsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillFile = join10(skillsDir, entry.name, "SKILL.md");
+    if (!existsSync9(skillFile)) continue;
+    const content = readFileSync9(skillFile, "utf-8");
+    const frontmatter = parseFrontmatter2(content);
+    commands.push(buildCommand(frontmatter, content, entry.name));
+  }
+  return commands;
+}
+function scanCommandsDir(commandsDir) {
+  if (!existsSync9(commandsDir)) return [];
+  const commands = [];
+  const entries = readdirSync3(commandsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+    const filePath = join10(commandsDir, entry.name);
+    const content = readFileSync9(filePath, "utf-8");
+    const frontmatter = parseFrontmatter2(content);
+    const fallbackName = basename2(entry.name, ".md");
+    commands.push(buildCommand(frontmatter, content, fallbackName));
+  }
+  return commands;
+}
+var SkillCommandSource = class {
+  name = "skill";
+  cwd;
+  home;
+  cachedCommands = null;
+  constructor(cwd, home) {
+    this.cwd = cwd;
+    this.home = home ?? homedir3();
+  }
+  getCommands() {
+    if (this.cachedCommands) return this.cachedCommands;
+    const sources = [
+      scanSkillsDir(join10(this.cwd, ".claude", "skills")),
+      scanCommandsDir(join10(this.cwd, ".claude", "commands")),
+      scanSkillsDir(join10(this.home, ".robota", "skills")),
+      scanSkillsDir(join10(this.cwd, ".agents", "skills"))
+    ];
+    const seen = /* @__PURE__ */ new Set();
+    const merged = [];
+    for (const commands of sources) {
+      for (const cmd of commands) {
+        if (!seen.has(cmd.name)) {
+          seen.add(cmd.name);
+          merged.push(cmd);
+        }
+      }
+    }
+    this.cachedCommands = merged;
+    return this.cachedCommands;
+  }
+  getModelInvocableSkills() {
+    return this.getCommands().filter((cmd) => cmd.disableModelInvocation !== true);
+  }
+  getUserInvocableSkills() {
+    return this.getCommands().filter((cmd) => cmd.userInvocable !== false);
+  }
+};
+
+// 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",
+          "  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: "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.ts
+import { FileSessionLogger as FileSessionLogger2 } from "@robota-sdk/agent-sessions";
+import {
+  createUserMessage,
+  createAssistantMessage,
+  createSystemMessage,
+  createToolMessage
+} from "@robota-sdk/agent-core";
+import { randomUUID } from "crypto";
+var TOOL_ARG_DISPLAY_MAX = 80;
+var TAIL_KEEP = 30;
+var MAX_COMPLETED_TOOLS = 50;
+var STREAMING_FLUSH_INTERVAL_MS = 16;
+var InteractiveSession = class {
+  session;
+  listeners = /* @__PURE__ */ new Map();
+  // Streaming state
+  streamingText = "";
+  flushTimer = null;
+  // Tool state
+  activeTools = [];
+  // Execution state
+  executing = false;
+  pendingPrompt = null;
+  // Display messages (what clients render — not the raw session history)
+  messages = [];
+  constructor(options) {
+    if (options.session) {
+      this.session = options.session;
+    } else {
+      const cwd = options.cwd ?? process.cwd();
+      const paths = projectPaths(cwd);
+      this.session = createSession({
+        config: options.config,
+        context: options.context,
+        projectInfo: options.projectInfo,
+        sessionStore: options.sessionStore,
+        permissionMode: options.permissionMode,
+        maxTurns: options.maxTurns,
+        terminal: NOOP_TERMINAL,
+        sessionLogger: new FileSessionLogger2(paths.logs),
+        permissionHandler: options.permissionHandler,
+        onTextDelta: (delta) => this.handleTextDelta(delta),
+        onToolExecution: (event) => this.handleToolExecution(event)
+      });
+    }
+  }
+  // ── Event system ──────────────────────────────────────────────
+  on(event, handler) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(handler);
+  }
+  off(event, handler) {
+    this.listeners.get(event)?.delete(handler);
+  }
+  emit(event, ...args) {
+    const handlers = this.listeners.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        handler(...args);
+      }
+    }
+  }
+  // ── Public API ────────────────────────────────────────────────
+  /** Submit a prompt. Queues if already executing (max 1 queued). */
+  async submit(input) {
+    if (this.executing) {
+      this.pendingPrompt = input;
+      return;
+    }
+    await this.executePrompt(input);
+  }
+  /** Abort current execution and clear queue. */
+  abort() {
+    this.pendingPrompt = null;
+    this.session.abort();
+  }
+  /** Cancel queued prompt without aborting current execution. */
+  cancelQueue() {
+    this.pendingPrompt = null;
+  }
+  isExecuting() {
+    return this.executing;
+  }
+  getPendingPrompt() {
+    return this.pendingPrompt;
+  }
+  getMessages() {
+    return this.messages;
+  }
+  getStreamingText() {
+    return this.streamingText;
+  }
+  getActiveTools() {
+    return this.activeTools;
+  }
+  getContextState() {
+    return this.session.getContextState();
+  }
+  getSession() {
+    return this.session;
+  }
+  // ── Execution ─────────────────────────────────────────────────
+  async executePrompt(input) {
+    this.executing = true;
+    this.clearStreaming();
+    this.emit("thinking", true);
+    this.messages.push(createUserMessage(input));
+    const historyBefore = this.session.getHistory().length;
+    try {
+      const response = await this.session.run(input);
+      this.flushStreaming();
+      this.clearStreaming();
+      const result = this.buildResult(response || "(empty response)", historyBefore);
+      this.messages.push(createAssistantMessage(result.response));
+      this.emit("complete", result);
+      this.emit("context_update", this.getContextState());
+    } catch (err) {
+      this.flushStreaming();
+      this.clearStreaming();
+      if (isAbortError(err)) {
+        const result = this.buildInterruptedResult(historyBefore);
+        if (result.response) {
+          this.messages.push(createAssistantMessage(result.response));
+        }
+        this.messages.push(createSystemMessage("Interrupted by user."));
+        this.emit("interrupted", result);
+      } else {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        this.messages.push(createSystemMessage(`Error: ${errMsg}`));
+        this.emit("error", err instanceof Error ? err : new Error(errMsg));
+      }
+    } finally {
+      this.executing = false;
+      this.emit("thinking", false);
+      if (this.pendingPrompt) {
+        const queued = this.pendingPrompt;
+        this.pendingPrompt = null;
+        setTimeout(() => this.executePrompt(queued), 0);
+      }
+    }
+  }
+  // ── Streaming callbacks ───────────────────────────────────────
+  handleTextDelta(delta) {
+    this.streamingText += delta;
+    this.emit("text_delta", delta);
+    if (!this.flushTimer) {
+      this.flushTimer = setTimeout(() => {
+        this.flushTimer = null;
+      }, STREAMING_FLUSH_INTERVAL_MS);
+    }
+  }
+  handleToolExecution(event) {
+    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);
+    } 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);
+      }
+    }
+  }
+  // ── Helpers ───────────────────────────────────────────────────
+  clearStreaming() {
+    this.streamingText = "";
+    this.activeTools = [];
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  flushStreaming() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  buildResult(response, historyBefore) {
+    const toolSummaries = this.extractToolSummaries(historyBefore);
+    if (toolSummaries.length > 0) {
+      this.messages.push(
+        createToolMessage(JSON.stringify(toolSummaries), {
+          toolCallId: randomUUID(),
+          name: `${toolSummaries.length} tools`
+        })
+      );
+    }
+    return {
+      response,
+      messages: this.messages,
+      toolSummaries,
+      contextState: this.getContextState()
+    };
+  }
+  buildInterruptedResult(historyBefore) {
+    const history = this.session.getHistory();
+    const toolSummaries = this.extractToolSummaries(historyBefore);
+    if (toolSummaries.length > 0) {
+      this.messages.push(
+        createToolMessage(JSON.stringify(toolSummaries), {
+          toolCallId: randomUUID(),
+          name: `${toolSummaries.length} tools`
+        })
+      );
+    }
+    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"),
+      messages: this.messages,
+      toolSummaries,
+      contextState: this.getContextState()
+    };
+  }
+  extractToolSummaries(historyBefore) {
+    const history = this.session.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/index.ts
 import { bashTool as bashTool2 } from "@robota-sdk/agent-tools";
 import { readTool as readTool2 } from "@robota-sdk/agent-tools";
@@ -1918,16 +2627,21 @@ import { grepTool as grepTool2 } from "@robota-sdk/agent-tools";
 export {
   AgentExecutor,
   BUILT_IN_AGENTS,
+  BuiltinCommandSource,
   BundlePluginInstaller,
   BundlePluginLoader,
+  CommandRegistry,
   DEFAULT_TOOL_DESCRIPTIONS,
-  FileSessionLogger2 as FileSessionLogger,
+  FileSessionLogger3 as FileSessionLogger,
+  InteractiveSession,
   MarketplaceClient,
   PluginSettingsStore,
   PromptExecutor,
   Session3 as Session,
   SessionStore,
   SilentSessionLogger,
+  SkillCommandSource,
+  SystemCommandExecutor,
   TRUST_TO_MODE,
   assembleSubagentPrompt,
   bashTool2 as bashTool,
@@ -1938,6 +2652,7 @@ export {
   createSession,
   createSubagentLogger,
   createSubagentSession,
+  createSystemCommands,
   detectProject,
   editTool2 as editTool,
   evaluatePermission,
@@ -1948,6 +2663,7 @@ export {
   grepTool2 as grepTool,
   loadConfig,
   loadContext,
+  parseFrontmatter2 as parseFrontmatter,
   projectPaths,
   promptForApproval,
   query,