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

package/dist/node/index.js

@@ -6,229 +6,1302 @@ import {
   messageToHistoryEntry
 } from "@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 }
-        };
+// src/commands/capability-descriptors.ts
+function inferKind(command) {
+  if (command.source === "skill") return "skill";
+  if (command.source === "plugin" && command.skillContent) return "skill";
+  return "builtin-command";
+}
+function commandToCapabilityDescriptor(command) {
+  const skillLike = command.source === "skill" || command.source === "plugin" && Boolean(command.skillContent);
+  return {
+    name: `/${command.name}`,
+    kind: inferKind(command),
+    description: command.description,
+    userInvocable: command.userInvocable !== false,
+    modelInvocable: command.modelInvocable === true || skillLike && command.disableModelInvocation !== true,
+    ...command.argumentHint ? { argumentHint: command.argumentHint } : {},
+    ...command.safety ? { safety: command.safety } : {}
+  };
+}
+
+// src/commands/command-registry.ts
+var CommandRegistry = class {
+  sources = [];
+  addSource(source) {
+    this.sources.push(source);
+  }
+  addModule(module) {
+    for (const source of module.commandSources ?? []) {
+      this.addSource(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 [];
+  }
+  getCapabilityDescriptors() {
+    return this.getCommands().map((command) => commandToCapabilityDescriptor(command));
+  }
+};
+
+// 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 buildProviderSubcommands() {
+  return [
+    { name: "current", description: "Show current provider", source: "builtin" },
+    { name: "list", description: "List provider profiles", source: "builtin" },
+    { name: "use", description: "Switch provider profile", source: "builtin" },
+    { name: "test", description: "Test provider profile", source: "builtin" }
+  ];
+}
+function buildBackgroundSubcommands() {
+  return [
+    { name: "list", description: "List background tasks", source: "builtin" },
+    { name: "read", description: "Read a background task log page", source: "builtin" },
+    { name: "cancel", description: "Cancel a running background task", source: "builtin" },
+    { name: "close", description: "Dismiss a terminal background task", source: "builtin" }
+  ];
+}
+function createBuiltinCommands() {
+  return [
+    { name: "help", description: "Show available commands", source: "builtin" },
+    { name: "clear", description: "Clear conversation history", source: "builtin" },
     {
       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
-        };
-      }
+      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: "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 }
-        };
-      }
+      description: "Select AI model",
+      source: "builtin",
+      subcommands: buildModelSubcommands()
     },
     {
       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
-          }
-        };
-      }
+      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: "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: "provider",
+      description: "Manage provider profiles",
+      source: "builtin",
+      subcommands: buildProviderSubcommands()
     },
+    { name: "resume", description: "Resume a previous session", source: "builtin" },
     {
-      name: "resume",
-      description: "Resume a previous session",
-      execute: (_session, _args) => ({
-        message: "Opening session picker...",
-        success: true,
-        data: { triggerResumePicker: true }
-      })
+      name: "background",
+      description: "List and control background tasks",
+      source: "builtin",
+      subcommands: buildBackgroundSubcommands()
     },
-    {
-      name: "rename",
-      description: "Rename the current session",
-      execute: (_session, args) => {
-        const name = args.trim();
-        if (!name) {
-          return { message: "Usage: rename <name>", success: false };
+    { name: "rename", description: "Rename the current session", source: "builtin" },
+    { name: "plugin", description: "Manage plugins", source: "builtin" },
+    { name: "reload-plugins", description: "Reload all plugin resources", source: "builtin" },
+    { name: "reset", description: "Delete settings and exit", source: "builtin" },
+    { name: "exit", description: "Exit CLI", source: "builtin" }
+  ];
+}
+var BuiltinCommandSource = class {
+  name = "builtin";
+  commands;
+  constructor() {
+    this.commands = createBuiltinCommands();
+  }
+  getCommands() {
+    return this.commands;
+  }
+};
+
+// src/commands/skill-source.ts
+import { readdirSync, readFileSync, existsSync } from "fs";
+import { join, basename } from "path";
+import { homedir } from "os";
+var BOOLEAN_KEYS = /* @__PURE__ */ new Set(["disable-model-invocation", "user-invocable"]);
+var LIST_KEYS = /* @__PURE__ */ new Set(["allowed-tools"]);
+function kebabToCamel(key) {
+  return key.replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase());
+}
+function parseListValue(rawValue) {
+  const separator = rawValue.includes(",") ? /\s*,\s*/ : /\s+/;
+  return rawValue.split(separator).map((value) => value.trim()).filter((value) => value.length > 0);
+}
+function parseFrontmatter(content) {
+  const lines = content.split("\n");
+  if (lines[0]?.trim() !== "---") return null;
+  const result = {};
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "---") break;
+    const match = line.match(/^([a-z][a-z0-9-]*):\s*(.+)/);
+    if (!match) continue;
+    const key = match[1];
+    const rawValue = match[2].trim();
+    const camelKey = kebabToCamel(key);
+    if (BOOLEAN_KEYS.has(key)) {
+      result[camelKey] = rawValue === "true";
+    } else if (LIST_KEYS.has(key)) {
+      result[camelKey] = parseListValue(rawValue);
+    } 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 (!existsSync(skillsDir)) return [];
+  const commands = [];
+  const entries = readdirSync(skillsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillFile = join(skillsDir, entry.name, "SKILL.md");
+    if (!existsSync(skillFile)) continue;
+    const content = readFileSync(skillFile, "utf-8");
+    const frontmatter = parseFrontmatter(content);
+    commands.push(buildCommand(frontmatter, content, entry.name));
+  }
+  return commands;
+}
+function scanCommandsDir(commandsDir) {
+  if (!existsSync(commandsDir)) return [];
+  const commands = [];
+  const entries = readdirSync(commandsDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
+    const filePath = join(commandsDir, entry.name);
+    const content = readFileSync(filePath, "utf-8");
+    const frontmatter = parseFrontmatter(content);
+    const fallbackName = basename(entry.name, ".md");
+    commands.push(buildCommand(frontmatter, content, fallbackName));
+  }
+  return commands;
+}
+var SkillCommandSource = class {
+  name = "skill";
+  cwd;
+  home;
+  cachedCommands = null;
+  constructor(cwd, home) {
+    this.cwd = cwd;
+    this.home = home ?? homedir();
+  }
+  getCommands() {
+    if (this.cachedCommands) return this.cachedCommands;
+    const sources = [
+      scanSkillsDir(join(this.cwd, ".claude", "skills")),
+      scanCommandsDir(join(this.cwd, ".claude", "commands")),
+      scanSkillsDir(join(this.home, ".robota", "skills")),
+      scanSkillsDir(join(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/plugin-source.ts
+var PluginCommandSource = class {
+  name = "plugin";
+  plugins;
+  constructor(plugins) {
+    this.plugins = plugins;
+  }
+  getCommands() {
+    const commands = [];
+    for (const plugin of this.plugins) {
+      for (const skill of plugin.skills) {
+        const baseName = skill.name.includes("@") ? skill.name.split("@")[0] : skill.name;
+        commands.push({
+          name: baseName,
+          description: `(${plugin.manifest.name}) ${skill.description}`,
+          source: "plugin",
+          skillContent: skill.skillContent,
+          pluginDir: plugin.pluginDir
+        });
+      }
+      for (const cmd of plugin.commands) {
+        commands.push({
+          name: cmd.name,
+          description: cmd.description,
+          source: "plugin",
+          skillContent: cmd.skillContent,
+          pluginDir: plugin.pluginDir
+        });
+      }
+    }
+    return commands;
+  }
+};
+
+// src/commands/background-command.ts
+var DECIMAL_RADIX = 10;
+function parseCommandParts(args) {
+  return args.trim().split(/\s+/).filter(Boolean);
+}
+function formatBackgroundTask(task) {
+  const preview = task.promptPreview ?? task.commandPreview ?? "";
+  const unread = task.unread ? " unread" : "";
+  const action = task.currentAction ? ` (${task.currentAction})` : "";
+  const timeout = task.timeoutReason ? ` timeout=${task.timeoutReason}` : "";
+  const activity = task.lastActivityAt ? ` lastActivityAt=${task.lastActivityAt}` : "";
+  const suffix = preview ? ` \u2014 ${preview}` : "";
+  return `${task.id} [${task.status}${unread}${timeout}${activity}] ${task.kind}:${task.label}${action}${suffix}`;
+}
+function formatBackgroundTaskList(tasks) {
+  if (tasks.length === 0) return "No background tasks.";
+  return ["Background tasks:", ...tasks.map((task) => `  ${formatBackgroundTask(task)}`)].join(
+    "\n"
+  );
+}
+function parseCursor(value) {
+  if (!value) return void 0;
+  const offset = Number.parseInt(value, DECIMAL_RADIX);
+  return Number.isNaN(offset) ? void 0 : { offset };
+}
+async function executeBackgroundCommand(session, args) {
+  const [action = "list", taskId, ...reasonParts] = parseCommandParts(args);
+  if (action === "list") {
+    const tasks = session.listBackgroundTasks();
+    return {
+      message: formatBackgroundTaskList(tasks),
+      success: true,
+      data: { count: tasks.length }
+    };
+  }
+  if (!taskId) {
+    return {
+      message: "Usage: background list | background read <task-id> [offset] | background cancel <task-id> | background close <task-id>",
+      success: false
+    };
+  }
+  if (action === "read" || action === "log" || action === "open") {
+    const page = await session.readBackgroundTaskLog(taskId, parseCursor(reasonParts[0]));
+    const next = page.nextCursor ? `
+Next offset: ${page.nextCursor.offset}` : "";
+    return {
+      message: page.lines.length > 0 ? `${page.lines.join("\n")}${next}` : `No log lines: ${taskId}`,
+      success: true,
+      data: { taskId, nextOffset: page.nextCursor?.offset }
+    };
+  }
+  if (action === "cancel" || action === "stop") {
+    await session.cancelBackgroundTask(taskId, reasonParts.join(" ") || void 0);
+    return { message: `Background task cancelled: ${taskId}`, success: true, data: { taskId } };
+  }
+  if (action === "close" || action === "dismiss") {
+    await session.closeBackgroundTask(taskId);
+    return { message: `Background task closed: ${taskId}`, success: true, data: { taskId } };
+  }
+  return { message: `Unknown background action: ${action}`, success: 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",
+          "  provider          \u2014 Provider profile status and switching",
+          "  resume            \u2014 Resume a previous session",
+          "  background        \u2014 List/cancel/close background tasks",
+          "  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: `Session renamed to "${name}".`,
+          message: `Context compacted: ${Math.round(before)}% -> ${Math.round(after)}%`,
           success: true,
-          data: { name }
+          data: { before, after }
         };
       }
     },
     {
-      name: "reset",
-      description: "Delete settings",
-      execute: (_session, _args) => {
+      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: "Reset requested.",
-          success: true,
-          data: { resetRequested: true }
+          message: `Invalid mode. Valid: ${VALID_MODES.join(" | ")}`,
+          success: false
         };
       }
-    }
-  ];
-}
-var SystemCommandExecutor = class {
-  commands;
-  constructor(commands) {
-    this.commands = /* @__PURE__ */ new Map();
-    for (const cmd of commands ?? createSystemCommands()) {
-      this.commands.set(cmd.name, cmd);
+    },
+    {
+      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: "background",
+      description: "List and control background tasks",
+      execute: executeBackgroundCommand
+    },
+    {
+      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()];
+  }
+  listModelInvocableCommands() {
+    return this.listCommands().filter((command) => command.modelInvocable === true).map((command) => ({
+      name: `/${command.name}`,
+      kind: "builtin-command",
+      description: command.description,
+      userInvocable: command.userInvocable !== false,
+      modelInvocable: true,
+      ...command.argumentHint ? { argumentHint: command.argumentHint } : {},
+      ...command.safety ? { safety: command.safety } : {}
+    }));
+  }
+  isModelInvocable(name) {
+    return this.commands.get(name)?.modelInvocable === true;
+  }
+  async executeModelInvocable(name, session, args) {
+    if (!this.isModelInvocable(name)) return null;
+    return this.execute(name, session, args);
+  }
+  /** Check if a command exists. */
+  hasCommand(name) {
+    return this.commands.has(name);
+  }
+};
+
+// src/utils/skill-prompt.ts
+import { execSync } from "child_process";
+function substituteVariables(content, args, context) {
+  const argParts = args ? args.split(/\s+/) : [];
+  let result = content;
+  result = result.replace(/\$ARGUMENTS\[(\d+)]/g, (_match, index) => {
+    return argParts[Number(index)] ?? "";
+  });
+  result = result.replace(/\$ARGUMENTS/g, args);
+  result = result.replace(/\$(\d)(?!\d|\w|\[)/g, (_match, digit) => {
+    return argParts[Number(digit)] ?? "";
+  });
+  result = result.replace(/\$\{CLAUDE_SESSION_ID}/g, context?.sessionId ?? "");
+  result = result.replace(/\$\{CLAUDE_SKILL_DIR}/g, context?.skillDir ?? "");
+  return result;
+}
+async function preprocessShellCommands(content) {
+  const shellPattern = /!`([^`]+)`/g;
+  if (!shellPattern.test(content)) {
+    return content;
+  }
+  shellPattern.lastIndex = 0;
+  let result = content;
+  let match;
+  const matches = [];
+  while ((match = shellPattern.exec(content)) !== null) {
+    matches.push({ full: match[0], command: match[1] });
+  }
+  for (const { full, command } of matches) {
+    let output = "";
+    try {
+      output = execSync(command, {
+        timeout: 5e3,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      }).trimEnd();
+    } catch {
+      output = "";
+    }
+    result = result.replace(full, output);
+  }
+  return result;
+}
+async function buildSkillPrompt(input, registry, context) {
+  const parts = input.slice(1).split(/\s+/);
+  const cmd = parts[0]?.toLowerCase() ?? "";
+  const skillCmd = registry.getCommands().find((c) => c.name === cmd && (c.source === "skill" || c.source === "plugin"));
+  if (!skillCmd) return null;
+  const args = parts.slice(1).join(" ").trim();
+  const userInstruction = args || skillCmd.description;
+  if (skillCmd.skillContent) {
+    let processed = await preprocessShellCommands(skillCmd.skillContent);
+    processed = substituteVariables(processed, args, context);
+    return `<skill name="${cmd}">
+${processed}
+</skill>
+
+Execute the "${cmd}" skill: ${userInstruction}`;
+  }
+  return `Use the "${cmd}" skill: ${userInstruction}`;
+}
+
+// src/commands/skill-executor.ts
+async function buildProcessedContent(skill, args, context) {
+  if (!skill.skillContent) return null;
+  const preprocessed = await preprocessShellCommands(skill.skillContent);
+  return substituteVariables(preprocessed, args, context);
+}
+async function buildInjectPrompt(skill, args, context) {
+  const processed = await buildProcessedContent(skill, args, context);
+  if (processed) {
+    const userInstruction = args || skill.description;
+    return `<skill name="${skill.name}">
+${processed}
+</skill>
+
+Execute the "${skill.name}" skill: ${userInstruction}`;
+  }
+  return `Use the "${skill.name}" skill: ${args || skill.description}`;
+}
+async function executeSkill(skill, args, callbacks, context) {
+  if (skill.context === "fork") {
+    if (!callbacks.runInFork) {
+      throw new Error("Fork execution is not available. Agent tool deps may not be initialized.");
+    }
+    const content = await buildProcessedContent(skill, args, context);
+    const prompt2 = content ?? `Use the "${skill.name}" skill: ${args || skill.description}`;
+    const options = {};
+    if (skill.agent) options.agent = skill.agent;
+    if (skill.allowedTools) options.allowedTools = skill.allowedTools;
+    const result = await callbacks.runInFork(prompt2, options);
+    return { mode: "fork", result };
+  }
+  const prompt = await buildInjectPrompt(skill, args, context);
+  return { mode: "inject", prompt };
+}
+
+// src/assembly/create-subagent-session.ts
+import { Session } from "@robota-sdk/agent-sessions";
+
+// src/assembly/subagent-prompts.ts
+function getSubagentSuffix() {
+  return `When you complete the task, respond with a concise report covering what was done and any key findings \u2014 the caller will relay this to the user, so it only needs the essentials.
+
+In your final response, share file paths (always absolute, never relative) that are relevant to the task. Include code snippets only when the exact text is load-bearing \u2014 do not recap code you merely read.
+
+Do not use emojis.`;
+}
+function getForkWorkerSuffix() {
+  return `You are a worker subagent executing a specific task. Do NOT spawn sub-agents; execute directly. Keep your report under 500 words. Use this structure:
+- Scope: What was requested
+- Result: What was done
+- Key files: Relevant file paths (absolute)
+- Files changed: List of modifications
+- Issues: Any problems encountered`;
+}
+function assembleSubagentPrompt(options) {
+  const parts = [options.agentBody];
+  if (options.claudeMd) {
+    parts.push(options.claudeMd);
+  }
+  if (options.agentsMd) {
+    parts.push(options.agentsMd);
+  }
+  const suffix = options.isForkWorker ? getForkWorkerSuffix() : getSubagentSuffix();
+  parts.push(suffix);
+  return parts.join("\n\n");
+}
+
+// src/assembly/create-subagent-session.ts
+var MODEL_SHORTCUTS = {
+  sonnet: "claude-sonnet-4-6",
+  haiku: "claude-haiku-4-5",
+  opus: "claude-opus-4-6"
+};
+function resolveModelId(shortName, _parentModel) {
+  return MODEL_SHORTCUTS[shortName] ?? shortName;
+}
+function filterTools(parentTools, agentDefinition) {
+  let tools = [...parentTools];
+  if (agentDefinition.disallowedTools) {
+    const denySet = new Set(agentDefinition.disallowedTools);
+    tools = tools.filter((t) => !denySet.has(t.getName()));
+  }
+  if (agentDefinition.tools) {
+    const allowSet = new Set(agentDefinition.tools);
+    tools = tools.filter((t) => allowSet.has(t.getName()));
+  }
+  tools = tools.filter((t) => t.getName() !== "Agent");
+  return tools;
+}
+function createSubagentSession(options) {
+  const { agentDefinition, parentConfig, parentContext, parentTools, terminal } = options;
+  const tools = filterTools(parentTools, agentDefinition);
+  const model = agentDefinition.model ? resolveModelId(agentDefinition.model, parentConfig.provider.model) : parentConfig.provider.model;
+  const systemMessage = assembleSubagentPrompt({
+    agentBody: agentDefinition.systemPrompt,
+    claudeMd: parentContext.claudeMd,
+    agentsMd: parentContext.agentsMd,
+    isForkWorker: options.isForkWorker ?? false
+  });
+  const provider = options.provider;
+  return new Session({
+    tools,
+    provider,
+    systemMessage,
+    terminal,
+    ...options.sessionId !== void 0 ? { sessionId: options.sessionId } : {},
+    ...options.sessionLogger !== void 0 ? { sessionLogger: options.sessionLogger } : {},
+    model,
+    maxTurns: agentDefinition.maxTurns,
+    permissions: parentConfig.permissions,
+    permissionMode: options.permissionMode,
+    defaultTrustLevel: parentConfig.defaultTrustLevel,
+    permissionHandler: options.permissionHandler,
+    hooks: options.hooks,
+    hookTypeExecutors: options.hookTypeExecutors,
+    onTextDelta: options.onTextDelta,
+    onToolExecution: options.onToolExecution
+  });
+}
+
+// src/agents/built-in-agents.ts
+var GENERAL_PURPOSE_SYSTEM_PROMPT = `You are a general-purpose task execution agent. You have access to all tools available in the parent session and can perform any task delegated to you.
+
+Your role is to complete the assigned task thoroughly and accurately. Follow these guidelines:
+
+- Execute the task as described in the prompt. Do not expand scope beyond what is requested.
+- Use the most appropriate tools for each step. Prefer precise tools (Read, Grep, Glob) over broad ones (Bash) when possible.
+- Report your findings clearly and concisely when the task is complete.
+- If a task cannot be completed, explain why and what information is missing.
+- Maintain the same code quality standards as the parent session (strict types, no fallbacks, proper error handling).`;
+var EXPLORE_SYSTEM_PROMPT = `You are a codebase exploration and analysis agent. Your purpose is to search, read, and understand code without making any modifications.
+
+You operate in read-only mode. You must NEVER attempt to write or edit files. Your tools are restricted to read-only operations: reading files, searching with grep and glob, and running non-destructive bash commands.
+
+Your role is to answer questions about the codebase by:
+
+- Searching for relevant files, symbols, and patterns using Glob and Grep.
+- Reading source files, configuration, and documentation to understand structure and behavior.
+- Tracing code paths across modules to understand how components interact.
+- Summarizing findings in a clear, structured format with file paths and line references.
+- Identifying architectural patterns, dependencies, and potential issues.
+
+When exploring, prefer targeted searches over broad scans. Start with the most likely locations and narrow down. Always include absolute file paths in your responses so the caller can navigate directly to relevant code.`;
+var PLAN_SYSTEM_PROMPT = `You are a planning, research, and architecture agent. Your purpose is to analyze requirements, research approaches, and produce structured plans without making any code modifications.
+
+You operate in read-only mode. You must NEVER attempt to write or edit files. Your tools are restricted to read-only operations.
+
+Your role is to:
+
+- Analyze the current codebase state relevant to the task by reading specs, source code, and tests.
+- Research implementation approaches by examining existing patterns and architectural conventions in the repository.
+- Identify affected files, modules, and interfaces that a proposed change would touch.
+- Assess risks, dependencies, and potential breaking changes.
+- Produce a structured implementation plan with clear steps, file lists, and ordering.
+- Consider edge cases, error handling, and test coverage requirements.
+
+Output your plan in a structured format with numbered steps. For each step, specify which files are involved and what changes are needed. Flag any decisions that require human judgment or clarification.`;
+var BUILT_IN_AGENTS = [
+  {
+    name: "general-purpose",
+    description: "General-purpose task execution agent with full tool access.",
+    systemPrompt: GENERAL_PURPOSE_SYSTEM_PROMPT
+  },
+  {
+    name: "Explore",
+    description: "Read-only codebase exploration and analysis agent.",
+    systemPrompt: EXPLORE_SYSTEM_PROMPT,
+    disallowedTools: ["Write", "Edit"]
+  },
+  {
+    name: "Plan",
+    description: "Read-only planning, research, and architecture agent.",
+    systemPrompt: PLAN_SYSTEM_PROMPT,
+    disallowedTools: ["Write", "Edit"]
+  }
+];
+function getBuiltInAgent(name) {
+  return BUILT_IN_AGENTS.find((agent) => agent.name === name);
+}
+
+// src/tools/agent-tool.ts
+import { z } from "zod";
+import { createZodFunctionTool } from "@robota-sdk/agent-tools";
+import { SubagentManager } from "@robota-sdk/agent-runtime";
+
+// src/subagents/in-process-subagent-runner.ts
+function resolveAgentDefinition(agentType, customRegistry) {
+  const definition = customRegistry?.(agentType) ?? getBuiltInAgent(agentType);
+  if (!definition) {
+    throw new Error(`Unknown agent type: ${agentType}`);
+  }
+  return definition;
+}
+function applyRequestOverrides(definition, job) {
+  return {
+    ...definition,
+    ...job.request.model ? { model: job.request.model } : {},
+    ...job.request.allowedTools ? { tools: job.request.allowedTools } : {},
+    ...job.request.disallowedTools ? { disallowedTools: job.request.disallowedTools } : {}
+  };
+}
+function extractFirstArg(toolArgs) {
+  if (!toolArgs) return void 0;
+  const firstValue = Object.values(toolArgs)[0];
+  if (firstValue === void 0) return void 0;
+  return typeof firstValue === "object" ? JSON.stringify(firstValue) : String(firstValue);
+}
+function assertSupportedIsolation(job) {
+  if (job.request.isolation === "worktree") {
+    throw new Error("Worktree isolation requires a runtime shell subagent runner");
+  }
+}
+function emitToolExecutionEvent(job, event) {
+  if (event.type === "start") {
+    job.emit?.({
+      type: "background_task_tool_start",
+      toolName: event.toolName,
+      firstArg: extractFirstArg(event.toolArgs)
+    });
+    return;
+  }
+  job.emit?.({
+    type: "background_task_tool_end",
+    toolName: event.toolName,
+    success: event.success ?? true
+  });
+}
+function createInProcessSubagentRunner(deps) {
+  return {
+    start(job) {
+      assertSupportedIsolation(job);
+      const definition = resolveAgentDefinition(job.request.type, deps.customAgentRegistry);
+      const session = createSubagentSession({
+        agentDefinition: applyRequestOverrides(definition, job),
+        parentConfig: deps.config,
+        parentContext: deps.context,
+        parentTools: deps.tools,
+        provider: deps.provider,
+        terminal: deps.terminal,
+        permissionMode: deps.permissionMode,
+        permissionHandler: deps.permissionHandler,
+        hooks: deps.hooks,
+        hookTypeExecutors: deps.hookTypeExecutors,
+        onTextDelta: (delta) => {
+          job.emit?.({ type: "background_task_text_delta", delta });
+          deps.onTextDelta?.(delta);
+        },
+        onToolExecution: (event) => {
+          emitToolExecutionEvent(job, event);
+          deps.onToolExecution?.(event);
+        }
+      });
+      return {
+        jobId: job.jobId,
+        result: session.run(job.request.prompt).then((output) => ({
+          jobId: job.jobId,
+          output
+        })),
+        cancel: () => {
+          session.abort();
+          return Promise.resolve();
+        }
+      };
+    }
+  };
+}
+
+// src/tools/agent-tool.ts
+var AGENT_TOOL_DESCRIPTION = [
+  "Creates one subagent job for delegated work in an isolated context.",
+  "One tool call creates one subagent job.",
+  "When the user explicitly asks to create, run, spawn, delegate to, or use agents/subagents, start the requested subagent job immediately.",
+  "Do not ask a follow-up question unless execution is impossible or unsafe.",
+  "For multiple or parallel agents, create one Agent tool call per requested role in the current turn.",
+  "Subagent jobs run as background tasks by default.",
+  "The tool waits for a terminal result and returns completed, failed, or timed-out outcome data to the parent conversation.",
+  "Execution is represented by a real tool call and runtime background task event."
+].join(" ");
+function createAgentToolPromptDescription(agentDefinitions = []) {
+  const availableAgents = agentDefinitions.length > 0 ? ` Available agent types: ${agentDefinitions.map((agent) => `${agent.name} (${agent.description})`).join(", ")}.` : "";
+  return [
+    "Agent \u2014 creates one isolated subagent job.",
+    "One Agent tool call corresponds to one subagent job.",
+    "When the user explicitly asks to create, run, spawn, delegate to, or use agents/subagents, start the requested subagent job immediately.",
+    "Do not ask a follow-up question unless execution is impossible or unsafe.",
+    "For multiple or parallel agents, create one Agent tool call per requested role in the current turn.",
+    "The tool returns terminal result data.",
+    "Runtime mode is background.",
+    availableAgents
+  ].join(" ").replace(/\s+/g, " ").trim();
+}
+function asZodSchema(schema) {
+  return schema;
+}
+var AgentSchema = z.object({
+  prompt: z.string().describe("The task for the subagent to perform"),
+  subagent_type: z.string().optional().describe('Agent type: "general-purpose", "Explore", "Plan", or a custom agent name'),
+  model: z.string().optional().describe("Optional model override"),
+  isolation: z.enum(["none", "worktree"]).optional().describe('Optional runtime isolation mode. "worktree" runs in a Git worktree.')
+}).passthrough();
+var sessionDepsStore = /* @__PURE__ */ new WeakMap();
+function storeAgentToolDeps(key, deps) {
+  sessionDepsStore.set(key, deps);
+}
+function retrieveAgentToolDeps(key) {
+  return sessionDepsStore.get(key);
+}
+function resolveAgentDefinition2(agentType, customRegistry) {
+  if (customRegistry) {
+    const custom = customRegistry(agentType);
+    if (custom) return custom;
+  }
+  const builtIn = getBuiltInAgent(agentType);
+  if (builtIn) return builtIn;
+  return void 0;
+}
+function createSubagentManager(deps) {
+  return deps.subagentManager ?? new SubagentManager({
+    runner: createInProcessSubagentRunner(deps)
+  });
+}
+function createSpawnRequest(args, agentType, agentDef, deps) {
+  return {
+    type: agentType,
+    label: agentDef.name,
+    parentSessionId: deps.parentSessionId ?? "unknown-session",
+    mode: "background",
+    depth: deps.subagentDepth ?? 1,
+    cwd: deps.cwd ?? process.cwd(),
+    prompt: args.prompt,
+    model: args.model,
+    isolation: args.isolation
+  };
+}
+function stringifyUnknownAgentType(agentType) {
+  return JSON.stringify({
+    success: false,
+    output: "",
+    error: `Unknown agent type: ${agentType}`
+  });
+}
+function stringifyAgentSuccess(result) {
+  const worktreePath = result.metadata?.["worktreePath"];
+  const branchName = result.metadata?.["branchName"];
+  return JSON.stringify({
+    success: true,
+    output: result.output,
+    agentId: result.jobId,
+    metadata: result.metadata,
+    ...typeof worktreePath === "string" ? { worktreePath } : {},
+    ...typeof branchName === "string" ? { branchName } : {}
+  });
+}
+function stringifyAgentError(message, agentId) {
+  return JSON.stringify({
+    success: false,
+    output: "",
+    error: `Sub-agent error: ${message}`,
+    agentId
+  });
+}
+async function runManagedAgent(args, deps, manager) {
+  const agentType = args.subagent_type ?? "general-purpose";
+  const agentDef = resolveAgentDefinition2(agentType, deps.customAgentRegistry);
+  if (!agentDef) {
+    return stringifyUnknownAgentType(agentType);
+  }
+  let agentId;
+  try {
+    const state = await manager.spawn(createSpawnRequest(args, agentType, agentDef, deps));
+    agentId = state.id;
+    const response = await manager.wait(state.id);
+    return stringifyAgentSuccess(response);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return stringifyAgentError(message, agentId);
+  }
+}
+function createAgentTool(deps) {
+  const manager = createSubagentManager(deps);
+  return createZodFunctionTool(
+    "Agent",
+    AGENT_TOOL_DESCRIPTION,
+    asZodSchema(AgentSchema),
+    async (params) => {
+      const args = params;
+      return runManagedAgent(
+        {
+          prompt: args.prompt,
+          ...args.subagent_type !== void 0 ? { subagent_type: args.subagent_type } : {},
+          ...args.model !== void 0 ? { model: args.model } : {},
+          ...args.isolation !== void 0 ? { isolation: args.isolation } : {}
+        },
+        deps,
+        manager
+      );
+    }
+  );
+}
+
+// src/background-tasks/index.ts
+import { BackgroundTaskManager } from "@robota-sdk/agent-runtime";
+
+// src/background-tasks/background-job-orchestrator.ts
+import {
+  isTerminalBackgroundTaskStatus
+} from "@robota-sdk/agent-runtime";
+var DEFAULT_SUMMARY_LENGTH = 1e3;
+var BackgroundJobOrchestrator = class {
+  manager;
+  now;
+  idFactory;
+  unsubscribeManager;
+  listeners = /* @__PURE__ */ new Set();
+  groups = /* @__PURE__ */ new Map();
+  sequence = 0;
+  constructor(options) {
+    this.manager = options.manager;
+    this.now = options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
+    this.idFactory = options.idFactory ?? (() => this.nextGroupId());
+    this.sequence = options.initialGroups?.length ?? 0;
+    for (const group of options.initialGroups ?? []) this.restoreGroup(group);
+    this.unsubscribeManager = this.manager.subscribe((event) => this.handleTaskEvent(event));
+  }
+  createGroup(request) {
+    const now = this.now();
+    const state = {
+      id: this.idFactory(request),
+      parentSessionId: request.parentSessionId,
+      waitPolicy: request.waitPolicy,
+      taskIds: [...request.taskIds],
+      status: "running",
+      createdAt: now,
+      updatedAt: now,
+      results: [],
+      ...request.label ? { label: request.label } : {}
+    };
+    const record = this.createRecord(state);
+    this.groups.set(state.id, record);
+    this.captureExistingTerminalTasks(record);
+    this.emit({ type: "background_job_group_created", group: cloneGroup(record.state) });
+    this.evaluateCompletion(record);
+    return cloneGroup(record.state);
+  }
+  listGroups() {
+    return [...this.groups.values()].map((record) => cloneGroup(record.state));
+  }
+  getGroup(groupId) {
+    const record = this.groups.get(groupId);
+    return record ? cloneGroup(record.state) : void 0;
+  }
+  waitGroup(groupId) {
+    const record = this.groups.get(groupId);
+    if (!record) return Promise.reject(new Error(`Unknown background job group: ${groupId}`));
+    return record.completion;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  dispose() {
+    this.unsubscribeManager();
+    this.listeners.clear();
+  }
+  nextGroupId() {
+    this.sequence += 1;
+    return `group_${this.sequence}`;
+  }
+  restoreGroup(group) {
+    const record = this.createRecord(cloneGroup(group));
+    this.groups.set(group.id, record);
+    if (group.status === "completed") record.resolve(cloneGroup(group));
+  }
+  createRecord(state) {
+    let resolveGroup = () => {
+    };
+    const completion = new Promise((resolve2) => {
+      resolveGroup = resolve2;
+    });
+    return { state, completion, resolve: resolveGroup };
+  }
+  captureExistingTerminalTasks(record) {
+    for (const taskId of record.state.taskIds) {
+      const task = this.manager.get(taskId);
+      if (task && isTerminalBackgroundTaskStatus(task.status)) this.captureTask(record, task);
     }
   }
-  /** Register an additional command. */
-  register(command) {
-    this.commands.set(command.name, command);
+  handleTaskEvent(event) {
+    const task = getTerminalTask(event);
+    if (!task) return;
+    for (const record of this.groups.values()) {
+      if (!record.state.taskIds.includes(task.id)) continue;
+      if (!this.captureTask(record, task)) continue;
+      if (record.state.status === "running") this.evaluateCompletion(record);
+      else this.emit({ type: "background_job_group_updated", group: cloneGroup(record.state) });
+    }
   }
-  /** 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);
+  captureTask(record, task) {
+    if (record.state.results.some((result) => result.taskId === task.id)) return false;
+    record.state.results = [...record.state.results, createResultEnvelope(task)];
+    record.state.updatedAt = this.now();
+    return true;
   }
-  /** List all registered commands. */
-  listCommands() {
-    return [...this.commands.values()];
+  evaluateCompletion(record) {
+    if (record.state.status === "completed") return;
+    if (!shouldComplete(record.state)) {
+      this.emit({ type: "background_job_group_updated", group: cloneGroup(record.state) });
+      return;
+    }
+    const now = this.now();
+    record.state.status = "completed";
+    record.state.completedAt = now;
+    record.state.updatedAt = now;
+    const completed = cloneGroup(record.state);
+    record.resolve(completed);
+    this.emit({ type: "background_job_group_completed", group: completed });
   }
-  /** Check if a command exists. */
-  hasCommand(name) {
-    return this.commands.has(name);
+  emit(event) {
+    for (const listener of this.listeners) listener(event);
   }
 };
+function getTerminalTask(event) {
+  if (event.type === "background_task_completed" || event.type === "background_task_failed" || event.type === "background_task_cancelled") {
+    return event.task;
+  }
+  return void 0;
+}
+function shouldComplete(group) {
+  if (group.waitPolicy === "manual") return false;
+  if (group.waitPolicy === "wait_any") return group.results.length > 0;
+  return group.taskIds.every((taskId) => group.results.some((result) => result.taskId === taskId));
+}
+function createResultEnvelope(task) {
+  return {
+    taskId: task.id,
+    label: task.label,
+    status: task.status,
+    ...task.result?.output ? { summary: summarizeOutput(task.result.output) } : {},
+    ...task.transcriptPath || task.logPath ? { outputRef: task.transcriptPath ?? task.logPath } : {},
+    ...task.error ? { error: { ...task.error } } : {},
+    ...task.startedAt ? { startedAt: task.startedAt } : {},
+    ...task.completedAt ? { completedAt: task.completedAt } : {}
+  };
+}
+function summarizeOutput(output) {
+  const trimmed = output.trim();
+  if (trimmed.length <= DEFAULT_SUMMARY_LENGTH) return trimmed;
+  return `${trimmed.slice(0, DEFAULT_SUMMARY_LENGTH)}...`;
+}
+function summarizeBackgroundJobGroup(group) {
+  const completed = countResults(group, "completed");
+  const failed = countResults(group, "failed");
+  const cancelled = countResults(group, "cancelled");
+  return {
+    groupId: group.id,
+    status: group.status,
+    total: group.taskIds.length,
+    completed,
+    failed,
+    cancelled,
+    pending: Math.max(group.taskIds.length - group.results.length, 0),
+    lines: group.results.map((result) => formatResultLine(result))
+  };
+}
+function countResults(group, status) {
+  return group.results.filter((result) => result.status === status).length;
+}
+function formatResultLine(result) {
+  const detail = normalizeResultDetail(result);
+  const output = result.outputRef && result.summary ? ` (output: ${result.outputRef})` : "";
+  return `[${result.status}] ${result.label} ${result.taskId}: ${detail}${output}`;
+}
+function normalizeResultDetail(result) {
+  const detail = result.error?.message ?? result.summary ?? "";
+  const normalized = detail.replace(/\s+/g, " ").trim();
+  return normalized.length > 0 ? normalized : "(no summary)";
+}
+function cloneGroup(group) {
+  return {
+    ...group,
+    taskIds: [...group.taskIds],
+    results: group.results.map((result) => ({
+      ...result,
+      ...result.error ? { error: { ...result.error } } : {}
+    }))
+  };
+}
+
+// src/background-tasks/index.ts
+import {
+  getBackgroundTaskTransitions,
+  isTerminalBackgroundTaskStatus as isTerminalBackgroundTaskStatus2,
+  transitionBackgroundTaskStatus
+} from "@robota-sdk/agent-runtime";
+import { BackgroundTaskError } from "@robota-sdk/agent-runtime";
+
+// src/background-tasks/session-background-store.ts
+var sessionBackgroundTaskManagers = /* @__PURE__ */ new WeakMap();
+function storeSessionBackgroundTaskManager(key, manager) {
+  sessionBackgroundTaskManagers.set(key, manager);
+}
+function retrieveSessionBackgroundTaskManager(key) {
+  return sessionBackgroundTaskManagers.get(key);
+}
 
 // src/interactive/interactive-session-execution.ts
 function isAbortError(err) {
@@ -269,7 +1342,7 @@ function buildInterruptedResult(sessionHistory, interactiveHistory, historyBefor
     contextState
   };
 }
-function persistSession(sessionStore, session, sessionName, cwd, history) {
+function persistSession(sessionStore, session, sessionName, cwd, history, backgroundState) {
   try {
     const sessionId = session.getSessionId();
     const existing = sessionStore.load(sessionId);
@@ -280,7 +1353,15 @@ function persistSession(sessionStore, session, sessionName, cwd, history) {
       createdAt: existing?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
       updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       messages: session.getHistory(),
-      history
+      history,
+      systemPrompt: session.getSystemMessage(),
+      toolSchemas: session.getToolSchemas(),
+      ...backgroundState ? {
+        backgroundTasks: [...backgroundState.tasks],
+        backgroundTaskEvents: [...backgroundState.events],
+        backgroundJobGroups: [...backgroundState.groups ?? []],
+        backgroundJobGroupEvents: [...backgroundState.groupEvents ?? []]
+      } : {}
     });
   } catch {
   }
@@ -307,7 +1388,7 @@ var TOOL_ARG_DISPLAY_MAX = 80;
 var TAIL_KEEP = 30;
 var MAX_COMPLETED_TOOLS = 50;
 var STREAMING_FLUSH_INTERVAL_MS = 16;
-function extractFirstArg(toolArgs) {
+function extractFirstArg2(toolArgs) {
   if (!toolArgs) return "";
   const firstVal = Object.values(toolArgs)[0];
   const raw = typeof firstVal === "string" ? firstVal : JSON.stringify(firstVal ?? "");
@@ -349,7 +1430,7 @@ function trimCompletedTools(activeTools) {
   });
 }
 function applyToolStart(state, event) {
-  const firstArg = extractFirstArg(event.toolArgs);
+  const firstArg = extractFirstArg2(event.toolArgs);
   const toolState = { toolName: event.toolName, firstArg, isRunning: true };
   state.activeTools.push(toolState);
   state.history.push({
@@ -493,14 +1574,31 @@ Respond with JSON: { "ok": boolean, "reason"?: string }`;
 // src/assembly/create-session.ts
 import { Session as Session2 } from "@robota-sdk/agent-sessions";
 
-// src/context/system-prompt-builder.ts
-var TRUST_LEVEL_DESCRIPTIONS = {
-  safe: "safe (read-only / plan mode \u2014 only read-access tools are available)",
-  moderate: "moderate (default mode \u2014 write and bash tools require approval)",
-  full: "full (acceptEdits mode \u2014 file writes are auto-approved; bash requires approval)"
+// src/context/system-prompt-composer.ts
+function renderSection(section) {
+  const content = section.content.trim();
+  if (!section.title) return content;
+  return [`## ${section.title}`, content].join("\n");
+}
+function composeSystemPrompt(sections) {
+  return [...sections].filter((section) => section.content.trim().length > 0).sort((a, b) => a.priority - b.priority || a.id.localeCompare(b.id)).map((section) => renderSection(section)).join("\n\n");
+}
+
+// src/context/system-prompt-section-providers.ts
+var TRUST_LEVEL_LABELS = {
+  safe: "safe",
+  moderate: "moderate",
+  full: "full"
 };
-function buildProjectSection(info) {
-  const lines = ["## Current Project"];
+function createSection(id, title, priority, content, source) {
+  return { id, title, priority, content, source };
+}
+function createWorkingDirectorySection(cwd) {
+  if (!cwd) return void 0;
+  return createSection("runtime-cwd", "Working Directory", 30, `\`${cwd}\``, "runtime");
+}
+function createProjectSection(info) {
+  const lines = [];
   if (info.name !== void 0) {
     lines.push(`- **Name:** ${info.name}`);
   }
@@ -513,79 +1611,114 @@ function buildProjectSection(info) {
   if (info.packageManager !== void 0) {
     lines.push(`- **Package manager:** ${info.packageManager}`);
   }
-  return lines.join("\n");
+  return createSection("runtime-project", "Current Project", 40, lines.join("\n"), "runtime");
 }
-function buildToolsSection(descriptions) {
-  if (descriptions.length === 0) {
-    return "";
-  }
-  const lines = ["## Available Tools", ...descriptions.map((d) => `- ${d}`)];
-  return lines.join("\n");
+function createPermissionSection(trustLevel) {
+  return createSection(
+    "permission-mode",
+    "Permission Mode",
+    50,
+    `- **Trust level:** ${TRUST_LEVEL_LABELS[trustLevel]}`,
+    "permissions"
+  );
 }
-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}`)
+function createResponseLanguageSection(language) {
+  if (language === void 0 || language.trim().length === 0) return void 0;
+  return createSection("runtime-response-language", "Response Language", 45, language, "runtime");
+}
+function createAgentsMdSection(agentsMd) {
+  if (agentsMd.trim().length === 0) return void 0;
+  return createSection(
+    "project-agents-md",
+    "Agent Instructions",
+    10,
+    agentsMd,
+    "project-instructions"
+  );
+}
+function createClaudeMdSection(claudeMd) {
+  if (claudeMd.trim().length === 0) return void 0;
+  return createSection("project-claude-md", "Project Notes", 20, claudeMd, "project-instructions");
+}
+function createToolDescriptionSection(descriptions) {
+  if (descriptions.length === 0) return void 0;
+  return createSection(
+    "tool-descriptions",
+    "Available Tools",
+    60,
+    descriptions.map((description) => `- ${description}`).join("\n"),
+    "tool"
+  );
+}
+function formatCapability(descriptor) {
+  const arg = descriptor.argumentHint ? ` ${descriptor.argumentHint}` : "";
+  return `- ${descriptor.name}${arg}: ${descriptor.description}`;
+}
+function createCapabilityKindSection(kind, title, priority, source, descriptors) {
+  const content = descriptors.filter((descriptor) => descriptor.modelInvocable && descriptor.kind === kind).map(formatCapability).join("\n");
+  if (content.trim().length === 0) return void 0;
+  return createSection(`capability-${kind}`, title, priority, content, source);
+}
+function createCapabilitySections(descriptors) {
+  const sections = [];
+  const commandSection = createCapabilityKindSection(
+    "builtin-command",
+    "Built-in Commands",
+    70,
+    "command",
+    descriptors
+  );
+  const skillSection = createCapabilityKindSection("skill", "Skills", 80, "skill", descriptors);
+  const agentSection = createCapabilityKindSection("agent", "Agents", 90, "agent", descriptors);
+  const toolSection = createCapabilityKindSection("tool", "Tools", 100, "tool", descriptors);
+  if (commandSection) sections.push(commandSection);
+  if (skillSection) sections.push(skillSection);
+  if (agentSection) sections.push(agentSection);
+  if (toolSection) sections.push(toolSection);
+  return sections;
+}
+
+// src/context/system-prompt-builder.ts
+function appendOptionalSection(sections, section) {
+  if (section !== void 0) sections.push(section);
+}
+function mapSkillDescriptors(skills) {
+  return skills.map((skill) => ({
+    name: skill.name,
+    kind: "skill",
+    description: skill.description,
+    userInvocable: true,
+    modelInvocable: skill.disableModelInvocation !== true
+  }));
+}
+function mapAgentDescriptors(agents) {
+  return agents.map((agent) => ({
+    name: agent.name,
+    kind: "agent",
+    description: agent.description,
+    userInvocable: false,
+    modelInvocable: true,
+    safety: "background-agent"
+  }));
+}
+function buildCapabilityDescriptors(params) {
+  return [
+    ...params.commandDescriptors ?? [],
+    ...params.skills ? mapSkillDescriptors(params.skills) : [],
+    ...params.agents ? mapAgentDescriptors(params.agents) : []
   ];
-  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");
+  appendOptionalSection(sections, createAgentsMdSection(params.agentsMd));
+  appendOptionalSection(sections, createClaudeMdSection(params.claudeMd));
+  appendOptionalSection(sections, createWorkingDirectorySection(params.cwd));
+  sections.push(createProjectSection(params.projectInfo));
+  appendOptionalSection(sections, createResponseLanguageSection(params.language));
+  sections.push(createPermissionSection(params.trustLevel));
+  appendOptionalSection(sections, createToolDescriptionSection(params.toolDescriptions));
+  sections.push(...createCapabilitySections(buildCapabilityDescriptors(params)));
+  return composeSystemPrompt(sections);
 }
 
 // src/assembly/create-tools.ts
@@ -621,240 +1754,128 @@ function createDefaultTools() {
   ];
 }
 
-// src/tools/agent-tool.ts
-import { z } from "zod";
-import { createZodFunctionTool } from "@robota-sdk/agent-tools";
-
-// src/agents/built-in-agents.ts
-var GENERAL_PURPOSE_SYSTEM_PROMPT = `You are a general-purpose task execution agent. You have access to all tools available in the parent session and can perform any task delegated to you.
-
-Your role is to complete the assigned task thoroughly and accurately. Follow these guidelines:
-
-- Execute the task as described in the prompt. Do not expand scope beyond what is requested.
-- Use the most appropriate tools for each step. Prefer precise tools (Read, Grep, Glob) over broad ones (Bash) when possible.
-- Report your findings clearly and concisely when the task is complete.
-- If a task cannot be completed, explain why and what information is missing.
-- Maintain the same code quality standards as the parent session (strict types, no fallbacks, proper error handling).`;
-var EXPLORE_SYSTEM_PROMPT = `You are a codebase exploration and analysis agent. Your purpose is to search, read, and understand code without making any modifications.
-
-You operate in read-only mode. You must NEVER attempt to write or edit files. Your tools are restricted to read-only operations: reading files, searching with grep and glob, and running non-destructive bash commands.
-
-Your role is to answer questions about the codebase by:
-
-- Searching for relevant files, symbols, and patterns using Glob and Grep.
-- Reading source files, configuration, and documentation to understand structure and behavior.
-- Tracing code paths across modules to understand how components interact.
-- Summarizing findings in a clear, structured format with file paths and line references.
-- Identifying architectural patterns, dependencies, and potential issues.
-
-When exploring, prefer targeted searches over broad scans. Start with the most likely locations and narrow down. Always include absolute file paths in your responses so the caller can navigate directly to relevant code.`;
-var PLAN_SYSTEM_PROMPT = `You are a planning, research, and architecture agent. Your purpose is to analyze requirements, research approaches, and produce structured plans without making any code modifications.
-
-You operate in read-only mode. You must NEVER attempt to write or edit files. Your tools are restricted to read-only operations.
-
-Your role is to:
-
-- Analyze the current codebase state relevant to the task by reading specs, source code, and tests.
-- Research implementation approaches by examining existing patterns and architectural conventions in the repository.
-- Identify affected files, modules, and interfaces that a proposed change would touch.
-- Assess risks, dependencies, and potential breaking changes.
-- Produce a structured implementation plan with clear steps, file lists, and ordering.
-- Consider edge cases, error handling, and test coverage requirements.
-
-Output your plan in a structured format with numbered steps. For each step, specify which files are involved and what changes are needed. Flag any decisions that require human judgment or clarification.`;
-var BUILT_IN_AGENTS = [
-  {
-    name: "general-purpose",
-    description: "General-purpose task execution agent with full tool access.",
-    systemPrompt: GENERAL_PURPOSE_SYSTEM_PROMPT
-  },
-  {
-    name: "Explore",
-    description: "Read-only codebase exploration and analysis agent.",
-    systemPrompt: EXPLORE_SYSTEM_PROMPT,
-    model: "claude-haiku-4-5",
-    disallowedTools: ["Write", "Edit"]
-  },
-  {
-    name: "Plan",
-    description: "Read-only planning, research, and architecture agent.",
-    systemPrompt: PLAN_SYSTEM_PROMPT,
-    disallowedTools: ["Write", "Edit"]
-  }
-];
-function getBuiltInAgent(name) {
-  return BUILT_IN_AGENTS.find((agent) => agent.name === name);
-}
-
-// src/assembly/create-subagent-session.ts
-import { Session } from "@robota-sdk/agent-sessions";
-
-// src/assembly/subagent-prompts.ts
-function getSubagentSuffix() {
-  return `When you complete the task, respond with a concise report covering what was done and any key findings \u2014 the caller will relay this to the user, so it only needs the essentials.
-
-In your final response, share file paths (always absolute, never relative) that are relevant to the task. Include code snippets only when the exact text is load-bearing \u2014 do not recap code you merely read.
-
-Do not use emojis.`;
-}
-function getForkWorkerSuffix() {
-  return `You are a worker subagent executing a specific task. Do NOT spawn sub-agents; execute directly. Keep your report under 500 words. Use this structure:
-- Scope: What was requested
-- Result: What was done
-- Key files: Relevant file paths (absolute)
-- Files changed: List of modifications
-- Issues: Any problems encountered`;
+// src/tools/background-process-tool.ts
+import { z as z2 } from "zod";
+import { createZodFunctionTool as createZodFunctionTool2 } from "@robota-sdk/agent-tools";
+var DEFAULT_PROCESS_TIMEOUT_MS = 12e4;
+function asZodSchema2(schema) {
+  return schema;
 }
-function assembleSubagentPrompt(options) {
-  const parts = [options.agentBody];
-  if (options.claudeMd) {
-    parts.push(options.claudeMd);
-  }
-  if (options.agentsMd) {
-    parts.push(options.agentsMd);
-  }
-  const suffix = options.isForkWorker ? getForkWorkerSuffix() : getSubagentSuffix();
-  parts.push(suffix);
-  return parts.join("\n\n");
+var BackgroundProcessSchema = z2.object({
+  command: z2.string().describe("The shell command to start in the background"),
+  timeout: z2.number().optional().describe("Optional timeout in milliseconds. Default is 120000."),
+  workingDirectory: z2.string().optional().describe("Working directory for the command. Defaults to the current project directory."),
+  stdin: z2.string().optional().describe("Optional stdin to write after the process starts."),
+  outputLimitBytes: z2.number().optional().describe("Maximum captured output bytes kept in the task result.")
+});
+function stringifyStarted(taskId, status, command) {
+  return JSON.stringify({
+    success: true,
+    background: true,
+    output: "",
+    taskId,
+    status,
+    command
+  });
 }
-
-// src/assembly/create-subagent-session.ts
-var MODEL_SHORTCUTS = {
-  sonnet: "claude-sonnet-4-6",
-  haiku: "claude-haiku-4-5",
-  opus: "claude-opus-4-6"
-};
-function resolveModelId(shortName, _parentModel) {
-  return MODEL_SHORTCUTS[shortName] ?? shortName;
+function stringifyProcessError(message) {
+  return JSON.stringify({
+    success: false,
+    background: true,
+    output: "",
+    error: `Background process error: ${message}`
+  });
 }
-function filterTools(parentTools, agentDefinition) {
-  let tools = [...parentTools];
-  if (agentDefinition.disallowedTools) {
-    const denySet = new Set(agentDefinition.disallowedTools);
-    tools = tools.filter((t) => !denySet.has(t.getName()));
-  }
-  if (agentDefinition.tools) {
-    const allowSet = new Set(agentDefinition.tools);
-    tools = tools.filter((t) => allowSet.has(t.getName()));
+async function startBackgroundProcess(args, deps) {
+  try {
+    const state = await deps.backgroundTaskManager.spawn({
+      kind: "process",
+      label: args.command,
+      mode: "background",
+      parentSessionId: deps.parentSessionId ?? "unknown-session",
+      depth: 0,
+      cwd: args.workingDirectory ?? deps.cwd ?? process.cwd(),
+      command: args.command,
+      stdin: args.stdin,
+      timeoutMs: args.timeout ?? DEFAULT_PROCESS_TIMEOUT_MS,
+      outputLimitBytes: args.outputLimitBytes
+    });
+    return stringifyStarted(state.id, state.status, args.command);
+  } catch (error) {
+    return stringifyProcessError(error instanceof Error ? error.message : String(error));
   }
-  tools = tools.filter((t) => t.getName() !== "Agent");
-  return tools;
 }
-function createSubagentSession(options) {
-  const { agentDefinition, parentConfig, parentContext, parentTools, terminal } = options;
-  const tools = filterTools(parentTools, agentDefinition);
-  const model = agentDefinition.model ? resolveModelId(agentDefinition.model, parentConfig.provider.model) : parentConfig.provider.model;
-  const systemMessage = assembleSubagentPrompt({
-    agentBody: agentDefinition.systemPrompt,
-    claudeMd: parentContext.claudeMd,
-    agentsMd: parentContext.agentsMd,
-    isForkWorker: options.isForkWorker ?? false
-  });
-  const provider = options.provider;
-  return new Session({
-    tools,
-    provider,
-    systemMessage,
-    terminal,
-    model,
-    maxTurns: agentDefinition.maxTurns,
-    permissions: parentConfig.permissions,
-    permissionMode: options.permissionMode,
-    defaultTrustLevel: parentConfig.defaultTrustLevel,
-    permissionHandler: options.permissionHandler,
-    hooks: options.hooks,
-    hookTypeExecutors: options.hookTypeExecutors,
-    onTextDelta: options.onTextDelta,
-    onToolExecution: options.onToolExecution
-  });
+function createBackgroundProcessTool(deps) {
+  return createZodFunctionTool2(
+    "BackgroundProcess",
+    "Start a shell command as a managed background task. Use this for long-running commands that should not block the current conversation. Use /background list, /background read <taskId>, /background cancel <taskId>, or /background close <taskId> to inspect or control it.",
+    asZodSchema2(BackgroundProcessSchema),
+    async (params) => startBackgroundProcess(params, deps)
+  );
 }
 
-// src/tools/agent-tool.ts
-function asZodSchema(schema) {
-  return schema;
-}
-var AgentSchema = z.object({
-  prompt: z.string().describe("The task for the subagent to perform"),
-  subagent_type: z.string().optional().describe('Agent type: "general-purpose", "Explore", "Plan", or a custom agent name'),
-  model: z.string().optional().describe("Optional model override")
+// src/tools/command-execution-tool.ts
+import { z as z3 } from "zod";
+import { createZodFunctionTool as createZodFunctionTool3 } from "@robota-sdk/agent-tools";
+var CommandExecutionSchema = z3.object({
+  command: z3.string().describe("Command name to execute, with or without a leading slash"),
+  args: z3.string().optional().describe("Arguments to pass to the command")
 });
-var sessionDepsStore = /* @__PURE__ */ new WeakMap();
-function storeAgentToolDeps(key, deps) {
-  sessionDepsStore.set(key, deps);
-}
-function retrieveAgentToolDeps(key) {
-  return sessionDepsStore.get(key);
-}
-function resolveAgentDefinition(agentType, customRegistry) {
-  const builtIn = getBuiltInAgent(agentType);
-  if (builtIn) return builtIn;
-  if (customRegistry) return customRegistry(agentType);
-  return void 0;
+function asZodSchema3(schema) {
+  return schema;
 }
-function generateAgentId() {
-  return `agent_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+function normalizeCommand(command) {
+  return command.trim().replace(/^\/+/, "").split(/\s+/)[0] ?? "";
 }
-function createAgentTool(deps) {
-  async function runAgent(args) {
-    const agentType = args.subagent_type ?? "general-purpose";
-    const agentDef = resolveAgentDefinition(agentType, deps.customAgentRegistry);
-    if (!agentDef) {
-      return JSON.stringify({
-        success: false,
-        output: "",
-        error: `Unknown agent type: ${agentType}`
-      });
-    }
-    const effectiveDef = args.model ? { ...agentDef, model: args.model } : agentDef;
-    const session = createSubagentSession({
-      agentDefinition: effectiveDef,
-      parentConfig: deps.config,
-      parentContext: deps.context,
-      parentTools: deps.tools,
-      provider: deps.provider,
-      terminal: deps.terminal,
-      permissionMode: deps.permissionMode,
-      permissionHandler: deps.permissionHandler,
-      hooks: deps.hooks,
-      hookTypeExecutors: deps.hookTypeExecutors,
-      onTextDelta: deps.onTextDelta,
-      onToolExecution: deps.onToolExecution
+function stringifyCommandResult(command, result) {
+  if (!result) {
+    return JSON.stringify({
+      success: false,
+      command,
+      error: `Unknown command: ${command}`
     });
-    const agentId = generateAgentId();
-    try {
-      const response = await session.run(args.prompt);
-      return JSON.stringify({
-        success: true,
-        output: response,
-        agentId
-      });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return JSON.stringify({
-        success: false,
-        output: "",
-        error: `Sub-agent error: ${message}`,
-        agentId
-      });
-    }
   }
-  return createZodFunctionTool(
-    "Agent",
-    "Launch a subagent to handle a task in an isolated context. The subagent gets its own context window and returns a result when done. The result returned by the agent is not visible to the user. To show the user the result, you should send a text message back to the user with a concise summary of the result.",
-    asZodSchema(AgentSchema),
+  return JSON.stringify({
+    success: result.success,
+    command,
+    message: result.message,
+    data: result.data
+  });
+}
+function createCommandExecutionTool(deps) {
+  return createZodFunctionTool3(
+    "ExecuteCommand",
+    "Executes a registered model-invocable Robota command through the command registry. Accepted command names and argument grammar come from registered command descriptors.",
+    asZodSchema3(CommandExecutionSchema),
     async (params) => {
-      return runAgent(params);
+      const args = CommandExecutionSchema.parse(params);
+      const command = normalizeCommand(args.command);
+      if (!deps.isModelInvocable(command)) {
+        return JSON.stringify({
+          success: false,
+          command,
+          error: `Command is not model-invocable: ${command}`
+        });
+      }
+      return stringifyCommandResult(command, await deps.execute(command, args.args ?? ""));
     }
   );
 }
 
+// src/assembly/create-session.ts
+import { BackgroundTaskManager as BackgroundTaskManager2, SubagentManager as SubagentManager2 } from "@robota-sdk/agent-runtime";
+
 // src/agents/agent-definition-loader.ts
-import { readdirSync, readFileSync, existsSync } from "fs";
-import { join, basename } from "path";
-import { homedir } from "os";
-var LIST_KEYS = /* @__PURE__ */ new Set(["tools", "disallowedTools"]);
+import { readdirSync as readdirSync2, readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join2, basename as basename2 } from "path";
+import { homedir as homedir2 } from "os";
+var LIST_KEYS2 = /* @__PURE__ */ new Set(["tools", "disallowedTools"]);
 var NUMBER_KEYS = /* @__PURE__ */ new Set(["maxTurns"]);
-function parseFrontmatter(content) {
+function parseListValue2(rawValue) {
+  const separator = rawValue.includes(",") ? /\s*,\s*/ : /\s+/;
+  return rawValue.split(separator).map((value) => value.trim()).filter((value) => value.length > 0);
+}
+function parseFrontmatter2(content) {
   const lines = content.split("\n");
   if (lines[0]?.trim() !== "---") {
     return { frontmatter: null, body: content };
@@ -876,8 +1897,8 @@ function parseFrontmatter(content) {
     if (!match) continue;
     const key = match[1];
     const rawValue = match[2].trim();
-    if (LIST_KEYS.has(key)) {
-      result[key] = rawValue.split(",").map((s) => s.trim());
+    if (LIST_KEYS2.has(key)) {
+      result[key] = parseListValue2(rawValue);
     } else if (NUMBER_KEYS.has(key)) {
       result[key] = parseInt(rawValue, 10);
     } else {
@@ -891,20 +1912,20 @@ function parseFrontmatter(content) {
   };
 }
 function scanAgentsDir(dir) {
-  if (!existsSync(dir)) return [];
+  if (!existsSync2(dir)) return [];
   const agents = [];
   let entries;
   try {
-    entries = readdirSync(dir, { withFileTypes: true });
+    entries = readdirSync2(dir, { withFileTypes: true });
   } catch {
     return [];
   }
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const filePath = join(dir, entry.name);
-    const content = readFileSync(filePath, "utf-8");
-    const { frontmatter, body } = parseFrontmatter(content);
-    const fallbackName = basename(entry.name, ".md");
+    const filePath = join2(dir, entry.name);
+    const content = readFileSync2(filePath, "utf-8");
+    const { frontmatter, body } = parseFrontmatter2(content);
+    const fallbackName = basename2(entry.name, ".md");
     const agent = {
       name: frontmatter?.name ?? fallbackName,
       description: frontmatter?.description ?? "",
@@ -924,13 +1945,16 @@ var AgentDefinitionLoader = class {
   home;
   constructor(cwd, home) {
     this.cwd = cwd;
-    this.home = home ?? homedir();
+    this.home = home ?? homedir2();
   }
   /** Load all agent definitions, merged with built-in agents. Custom overrides built-in on name collision. */
   loadAll() {
     const sources = [
-      scanAgentsDir(join(this.cwd, ".claude", "agents")),
-      scanAgentsDir(join(this.home, ".robota", "agents"))
+      scanAgentsDir(join2(this.cwd, ".robota", "agents")),
+      scanAgentsDir(join2(this.cwd, ".agents", "agents")),
+      scanAgentsDir(join2(this.cwd, ".claude", "agents")),
+      scanAgentsDir(join2(this.home, ".robota", "agents")),
+      scanAgentsDir(join2(this.home, ".claude", "agents"))
     ];
     const seen = /* @__PURE__ */ new Set();
     const customAgents = [];
@@ -956,7 +1980,49 @@ var AgentDefinitionLoader = class {
   }
 };
 
+// src/assembly/background-task-hooks.ts
+import { runHooks } from "@robota-sdk/agent-core";
+function getSubagentHookEvent(event) {
+  if (event.type === "background_task_started" && event.task.kind === "agent") {
+    return "SubagentStart";
+  }
+  if ((event.type === "background_task_completed" || event.type === "background_task_failed" || event.type === "background_task_cancelled") && event.task.kind === "agent") {
+    return "SubagentStop";
+  }
+  return void 0;
+}
+function fireSubagentLifecycleHook(event, cwd, hooks, hookTypeExecutors) {
+  const hookEventName = getSubagentHookEvent(event);
+  if (!hookEventName || !("task" in event)) return;
+  const input = {
+    session_id: event.task.parentSessionId,
+    cwd,
+    hook_event_name: hookEventName,
+    agent_id: event.task.id,
+    agent_type: event.task.agentType ?? event.task.label,
+    ...event.task.transcriptPath ? {
+      agent_transcript_path: event.task.transcriptPath,
+      transcript_path: event.task.transcriptPath
+    } : {},
+    ...event.task.error?.message || event.task.timeoutReason ? { reason: event.task.error?.message ?? event.task.timeoutReason } : {},
+    ...hookEventName === "SubagentStop" ? {
+      stop_hook_active: false,
+      ...event.task.result?.output ? { last_assistant_message: event.task.result.output } : {}
+    } : {},
+    env: {
+      CLAUDE_PROJECT_DIR: cwd,
+      CLAUDE_SESSION_ID: event.task.parentSessionId,
+      ROBOTA_AGENT_ID: event.task.id,
+      ROBOTA_AGENT_TYPE: event.task.agentType ?? event.task.label
+    }
+  };
+  void runHooks(hooks, hookEventName, input, hookTypeExecutors).catch(() => void 0);
+}
+
 // src/assembly/create-session.ts
+var ID_RADIX = 36;
+var ID_RANDOM_LENGTH = 9;
+var DEFAULT_PROVIDER_IDLE_TIMEOUT_MS = 12e4;
 function createSession(options) {
   if (!options.provider) {
     throw new Error(
@@ -964,9 +2030,18 @@ function createSession(options) {
     );
   }
   const provider = options.provider;
+  const cwd = options.cwd ?? process.cwd();
+  const sessionId = options.sessionId ?? createSessionId();
   const defaultTools = createDefaultTools();
   const tools = [...defaultTools, ...options.additionalTools ?? []];
-  const agentLoader = new AgentDefinitionLoader(process.cwd());
+  if (options.modelCommandExecutor && options.isModelCommandInvocable) {
+    tools.push(
+      createCommandExecutionTool({
+        execute: options.modelCommandExecutor,
+        isModelInvocable: options.isModelCommandInvocable
+      })
+    );
+  }
   const hookTypeExecutors = [];
   if (options.providerFactory) {
     hookTypeExecutors.push(
@@ -986,31 +2061,102 @@ function createSession(options) {
   if (options.additionalHookExecutors) {
     hookTypeExecutors.push(...options.additionalHookExecutors);
   }
-  const agentToolDeps = {
-    config: options.config,
-    context: options.context,
-    tools,
-    terminal: options.terminal,
-    provider,
-    permissionMode: options.permissionMode,
-    permissionHandler: options.permissionHandler,
-    hooks: options.config.hooks,
-    hookTypeExecutors: hookTypeExecutors.length > 0 ? hookTypeExecutors : void 0,
-    onTextDelta: options.onTextDelta,
-    onToolExecution: options.onToolExecution,
-    customAgentRegistry: (name) => agentLoader.getAgent(name)
-  };
-  tools.push(createAgentTool(agentToolDeps));
+  let agentToolDeps;
+  let agentDefinitions = [];
+  let backgroundTaskManager;
+  if (options.enableAgentRuntime) {
+    const agentLoader = new AgentDefinitionLoader(cwd);
+    agentDefinitions = agentLoader.loadAll();
+    agentToolDeps = {
+      config: options.config,
+      context: options.context,
+      tools,
+      terminal: options.terminal,
+      provider,
+      cwd,
+      parentSessionId: sessionId,
+      permissionMode: options.permissionMode,
+      permissionHandler: options.permissionHandler,
+      hooks: options.config.hooks,
+      hookTypeExecutors: hookTypeExecutors.length > 0 ? hookTypeExecutors : void 0,
+      onTextDelta: options.onTextDelta,
+      onToolExecution: options.onToolExecution,
+      customAgentRegistry: (name) => agentLoader.getAgent(name),
+      agentDefinitions
+    };
+    const subagentManager = new SubagentManager2({
+      runner: (options.subagentRunnerFactory ?? createInProcessSubagentRunner)(agentToolDeps),
+      backgroundTaskRunners: options.backgroundTaskRunners
+    });
+    agentToolDeps.subagentManager = subagentManager;
+    backgroundTaskManager = subagentManager.getBackgroundTaskManager();
+    agentToolDeps.backgroundTaskManager = backgroundTaskManager;
+  } else {
+    backgroundTaskManager = new BackgroundTaskManager2({
+      runners: options.backgroundTaskRunners ?? []
+    });
+  }
+  const sessionLogger = options.sessionLogger;
+  if (backgroundTaskManager && sessionLogger) {
+    backgroundTaskManager.subscribe(
+      (event) => logBackgroundTaskEvent(sessionLogger, sessionId, event)
+    );
+  }
+  if (backgroundTaskManager) {
+    backgroundTaskManager.subscribe(
+      (event) => fireSubagentLifecycleHook(
+        event,
+        cwd,
+        options.config.hooks,
+        hookTypeExecutors.length > 0 ? hookTypeExecutors : void 0
+      )
+    );
+  }
+  let backgroundProcessToolDeps;
+  if (backgroundTaskManager && options.backgroundTaskRunners?.some((runner) => runner.kind === "process")) {
+    backgroundProcessToolDeps = {
+      backgroundTaskManager,
+      cwd,
+      parentSessionId: sessionId
+    };
+    tools.push(createBackgroundProcessTool(backgroundProcessToolDeps));
+  }
+  if (agentToolDeps) {
+    tools.push(createAgentTool(agentToolDeps));
+  }
   const buildPrompt = options.systemPromptBuilder ?? buildSystemPrompt;
+  const defaultToolDescriptions = [
+    ...DEFAULT_TOOL_DESCRIPTIONS,
+    ...agentToolDeps ? [createAgentToolPromptDescription(agentDefinitions)] : [],
+    ...options.modelCommandExecutor ? ["ExecuteCommand \u2014 execute model-invocable Robota commands"] : []
+  ];
   const systemMessage = buildPrompt({
     agentsMd: options.context.agentsMd,
     claudeMd: options.context.claudeMd,
-    toolDescriptions: options.toolDescriptions ?? DEFAULT_TOOL_DESCRIPTIONS,
+    toolDescriptions: options.toolDescriptions ?? (backgroundProcessToolDeps ? [
+      ...defaultToolDescriptions,
+      "BackgroundProcess \u2014 start long-running shell commands as managed background tasks"
+    ] : defaultToolDescriptions),
     trustLevel: options.config.defaultTrustLevel,
     projectInfo: options.projectInfo ?? { type: "unknown", language: "unknown" },
-    cwd: process.cwd(),
-    language: options.config.language
+    cwd,
+    language: options.config.language,
+    skills: new SkillCommandSource(cwd).getModelInvocableSkills().map((skill) => ({
+      name: skill.name,
+      description: skill.description,
+      disableModelInvocation: skill.disableModelInvocation
+    })),
+    ...agentDefinitions.length > 0 ? {
+      agents: agentDefinitions.map((agent) => ({
+        name: agent.name,
+        description: agent.description
+      }))
+    } : {},
+    commandDescriptors: options.commandDescriptors ?? []
   });
+  const finalSystemMessage = options.appendSystemPrompt ? `${systemMessage}
+
+${options.appendSystemPrompt}` : systemMessage;
   const defaultAllow = [
     "Read(.agents/**)",
     "Read(.claude/**)",
@@ -1019,23 +2165,25 @@ function createSession(options) {
     "Glob(.claude/**)",
     "Glob(.robota/**)"
   ];
+  const allowedToolPatterns = (options.allowedTools ?? []).map((name) => `${name}(*)`);
   const mergedPermissions = {
-    allow: [...defaultAllow, ...options.config.permissions.allow ?? []],
+    allow: [...defaultAllow, ...options.config.permissions.allow ?? [], ...allowedToolPatterns],
     deny: options.config.permissions.deny ?? []
   };
   const session = new Session2({
     tools,
     provider,
-    systemMessage,
+    systemMessage: finalSystemMessage,
     terminal: options.terminal,
     permissions: mergedPermissions,
     hooks: options.config.hooks,
     permissionMode: options.permissionMode,
     defaultTrustLevel: options.config.defaultTrustLevel,
     model: options.config.provider.model,
+    providerTimeout: options.config.provider.timeout ?? DEFAULT_PROVIDER_IDLE_TIMEOUT_MS,
     maxTurns: options.maxTurns,
     sessionStore: options.sessionStore,
-    sessionId: options.sessionId,
+    sessionId,
     permissionHandler: options.permissionHandler,
     onTextDelta: options.onTextDelta,
     onToolExecution: options.onToolExecution,
@@ -1045,122 +2193,153 @@ function createSession(options) {
     sessionLogger: options.sessionLogger,
     hookTypeExecutors: hookTypeExecutors.length > 0 ? hookTypeExecutors : void 0
   });
-  storeAgentToolDeps(session, agentToolDeps);
+  if (agentToolDeps) agentToolDeps.parentSessionId = session.getSessionId();
+  if (backgroundProcessToolDeps) backgroundProcessToolDeps.parentSessionId = session.getSessionId();
+  if (backgroundTaskManager) storeSessionBackgroundTaskManager(session, backgroundTaskManager);
+  if (agentToolDeps) storeAgentToolDeps(session, agentToolDeps);
   return session;
 }
+function createSessionId() {
+  return `session_${Date.now()}_${Math.random().toString(ID_RADIX).substr(2, ID_RANDOM_LENGTH)}`;
+}
+function logBackgroundTaskEvent(logger, sessionId, event) {
+  logger.log(sessionId, "background_task_event", {
+    backgroundEventType: event.type,
+    backgroundEvent: event
+  });
+}
 
 // src/assembly/subagent-logger.ts
 import { mkdirSync } from "fs";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { FileSessionLogger } from "@robota-sdk/agent-sessions";
 function createSubagentLogger(parentSessionId, _agentId, baseLogsDir) {
-  const subagentDir = join2(baseLogsDir, parentSessionId, "subagents");
+  const subagentDir = join3(baseLogsDir, parentSessionId, "subagents");
   mkdirSync(subagentDir, { recursive: true });
   return new FileSessionLogger(subagentDir);
 }
 function resolveSubagentLogDir(parentSessionId, baseLogsDir) {
-  return join2(baseLogsDir, parentSessionId, "subagents");
+  return join3(baseLogsDir, parentSessionId, "subagents");
 }
 
 // src/interactive/interactive-session-init.ts
 import { FileSessionLogger as FileSessionLogger2 } from "@robota-sdk/agent-sessions";
 
 // src/paths.ts
-import { join as join3 } from "path";
-import { homedir as homedir2 } from "os";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
 function projectPaths(cwd) {
-  const base = join3(cwd, ".robota");
+  const base = join4(cwd, ".robota");
   return {
-    settings: join3(base, "settings.json"),
-    settingsLocal: join3(base, "settings.local.json"),
-    logs: join3(base, "logs"),
-    sessions: join3(base, "sessions")
+    settings: join4(base, "settings.json"),
+    settingsLocal: join4(base, "settings.local.json"),
+    logs: join4(base, "logs"),
+    sessions: join4(base, "sessions")
   };
 }
 function userPaths() {
-  const base = join3(homedir2(), ".robota");
+  const base = join4(homedir3(), ".robota");
   return {
-    settings: join3(base, "settings.json"),
-    sessions: join3(base, "sessions")
+    settings: join4(base, "settings.json"),
+    sessions: join4(base, "sessions")
   };
 }
 
 // src/config/config-loader.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+import { join as join5 } from "path";
 
 // src/config/config-types.ts
-import { z as z2 } from "zod";
-var ProviderSchema = z2.object({
-  name: z2.string().optional(),
-  model: z2.string().optional(),
-  apiKey: z2.string().optional()
+import { z as z4 } from "zod";
+var ProviderSchema = z4.object({
+  name: z4.string().optional(),
+  model: z4.string().optional(),
+  apiKey: z4.string().optional(),
+  baseURL: z4.string().optional(),
+  timeout: z4.number().optional()
 });
-var PermissionsSchema = z2.object({
+var ProviderProfileSchema = z4.object({
+  type: z4.string().optional(),
+  model: z4.string().optional(),
+  apiKey: z4.string().optional(),
+  baseURL: z4.string().optional(),
+  timeout: z4.number().optional()
+});
+var PermissionsSchema = z4.object({
   /** Patterns that are always approved without prompting */
-  allow: z2.array(z2.string()).optional(),
+  allow: z4.array(z4.string()).optional(),
   /** Patterns that are always denied */
-  deny: z2.array(z2.string()).optional()
+  deny: z4.array(z4.string()).optional()
 });
-var EnvSchema = z2.record(z2.string()).optional();
-var CommandHookDefinitionSchema = z2.object({
-  type: z2.literal("command"),
-  command: z2.string(),
-  timeout: z2.number().optional()
+var EnvSchema = z4.record(z4.string()).optional();
+var CommandHookDefinitionSchema = z4.object({
+  type: z4.literal("command"),
+  command: z4.string(),
+  timeout: z4.number().optional()
 });
-var HttpHookDefinitionSchema = z2.object({
-  type: z2.literal("http"),
-  url: z2.string(),
-  headers: z2.record(z2.string()).optional(),
-  timeout: z2.number().optional()
+var HttpHookDefinitionSchema = z4.object({
+  type: z4.literal("http"),
+  url: z4.string(),
+  headers: z4.record(z4.string()).optional(),
+  timeout: z4.number().optional()
 });
-var PromptHookDefinitionSchema = z2.object({
-  type: z2.literal("prompt"),
-  prompt: z2.string(),
-  model: z2.string().optional()
+var PromptHookDefinitionSchema = z4.object({
+  type: z4.literal("prompt"),
+  prompt: z4.string(),
+  model: z4.string().optional()
 });
-var AgentHookDefinitionSchema = z2.object({
-  type: z2.literal("agent"),
-  agent: z2.string(),
-  maxTurns: z2.number().optional(),
-  timeout: z2.number().optional()
+var AgentHookDefinitionSchema = z4.object({
+  type: z4.literal("agent"),
+  agent: z4.string(),
+  maxTurns: z4.number().optional(),
+  timeout: z4.number().optional()
 });
-var HookDefinitionSchema = z2.discriminatedUnion("type", [
+var HookDefinitionSchema = z4.discriminatedUnion("type", [
   CommandHookDefinitionSchema,
   HttpHookDefinitionSchema,
   PromptHookDefinitionSchema,
   AgentHookDefinitionSchema
 ]);
-var HookGroupSchema = z2.object({
-  matcher: z2.string(),
-  hooks: z2.array(HookDefinitionSchema)
+var HookGroupSchema = z4.object({
+  matcher: z4.string(),
+  hooks: z4.array(HookDefinitionSchema)
 });
-var HooksSchema = z2.object({
-  PreToolUse: z2.array(HookGroupSchema).optional(),
-  PostToolUse: z2.array(HookGroupSchema).optional(),
-  SessionStart: z2.array(HookGroupSchema).optional(),
-  Stop: z2.array(HookGroupSchema).optional(),
-  PreCompact: z2.array(HookGroupSchema).optional(),
-  PostCompact: z2.array(HookGroupSchema).optional(),
-  UserPromptSubmit: z2.array(HookGroupSchema).optional(),
-  Notification: z2.array(HookGroupSchema).optional()
+var HooksSchema = z4.object({
+  PreToolUse: z4.array(HookGroupSchema).optional(),
+  PostToolUse: z4.array(HookGroupSchema).optional(),
+  SessionStart: z4.array(HookGroupSchema).optional(),
+  SessionEnd: z4.array(HookGroupSchema).optional(),
+  Stop: z4.array(HookGroupSchema).optional(),
+  StopFailure: z4.array(HookGroupSchema).optional(),
+  PreCompact: z4.array(HookGroupSchema).optional(),
+  PostCompact: z4.array(HookGroupSchema).optional(),
+  UserPromptSubmit: z4.array(HookGroupSchema).optional(),
+  SubagentStart: z4.array(HookGroupSchema).optional(),
+  SubagentStop: z4.array(HookGroupSchema).optional(),
+  WorktreeCreate: z4.array(HookGroupSchema).optional(),
+  WorktreeRemove: z4.array(HookGroupSchema).optional()
 }).optional();
-var EnabledPluginsSchema = z2.record(z2.boolean()).optional();
-var MarketplaceSourceSchema = z2.object({
-  source: z2.object({
-    type: z2.enum(["github", "git", "local", "url"]),
-    repo: z2.string().optional(),
-    url: z2.string().optional(),
-    path: z2.string().optional(),
-    ref: z2.string().optional()
+var EnabledPluginsSchema = z4.record(z4.boolean()).optional();
+var MarketplaceSourceSchema = z4.object({
+  source: z4.object({
+    type: z4.enum(["github", "git", "local", "url"]),
+    repo: z4.string().optional(),
+    url: z4.string().optional(),
+    path: z4.string().optional(),
+    ref: z4.string().optional()
   })
 });
-var ExtraKnownMarketplacesSchema = z2.record(MarketplaceSourceSchema).optional();
-var SettingsSchema = z2.object({
+var ExtraKnownMarketplacesSchema = z4.record(MarketplaceSourceSchema).optional().catch(void 0);
+var SettingsSchema = z4.object({
   /** Trust level used when no --permission-mode flag is given */
-  defaultTrustLevel: z2.enum(["safe", "moderate", "full"]).optional(),
+  defaultTrustLevel: z4.enum(["safe", "moderate", "full"]).optional(),
   /** Response language (e.g., "ko", "en", "ja"). Injected into system prompt. */
-  language: z2.string().optional(),
+  language: z4.string().optional(),
+  /** Active provider profile key from providers. */
+  currentProvider: z4.string().optional(),
+  /** Provider profiles keyed by user-facing profile name. */
+  providers: z4.record(ProviderProfileSchema).optional(),
+  /** Legacy single-provider settings. Prefer currentProvider + providers for new config. */
   provider: ProviderSchema.optional(),
   permissions: PermissionsSchema.optional(),
   env: EnvSchema,
@@ -1189,10 +2368,10 @@ var DEFAULTS = {
   env: {}
 };
 function readJsonFile(filePath) {
-  if (!existsSync2(filePath)) {
+  if (!existsSync3(filePath)) {
     return void 0;
   }
-  const raw = readFileSync2(filePath, "utf-8").trim();
+  const raw = readFileSync3(filePath, "utf-8").trim();
   if (raw.length === 0) {
     return void 0;
   }
@@ -1211,16 +2390,30 @@ function resolveEnvRef(value) {
   return value;
 }
 function resolveEnvRefs(settings) {
-  if (settings.provider?.apiKey !== void 0) {
+  const provider = settings.provider?.apiKey !== void 0 ? {
+    ...settings.provider,
+    apiKey: resolveEnvRef(settings.provider.apiKey)
+  } : settings.provider;
+  if (settings.providers !== void 0) {
+    const providers = Object.fromEntries(
+      Object.entries(settings.providers).map(([name, profile]) => [
+        name,
+        {
+          ...profile,
+          ...profile.apiKey !== void 0 && { apiKey: resolveEnvRef(profile.apiKey) }
+        }
+      ])
+    );
     return {
       ...settings,
-      provider: {
-        ...settings.provider,
-        apiKey: resolveEnvRef(settings.provider.apiKey)
-      }
+      provider,
+      providers
     };
   }
-  return settings;
+  return {
+    ...settings,
+    provider
+  };
 }
 function mergeSettings(layers) {
   return layers.reduce((merged, layer) => {
@@ -1236,20 +2429,53 @@ function mergeSettings(layers) {
         ...merged.env ?? {},
         ...layer.env ?? {}
       },
+      providers: merged.providers !== void 0 || layer.providers !== void 0 ? mergeProviders(merged.providers, layer.providers) : void 0,
       enabledPlugins: merged.enabledPlugins !== void 0 || layer.enabledPlugins !== void 0 ? { ...merged.enabledPlugins ?? {}, ...layer.enabledPlugins ?? {} } : void 0,
       extraKnownMarketplaces: layer.extraKnownMarketplaces ?? merged.extraKnownMarketplaces
     };
   }, {});
 }
+function mergeProviders(base, override) {
+  const result = { ...base ?? {} };
+  for (const [name, profile] of Object.entries(override ?? {})) {
+    result[name] = {
+      ...result[name],
+      ...profile
+    };
+  }
+  return result;
+}
+function resolveProvider(merged) {
+  if (merged.currentProvider !== void 0) {
+    const profile = merged.providers?.[merged.currentProvider];
+    if (profile === void 0) {
+      throw new Error(`currentProvider "${merged.currentProvider}" was not found in providers`);
+    }
+    if (profile.type === void 0) {
+      throw new Error(`Provider profile "${merged.currentProvider}" is missing type`);
+    }
+    return {
+      name: profile.type,
+      model: profile.model ?? DEFAULTS.provider.model,
+      apiKey: profile.apiKey ?? DEFAULTS.provider.apiKey,
+      ...profile.baseURL !== void 0 && { baseURL: profile.baseURL },
+      ...profile.timeout !== void 0 && { timeout: profile.timeout }
+    };
+  }
+  return {
+    name: merged.provider?.name ?? DEFAULTS.provider.name,
+    model: merged.provider?.model ?? DEFAULTS.provider.model,
+    apiKey: merged.provider?.apiKey ?? DEFAULTS.provider.apiKey,
+    ...merged.provider?.baseURL !== void 0 && { baseURL: merged.provider.baseURL },
+    ...merged.provider?.timeout !== void 0 && { timeout: merged.provider.timeout }
+  };
+}
 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,
-      apiKey: merged.provider?.apiKey ?? DEFAULTS.provider.apiKey
-    },
+    currentProvider: merged.currentProvider,
+    provider: resolveProvider(merged),
     permissions: {
       allow: merged.permissions?.allow ?? DEFAULTS.permissions.allow,
       deny: merged.permissions?.deny ?? DEFAULTS.permissions.deny
@@ -1263,15 +2489,17 @@ function toResolvedConfig(merged) {
 function getSettingsPaths(cwd) {
   const home = getHomeDir();
   return [
-    join4(home, ".robota", "settings.json"),
+    join5(home, ".robota", "settings.json"),
     // 1. user (lowest)
-    join4(cwd, ".robota", "settings.json"),
+    join5(home, ".claude", "settings.json"),
+    // 1b. user (Claude Code compat)
+    join5(cwd, ".robota", "settings.json"),
     // 2. project
-    join4(cwd, ".robota", "settings.local.json"),
+    join5(cwd, ".robota", "settings.local.json"),
     // 3. project-local
-    join4(cwd, ".claude", "settings.json"),
+    join5(cwd, ".claude", "settings.json"),
     // 4. project, Claude Code compat
-    join4(cwd, ".claude", "settings.local.json")
+    join5(cwd, ".claude", "settings.local.json")
     // 5. project-local (highest)
   ];
 }
@@ -1296,8 +2524,8 @@ async function loadConfig(cwd) {
 }
 
 // src/context/context-loader.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { join as join5, dirname, resolve } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
+import { join as join6, dirname, resolve } from "path";
 var AGENTS_FILENAME = "AGENTS.md";
 var CLAUDE_FILENAME = "CLAUDE.md";
 function collectFilesWalkingUp(startDir, filename) {
@@ -1305,8 +2533,8 @@ function collectFilesWalkingUp(startDir, filename) {
   let current = resolve(startDir);
   let atRoot = false;
   while (!atRoot) {
-    const candidate = join5(current, filename);
-    if (existsSync3(candidate)) {
+    const candidate = join6(current, filename);
+    if (existsSync4(candidate)) {
       found.push(candidate);
     }
     const parent = dirname(current);
@@ -1344,47 +2572,47 @@ function extractCompactInstructions(content) {
 async function loadContext(cwd) {
   const agentsPaths = collectFilesWalkingUp(cwd, AGENTS_FILENAME);
   const claudePaths = collectFilesWalkingUp(cwd, CLAUDE_FILENAME);
-  const agentsMd = agentsPaths.map((p) => readFileSync3(p, "utf-8")).join("\n\n");
-  const claudeMd = claudePaths.map((p) => readFileSync3(p, "utf-8")).join("\n\n");
+  const agentsMd = agentsPaths.map((p) => readFileSync4(p, "utf-8")).join("\n\n");
+  const claudeMd = claudePaths.map((p) => readFileSync4(p, "utf-8")).join("\n\n");
   const compactInstructions = extractCompactInstructions(claudeMd);
   return { agentsMd, claudeMd, compactInstructions };
 }
 
 // src/context/project-detector.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync5 } from "fs";
+import { join as join7 } from "path";
 function tryReadJson(filePath) {
-  if (!existsSync4(filePath)) return void 0;
+  if (!existsSync5(filePath)) return void 0;
   try {
-    return JSON.parse(readFileSync4(filePath, "utf-8"));
+    return JSON.parse(readFileSync5(filePath, "utf-8"));
   } catch {
     return void 0;
   }
 }
 function detectPackageManager(cwd) {
-  if (existsSync4(join6(cwd, "pnpm-workspace.yaml")) || existsSync4(join6(cwd, "pnpm-lock.yaml"))) {
+  if (existsSync5(join7(cwd, "pnpm-workspace.yaml")) || existsSync5(join7(cwd, "pnpm-lock.yaml"))) {
     return "pnpm";
   }
-  if (existsSync4(join6(cwd, "yarn.lock"))) {
+  if (existsSync5(join7(cwd, "yarn.lock"))) {
     return "yarn";
   }
-  if (existsSync4(join6(cwd, "bun.lockb"))) {
+  if (existsSync5(join7(cwd, "bun.lockb"))) {
     return "bun";
   }
-  if (existsSync4(join6(cwd, "package-lock.json"))) {
+  if (existsSync5(join7(cwd, "package-lock.json"))) {
     return "npm";
   }
   return void 0;
 }
 async function detectProject(cwd) {
-  const pkgJsonPath = join6(cwd, "package.json");
-  const tsconfigPath = join6(cwd, "tsconfig.json");
-  const pyprojectPath = join6(cwd, "pyproject.toml");
-  const cargoPath = join6(cwd, "Cargo.toml");
-  const goModPath = join6(cwd, "go.mod");
-  if (existsSync4(pkgJsonPath)) {
+  const pkgJsonPath = join7(cwd, "package.json");
+  const tsconfigPath = join7(cwd, "tsconfig.json");
+  const pyprojectPath = join7(cwd, "pyproject.toml");
+  const cargoPath = join7(cwd, "Cargo.toml");
+  const goModPath = join7(cwd, "go.mod");
+  if (existsSync5(pkgJsonPath)) {
     const pkgJson = tryReadJson(pkgJsonPath);
-    const language = existsSync4(tsconfigPath) ? "typescript" : "javascript";
+    const language = existsSync5(tsconfigPath) ? "typescript" : "javascript";
     const packageManager = detectPackageManager(cwd);
     return {
       type: "node",
@@ -1393,19 +2621,19 @@ async function detectProject(cwd) {
       language
     };
   }
-  if (existsSync4(pyprojectPath) || existsSync4(join6(cwd, "setup.py"))) {
+  if (existsSync5(pyprojectPath) || existsSync5(join7(cwd, "setup.py"))) {
     return {
       type: "python",
       language: "python"
     };
   }
-  if (existsSync4(cargoPath)) {
+  if (existsSync5(cargoPath)) {
     return {
       type: "rust",
       language: "rust"
     };
   }
-  if (existsSync4(goModPath)) {
+  if (existsSync5(goModPath)) {
     return {
       type: "go",
       language: "go"
@@ -1418,7 +2646,7 @@ async function detectProject(cwd) {
 }
 
 // src/plugins/plugin-settings-store.ts
-import { existsSync as existsSync5, readFileSync as readFileSync5, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync6, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
 import { dirname as dirname2 } from "path";
 var PluginSettingsStore = class {
   settingsPath;
@@ -1427,11 +2655,11 @@ var PluginSettingsStore = class {
   }
   /** Read the full settings file from disk. */
   readAll() {
-    if (!existsSync5(this.settingsPath)) {
+    if (!existsSync6(this.settingsPath)) {
       return {};
     }
     try {
-      const raw = readFileSync5(this.settingsPath, "utf-8");
+      const raw = readFileSync6(this.settingsPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data === "object" && data !== null) {
         return data;
@@ -1444,7 +2672,7 @@ var PluginSettingsStore = class {
   /** Write the full settings file to disk. */
   writeAll(settings) {
     const dir = dirname2(this.settingsPath);
-    if (!existsSync5(dir)) {
+    if (!existsSync6(dir)) {
       mkdirSync2(dir, { recursive: true });
     }
     writeFileSync(this.settingsPath, JSON.stringify(settings, null, 2), "utf-8");
@@ -1519,11 +2747,11 @@ var PluginSettingsStore = class {
 };
 
 // src/plugins/bundle-plugin-loader.ts
-import { existsSync as existsSync7, readdirSync as readdirSync3, readFileSync as readFileSync6 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync7 } from "fs";
+import { join as join8 } from "path";
 
 // src/plugins/bundle-plugin-utils.ts
-import { existsSync as existsSync6, readdirSync as readdirSync2 } from "fs";
+import { existsSync as existsSync7, readdirSync as readdirSync3 } from "fs";
 function parseSkillFrontmatter(raw) {
   const trimmed = raw.trimStart();
   if (!trimmed.startsWith("---")) {
@@ -1572,9 +2800,9 @@ function validateManifest(data) {
   };
 }
 function getSortedSubdirs(dirPath) {
-  if (!existsSync6(dirPath)) return [];
+  if (!existsSync7(dirPath)) return [];
   try {
-    const entries = readdirSync2(dirPath, { withFileTypes: true });
+    const entries = readdirSync3(dirPath, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort();
   } catch {
     return [];
@@ -1604,23 +2832,23 @@ var BundlePluginLoader = class {
    * For each marketplace/plugin pair, the latest version (lexicographically last) is loaded.
    */
   discoverAndLoad() {
-    const cacheDir = join7(this.pluginsDir, "cache");
-    if (!existsSync7(cacheDir)) {
+    const cacheDir = join8(this.pluginsDir, "cache");
+    if (!existsSync8(cacheDir)) {
       return [];
     }
     const results = [];
     const marketplaces = getSortedSubdirs(cacheDir);
     for (const marketplace of marketplaces) {
-      const marketplaceDir = join7(cacheDir, marketplace);
+      const marketplaceDir = join8(cacheDir, marketplace);
       const plugins = getSortedSubdirs(marketplaceDir);
       for (const pluginName of plugins) {
-        const pluginDir = join7(marketplaceDir, pluginName);
+        const pluginDir = join8(marketplaceDir, pluginName);
         const versions = getSortedSubdirs(pluginDir);
         if (versions.length === 0) continue;
         const latestVersion = versions[versions.length - 1];
-        const versionDir = join7(pluginDir, latestVersion);
-        const manifestPath = join7(versionDir, ".claude-plugin", "plugin.json");
-        if (!existsSync7(manifestPath)) continue;
+        const versionDir = join8(pluginDir, latestVersion);
+        const manifestPath = join8(versionDir, ".claude-plugin", "plugin.json");
+        if (!existsSync8(manifestPath)) continue;
         const manifest = this.readManifest(manifestPath);
         if (!manifest) continue;
         const pluginId = `${manifest.name}@${marketplace}`;
@@ -1634,7 +2862,7 @@ var BundlePluginLoader = class {
   /** Read and validate a plugin.json manifest. Returns null on failure. */
   readManifest(path) {
     try {
-      const raw = readFileSync6(path, "utf-8");
+      const raw = readFileSync7(path, "utf-8");
       const data = JSON.parse(raw);
       return validateManifest(data);
     } catch {
@@ -1669,15 +2897,15 @@ var BundlePluginLoader = class {
   }
   /** Load skills from the plugin's skills/ directory. */
   loadSkills(pluginDir, pluginName) {
-    const skillsDir = join7(pluginDir, "skills");
-    if (!existsSync7(skillsDir)) return [];
-    const entries = readdirSync3(skillsDir, { withFileTypes: true });
+    const skillsDir = join8(pluginDir, "skills");
+    if (!existsSync8(skillsDir)) return [];
+    const entries = readdirSync4(skillsDir, { withFileTypes: true });
     const skills = [];
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const skillFile = join7(skillsDir, entry.name, "SKILL.md");
-      if (!existsSync7(skillFile)) continue;
-      const raw = readFileSync6(skillFile, "utf-8");
+      const skillFile = join8(skillsDir, entry.name, "SKILL.md");
+      if (!existsSync8(skillFile)) continue;
+      const raw = readFileSync7(skillFile, "utf-8");
       const { metadata, content } = parseSkillFrontmatter(raw);
       const description = typeof metadata.description === "string" ? metadata.description : "";
       const skill = {
@@ -1692,13 +2920,13 @@ var BundlePluginLoader = class {
   }
   /** Load commands from the plugin's commands/ directory (flat .md files). */
   loadCommands(pluginDir, pluginName) {
-    const commandsDir = join7(pluginDir, "commands");
-    if (!existsSync7(commandsDir)) return [];
-    const entries = readdirSync3(commandsDir, { withFileTypes: true });
+    const commandsDir = join8(pluginDir, "commands");
+    if (!existsSync8(commandsDir)) return [];
+    const entries = readdirSync4(commandsDir, { withFileTypes: true });
     const commands = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-      const raw = readFileSync6(join7(commandsDir, entry.name), "utf-8");
+      const raw = readFileSync7(join8(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 : "";
@@ -1713,10 +2941,10 @@ var BundlePluginLoader = class {
   }
   /** Load hooks from hooks/hooks.json if present. */
   loadHooks(pluginDir) {
-    const hooksPath = join7(pluginDir, "hooks", "hooks.json");
-    if (!existsSync7(hooksPath)) return {};
+    const hooksPath = join8(pluginDir, "hooks", "hooks.json");
+    if (!existsSync8(hooksPath)) return {};
     try {
-      const raw = readFileSync6(hooksPath, "utf-8");
+      const raw = readFileSync7(hooksPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data === "object" && data !== null) {
         return data;
@@ -1728,12 +2956,12 @@ var BundlePluginLoader = class {
   }
   /** Load MCP server configuration if present. Checks `.mcp.json` at plugin root first. */
   loadMcpConfig(pluginDir) {
-    const primaryPath = join7(pluginDir, ".mcp.json");
-    const fallbackPath = join7(pluginDir, ".claude-plugin", "mcp.json");
-    const mcpPath = existsSync7(primaryPath) ? primaryPath : fallbackPath;
-    if (!existsSync7(mcpPath)) return void 0;
+    const primaryPath = join8(pluginDir, ".mcp.json");
+    const fallbackPath = join8(pluginDir, ".claude-plugin", "mcp.json");
+    const mcpPath = existsSync8(primaryPath) ? primaryPath : fallbackPath;
+    if (!existsSync8(mcpPath)) return void 0;
     try {
-      const raw = readFileSync6(mcpPath, "utf-8");
+      const raw = readFileSync7(mcpPath, "utf-8");
       return JSON.parse(raw);
     } catch {
       return void 0;
@@ -1741,10 +2969,10 @@ var BundlePluginLoader = class {
   }
   /** Load agent definitions from agents/ directory if present. */
   loadAgents(pluginDir) {
-    const agentsDir = join7(pluginDir, "agents");
-    if (!existsSync7(agentsDir)) return [];
+    const agentsDir = join8(pluginDir, "agents");
+    if (!existsSync8(agentsDir)) return [];
     try {
-      const entries = readdirSync3(agentsDir, { withFileTypes: true });
+      const entries = readdirSync4(agentsDir, { withFileTypes: true });
       return entries.filter((e) => e.isDirectory() || e.name.endsWith(".md")).map((e) => e.name.replace(/\.md$/, ""));
     } catch {
       return [];
@@ -1753,9 +2981,9 @@ var BundlePluginLoader = class {
 };
 
 // src/plugins/bundle-plugin-installer.ts
-import { execSync } from "child_process";
-import { cpSync, existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync7, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join8, dirname as dirname3 } from "path";
+import { execSync as execSync2 } from "child_process";
+import { cpSync, existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync8, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join9, dirname as dirname3 } from "path";
 var GIT_CLONE_TIMEOUT_MS = 6e4;
 var BundlePluginInstaller = class {
   pluginsDir;
@@ -1766,8 +2994,8 @@ var BundlePluginInstaller = class {
   exec;
   constructor(options) {
     this.pluginsDir = options.pluginsDir;
-    this.cacheDir = join8(this.pluginsDir, "cache");
-    this.registryPath = join8(this.pluginsDir, "installed_plugins.json");
+    this.cacheDir = join9(this.pluginsDir, "cache");
+    this.registryPath = join9(this.pluginsDir, "installed_plugins.json");
     this.settingsStore = options.settingsStore;
     this.marketplaceClient = options.marketplaceClient;
     this.exec = options.exec ?? this.defaultExec;
@@ -1787,8 +3015,8 @@ var BundlePluginInstaller = class {
       throw new Error(`Plugin "${pluginName}" not found in marketplace "${marketplaceName}"`);
     }
     const version = this.resolveVersion(entry, marketplaceName);
-    const targetDir = join8(this.cacheDir, marketplaceName, pluginName, version);
-    if (existsSync8(targetDir)) {
+    const targetDir = join9(this.cacheDir, marketplaceName, pluginName, version);
+    if (existsSync9(targetDir)) {
       throw new Error(
         `Plugin "${pluginName}" version "${version}" is already installed from "${marketplaceName}"`
       );
@@ -1815,7 +3043,7 @@ var BundlePluginInstaller = class {
     if (!record) {
       throw new Error(`Plugin "${pluginId}" is not installed`);
     }
-    if (existsSync8(record.installPath)) {
+    if (existsSync9(record.installPath)) {
       rmSync(record.installPath, { recursive: true, force: true });
     }
     delete registry[pluginId];
@@ -1867,8 +3095,8 @@ var BundlePluginInstaller = class {
     try {
       if (typeof source === "string") {
         const marketplaceDir = this.marketplaceClient.getMarketplaceDir(marketplaceName);
-        const sourcePath = join8(marketplaceDir, source);
-        if (!existsSync8(sourcePath)) {
+        const sourcePath = join9(marketplaceDir, source);
+        if (!existsSync9(sourcePath)) {
           throw new Error(
             `Plugin source path "${source}" not found in marketplace "${marketplaceName}"`
           );
@@ -1885,7 +3113,7 @@ var BundlePluginInstaller = class {
         throw new Error(`Unknown source type: ${JSON.stringify(source)}`);
       }
     } catch (err) {
-      if (existsSync8(targetDir)) {
+      if (existsSync9(targetDir)) {
         rmSync(targetDir, { recursive: true, force: true });
       }
       throw err;
@@ -1904,11 +3132,11 @@ var BundlePluginInstaller = class {
   }
   /** Read the installed_plugins.json registry. */
   readRegistry() {
-    if (!existsSync8(this.registryPath)) {
+    if (!existsSync9(this.registryPath)) {
       return {};
     }
     try {
-      const raw = readFileSync7(this.registryPath, "utf-8");
+      const raw = readFileSync8(this.registryPath, "utf-8");
       const data = JSON.parse(raw);
       if (typeof data === "object" && data !== null) {
         return data;
@@ -1921,31 +3149,31 @@ var BundlePluginInstaller = class {
   /** Write the installed_plugins.json registry. */
   writeRegistry(registry) {
     const dir = dirname3(this.registryPath);
-    if (!existsSync8(dir)) {
+    if (!existsSync9(dir)) {
       mkdirSync3(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" });
+    return execSync2(command, { timeout: options.timeout, stdio: "pipe" });
   }
 };
 
 // src/plugins/marketplace-client.ts
-import { execSync as execSync2 } from "child_process";
-import { cpSync as cpSync2, existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync9, renameSync, rmSync as rmSync3 } from "fs";
-import { join as join10 } from "path";
+import { execSync as execSync3 } from "child_process";
+import { cpSync as cpSync2, existsSync as existsSync11, mkdirSync as mkdirSync5, readFileSync as readFileSync10, renameSync, rmSync as rmSync3 } from "fs";
+import { join as join11 } from "path";
 
 // src/plugins/marketplace-registry.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync8, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
-import { join as join9, dirname as dirname4 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync9, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join10, dirname as dirname4 } from "path";
 function readRegistry(registryPath) {
-  if (!existsSync9(registryPath)) {
+  if (!existsSync10(registryPath)) {
     return {};
   }
   try {
-    const raw = readFileSync8(registryPath, "utf-8");
+    const raw = readFileSync9(registryPath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data === "object" && data !== null) {
       return data;
@@ -1957,17 +3185,17 @@ function readRegistry(registryPath) {
 }
 function writeRegistry(registryPath, registry) {
   const dir = dirname4(registryPath);
-  if (!existsSync9(dir)) {
+  if (!existsSync10(dir)) {
     mkdirSync4(dir, { recursive: true });
   }
   writeFileSync3(registryPath, JSON.stringify(registry, null, 2), "utf-8");
 }
 function removeInstalledPluginsForMarketplace(pluginsDir, marketplaceName) {
-  const installedPath = join9(pluginsDir, "installed_plugins.json");
-  if (!existsSync9(installedPath)) return;
+  const installedPath = join10(pluginsDir, "installed_plugins.json");
+  if (!existsSync10(installedPath)) return;
   let registry;
   try {
-    const raw = readFileSync8(installedPath, "utf-8");
+    const raw = readFileSync9(installedPath, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data !== "object" || data === null) return;
     registry = data;
@@ -1977,7 +3205,7 @@ function removeInstalledPluginsForMarketplace(pluginsDir, marketplaceName) {
   let changed = false;
   for (const [pluginId, record] of Object.entries(registry)) {
     if (record.marketplace === marketplaceName) {
-      if (record.installPath && existsSync9(record.installPath)) {
+      if (record.installPath && existsSync10(record.installPath)) {
         rmSync2(record.installPath, { recursive: true, force: true });
       }
       delete registry[pluginId];
@@ -1986,7 +3214,7 @@ function removeInstalledPluginsForMarketplace(pluginsDir, marketplaceName) {
   }
   if (changed) {
     const dir = dirname4(installedPath);
-    if (!existsSync9(dir)) {
+    if (!existsSync10(dir)) {
       mkdirSync4(dir, { recursive: true });
     }
     writeFileSync3(installedPath, JSON.stringify(registry, null, 2), "utf-8");
@@ -2003,8 +3231,8 @@ var MarketplaceClient = class {
   constructor(options) {
     this.pluginsDir = options.pluginsDir;
     this.exec = options.exec ?? this.defaultExec;
-    this.marketplacesDir = join10(this.pluginsDir, "marketplaces");
-    this.registryPath = join10(this.pluginsDir, "known_marketplaces.json");
+    this.marketplacesDir = join11(this.pluginsDir, "marketplaces");
+    this.registryPath = join11(this.pluginsDir, "known_marketplaces.json");
   }
   /**
    * Add a marketplace by cloning its repository.
@@ -2017,10 +3245,10 @@ var MarketplaceClient = class {
    */
   addMarketplace(source) {
     const tempName = "temp-" + Date.now().toString(36);
-    const tempDir = join10(this.marketplacesDir, tempName);
+    const tempDir = join11(this.marketplacesDir, tempName);
     mkdirSync5(this.marketplacesDir, { recursive: true });
     if (source.type === "local") {
-      if (!existsSync10(source.path)) {
+      if (!existsSync11(source.path)) {
         throw new Error(`Local marketplace path does not exist: ${source.path}`);
       }
       cpSync2(source.path, tempDir, { recursive: true });
@@ -2034,8 +3262,8 @@ var MarketplaceClient = class {
         throw new Error(`Failed to clone marketplace: ${message}`);
       }
     }
-    const manifestPath = join10(tempDir, ".claude-plugin", "marketplace.json");
-    if (!existsSync10(manifestPath)) {
+    const manifestPath = join11(tempDir, ".claude-plugin", "marketplace.json");
+    if (!existsSync11(manifestPath)) {
       rmSync3(tempDir, { recursive: true, force: true });
       throw new Error(
         source.type === "local" ? "Local directory does not contain .claude-plugin/marketplace.json" : "Cloned repository does not contain .claude-plugin/marketplace.json"
@@ -2052,7 +3280,7 @@ var MarketplaceClient = class {
       rmSync3(tempDir, { recursive: true, force: true });
       throw new Error(`Marketplace "${name}" already exists`);
     }
-    const finalDir = join10(this.marketplacesDir, name);
+    const finalDir = join11(this.marketplacesDir, name);
     renameSync(tempDir, finalDir);
     registry[name] = {
       source,
@@ -2074,7 +3302,7 @@ var MarketplaceClient = class {
       throw new Error(`Marketplace "${name}" not found`);
     }
     removeInstalledPluginsForMarketplace(this.pluginsDir, name);
-    if (existsSync10(entry.installLocation)) {
+    if (existsSync11(entry.installLocation)) {
       rmSync3(entry.installLocation, { recursive: true, force: true });
     }
     delete registry[name];
@@ -2091,12 +3319,12 @@ var MarketplaceClient = class {
     if (!entry) {
       throw new Error(`Marketplace "${name}" not found`);
     }
-    if (!existsSync10(entry.installLocation)) {
+    if (!existsSync11(entry.installLocation)) {
       throw new Error(`Marketplace directory for "${name}" does not exist`);
     }
     if (entry.source.type === "local") {
       const localSource = entry.source;
-      if (!existsSync10(localSource.path)) {
+      if (!existsSync11(localSource.path)) {
         throw new Error(`Local marketplace path does not exist: ${localSource.path}`);
       }
       rmSync3(entry.installLocation, { recursive: true, force: true });
@@ -2129,8 +3357,8 @@ var MarketplaceClient = class {
     if (!entry) {
       throw new Error(`Marketplace "${marketplaceName}" not found`);
     }
-    const manifestPath = join10(entry.installLocation, ".claude-plugin", "marketplace.json");
-    if (!existsSync10(manifestPath)) {
+    const manifestPath = join11(entry.installLocation, ".claude-plugin", "marketplace.json");
+    if (!existsSync11(manifestPath)) {
       throw new Error(
         `Marketplace "${marketplaceName}" does not contain .claude-plugin/marketplace.json`
       );
@@ -2193,7 +3421,7 @@ var MarketplaceClient = class {
   }
   /** Read and parse a marketplace.json from a file path. */
   readManifestFromPath(path) {
-    const raw = readFileSync9(path, "utf-8");
+    const raw = readFileSync10(path, "utf-8");
     const data = JSON.parse(raw);
     if (typeof data !== "object" || data === null) {
       throw new Error("Invalid marketplace manifest: not an object");
@@ -2206,14 +3434,14 @@ var MarketplaceClient = class {
   }
   /** Default exec implementation using child_process. */
   defaultExec(command, options) {
-    return execSync2(command, { timeout: options.timeout, stdio: "pipe" });
+    return execSync3(command, { timeout: options.timeout, stdio: "pipe" });
   }
 };
 
 // src/plugins/plugin-hooks-merger.ts
-import { join as join11, dirname as dirname5 } from "path";
+import { join as join12, dirname as dirname5 } from "path";
 function buildPluginEnv(plugin) {
-  const dataDir = join11(dirname5(dirname5(plugin.pluginDir)), "data", plugin.manifest.name);
+  const dataDir = join12(dirname5(dirname5(plugin.pluginDir)), "data", plugin.manifest.name);
   return {
     CLAUDE_PLUGIN_ROOT: plugin.pluginDir,
     CLAUDE_PLUGIN_PATH: plugin.pluginDir,
@@ -2275,36 +3503,39 @@ function mergeHooksIntoConfig(configHooks, pluginHooks) {
 }
 
 // src/interactive/interactive-session-init.ts
-import { homedir as homedir3 } from "os";
-import { join as join12 } from "path";
+import { homedir as homedir4 } from "os";
+import { join as join13 } from "path";
 async function createInteractiveSession(options) {
   const cwd = options.cwd;
   const [config, context, projectInfo] = await Promise.all([
     loadConfig(cwd),
-    loadContext(cwd),
-    detectProject(cwd)
+    options.bare ? Promise.resolve({ agentsMd: "", claudeMd: "" }) : loadContext(cwd),
+    options.bare ? Promise.resolve({ type: "unknown", language: "unknown" }) : detectProject(cwd)
   ]);
-  const pluginsDir = join12(homedir3(), ".robota", "plugins");
+  const pluginsDir = join13(homedir4(), ".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
-        )
-      };
+  if (!options.bare) {
+    try {
+      const plugins = pluginLoader.loadPluginsSync();
+      if (plugins.length > 0) {
+        const pluginHooks = mergePluginHooks(plugins);
+        mergedConfig = {
+          ...config,
+          hooks: mergeHooksIntoConfig(
+            config.hooks,
+            pluginHooks
+          )
+        };
+      }
+    } catch {
     }
-  } catch {
   }
   const paths = projectPaths(cwd);
   const sessionId = options.resumeSessionId && !options.forkSession ? options.resumeSessionId : void 0;
   return createSession({
     config: mergedConfig,
+    cwd,
     context,
     projectInfo,
     permissionMode: options.permissionMode,
@@ -2315,7 +3546,22 @@ async function createInteractiveSession(options) {
     provider: options.provider,
     onTextDelta: options.onTextDelta,
     onToolExecution: options.onToolExecution,
-    sessionId
+    sessionId,
+    allowedTools: options.allowedTools,
+    appendSystemPrompt: options.appendSystemPrompt,
+    backgroundTaskRunners: options.backgroundTaskRunners,
+    subagentRunnerFactory: options.subagentRunnerFactory,
+    ...options.commandModules?.some(
+      (module) => module.sessionRequirements?.includes("agent-runtime")
+    ) ? { enableAgentRuntime: true } : {},
+    ...options.commandModules || options.commandDescriptors ? {
+      commandDescriptors: [
+        ...options.commandDescriptors ?? [],
+        ...options.commandModules?.flatMap((module) => module.commandDescriptors ?? []) ?? []
+      ]
+    } : {},
+    modelCommandExecutor: options.modelCommandExecutor,
+    isModelCommandInvocable: options.isModelCommandInvocable
   });
 }
 function injectSavedMessage(session, msg) {
@@ -2334,9 +3580,25 @@ function injectSavedMessage(session, msg) {
 function loadSessionRecord(sessionStore, resumeSessionId, forkSession, existingSession) {
   const record = sessionStore.load(resumeSessionId);
   if (!record) {
-    return { history: [], sessionName: void 0, pendingRestoreMessages: null };
+    return {
+      history: [],
+      sessionName: void 0,
+      pendingRestoreMessages: null,
+      backgroundTasks: [],
+      backgroundTaskEvents: [],
+      backgroundJobGroups: [],
+      backgroundJobGroupEvents: []
+    };
   }
   const history = record.history ?? [];
+  const restoredBackgroundTasks = record.backgroundTasks ?? [];
+  const restoredBackgroundTaskEvents = record.backgroundTaskEvents ?? [];
+  const backgroundJobGroups = record.backgroundJobGroups ?? [];
+  const backgroundJobGroupEvents = record.backgroundJobGroupEvents ?? [];
+  const { backgroundTasks, backgroundTaskEvents } = reconcileRestoredBackgroundTasks(
+    restoredBackgroundTasks,
+    restoredBackgroundTaskEvents
+  );
   const sessionName = record.name;
   let pendingRestoreMessages = null;
   if (!forkSession && record.messages) {
@@ -2348,7 +3610,44 @@ function loadSessionRecord(sessionStore, resumeSessionId, forkSession, existingS
       pendingRestoreMessages = record.messages;
     }
   }
-  return { history, sessionName, pendingRestoreMessages };
+  return {
+    history,
+    sessionName,
+    pendingRestoreMessages,
+    backgroundTasks,
+    backgroundTaskEvents,
+    backgroundJobGroups,
+    backgroundJobGroupEvents
+  };
+}
+function reconcileRestoredBackgroundTasks(tasks, events) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const syntheticEvents = [];
+  const backgroundTasks = tasks.map((task) => {
+    if (isRestoredTerminalStatus(task.status)) return task;
+    const reconciled = {
+      ...task,
+      status: "failed",
+      timeoutReason: "stale_worker",
+      error: {
+        category: "timeout",
+        message: "Restored background task is stale; worker cannot be reattached",
+        recoverable: true
+      },
+      unread: true,
+      completedAt: now,
+      updatedAt: now
+    };
+    syntheticEvents.push({ type: "background_task_failed", task: reconciled });
+    return reconciled;
+  });
+  return {
+    backgroundTasks,
+    backgroundTaskEvents: [...events, ...syntheticEvents]
+  };
+}
+function isRestoredTerminalStatus(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
 }
 
 // src/interactive/interactive-session.ts
@@ -2370,10 +3669,24 @@ var InteractiveSession = class {
   sessionName;
   cwd;
   pendingRestoreMessages = null;
+  backgroundTasks = [];
+  backgroundTaskEvents = [];
+  backgroundJobGroups = [];
+  backgroundJobGroupEvents = [];
   resumeSessionId;
   forkSession;
+  backgroundTaskUnsubscribe = null;
+  backgroundJobUnsubscribe = null;
+  backgroundJobOrchestrator = null;
+  commandModules;
+  shuttingDown = false;
+  shutdownPromise = null;
   constructor(options) {
-    this.commandExecutor = new SystemCommandExecutor(createSystemCommands());
+    this.commandModules = "commandModules" in options ? options.commandModules ?? [] : [];
+    this.commandExecutor = new SystemCommandExecutor([
+      ...createSystemCommands(),
+      ...this.commandModules.flatMap((module) => module.systemCommands ?? [])
+    ]);
     this.sessionStore = options.sessionStore;
     this.sessionName = options.sessionName;
     this.cwd = ("cwd" in options ? options.cwd : void 0) ?? "";
@@ -2395,8 +3708,14 @@ var InteractiveSession = class {
       );
       if (restored.history.length > 0) this.history = restored.history;
       if (restored.sessionName) this.sessionName = restored.sessionName;
+      this.backgroundTasks = restored.backgroundTasks;
+      this.backgroundTaskEvents = restored.backgroundTaskEvents;
+      this.backgroundJobGroups = restored.backgroundJobGroups;
+      this.backgroundJobGroupEvents = restored.backgroundJobGroupEvents;
       this.pendingRestoreMessages = restored.pendingRestoreMessages;
     }
+    if (this.initialized) this.subscribeBackgroundTaskEvents();
+    if (this.initialized) this.persistCurrentSession();
   }
   async initializeAsync(options) {
     this.session = await createInteractiveSession({
@@ -2408,13 +3727,26 @@ var InteractiveSession = class {
       resumeSessionId: this.resumeSessionId,
       forkSession: this.forkSession,
       onTextDelta: (delta) => this.handleTextDelta(delta),
-      onToolExecution: (event) => this.handleToolExecution(event)
+      onToolExecution: (event) => this.handleToolExecution(event),
+      bare: options.bare,
+      allowedTools: options.allowedTools,
+      appendSystemPrompt: options.appendSystemPrompt,
+      backgroundTaskRunners: options.backgroundTaskRunners,
+      subagentRunnerFactory: options.subagentRunnerFactory,
+      ...options.commandModules ? { commandModules: options.commandModules } : {},
+      commandDescriptors: this.commandExecutor.listModelInvocableCommands(),
+      ...this.commandExecutor.listModelInvocableCommands().length > 0 ? {
+        modelCommandExecutor: (command, args) => this.executeModelCommand(command, args),
+        isModelCommandInvocable: (command) => this.commandExecutor.isModelInvocable(command)
+      } : {}
     });
     if (this.pendingRestoreMessages) {
       for (const msg of this.pendingRestoreMessages) injectSavedMessage(this.session, msg);
       this.pendingRestoreMessages = null;
     }
     this.initialized = true;
+    this.subscribeBackgroundTaskEvents();
+    this.persistCurrentSession();
   }
   async ensureInitialized() {
     if (!this.initialized && this.initPromise) await this.initPromise;
@@ -2437,6 +3769,7 @@ var InteractiveSession = class {
   }
   async submit(input, displayInput, rawInput) {
     await this.ensureInitialized();
+    if (this.shuttingDown) throw new Error("Interactive session is shutting down.");
     if (this.executing) {
       this.pendingPrompt = input;
       this.pendingDisplayInput = displayInput;
@@ -2449,16 +3782,68 @@ var InteractiveSession = class {
     await this.ensureInitialized();
     return this.commandExecutor.execute(name, this, args);
   }
+  async executeModelCommand(name, args) {
+    await this.ensureInitialized();
+    return this.commandExecutor.executeModelInvocable(name, this, args);
+  }
+  async executeSkillCommand(skill, args, displayInput, rawInput) {
+    await this.ensureInitialized();
+    if (skill.context === "fork") {
+      return this.executeForkSkillCommand(skill, args, displayInput);
+    }
+    const result = await executeSkill(
+      skill,
+      args,
+      {
+        runInFork: (content, options) => this.runSkillInFork(content, options)
+      },
+      { sessionId: this.getSessionOrThrow().getSessionId() }
+    );
+    if (result.mode === "inject") {
+      if (result.prompt) {
+        await this.submit(result.prompt, displayInput, rawInput);
+      }
+      return result;
+    }
+    await this.applyForkSkillResult(result.result ?? "(empty response)");
+    return result;
+  }
   listCommands() {
     return this.commandExecutor.listCommands().map((cmd) => ({
       name: cmd.name,
       description: cmd.description
     }));
   }
+  listModelInvocableCommands() {
+    return this.commandExecutor.listModelInvocableCommands().map((cmd) => ({
+      name: cmd.name,
+      description: cmd.description
+    }));
+  }
   abort() {
     this.clearPendingQueue();
     this.session?.abort();
   }
+  shutdown(options = {}) {
+    if (this.shutdownPromise) return this.shutdownPromise;
+    this.shuttingDown = true;
+    this.shutdownPromise = (async () => {
+      await this.ensureInitialized();
+      this.clearPendingQueue();
+      const session = this.session;
+      session?.abort();
+      await this.getBackgroundTaskManager()?.shutdown(options.message ?? "Session shutdown");
+      this.backgroundTaskUnsubscribe?.();
+      this.backgroundTaskUnsubscribe = null;
+      this.backgroundJobUnsubscribe?.();
+      this.backgroundJobUnsubscribe = null;
+      this.backgroundJobOrchestrator?.dispose();
+      this.backgroundJobOrchestrator = null;
+      this.persistCurrentSession();
+      await session?.shutdown({ reason: options.reason ?? "other" });
+    })();
+    return this.shutdownPromise;
+  }
   cancelQueue() {
     this.clearPendingQueue();
   }
@@ -2494,485 +3879,436 @@ var InteractiveSession = class {
   getSession() {
     return this.getSessionOrThrow();
   }
-  setName(name) {
-    this.sessionName = name;
-    if (this.sessionStore && this.session) {
-      try {
-        const id = this.getSessionOrThrow().getSessionId();
-        const existing = this.sessionStore.load(id);
-        if (existing) {
-          existing.name = name;
-          existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-          this.sessionStore.save(existing);
-        }
-      } catch {
-      }
-    }
+  listBackgroundTasks(filter) {
+    return this.getBackgroundTaskManagerOrThrow().list(filter);
   }
-  attachTransport(transport) {
-    transport.attach(this);
+  getBackgroundTask(taskId) {
+    return this.getBackgroundTaskManagerOrThrow().get(taskId);
   }
-  async executePrompt(input, displayInput, rawInput) {
-    this.executing = true;
-    this.clearStreaming();
-    this.emit("thinking", true);
-    this.history.push(messageToHistoryEntry(createUserMessage(displayInput ?? input)));
-    const historyBefore = this.getSessionOrThrow().getHistory().length;
-    try {
-      const response = await this.getSessionOrThrow().run(input, rawInput);
-      this.flushStreaming();
-      pushToolSummaryToHistory({ activeTools: this.activeTools, history: this.history });
-      this.clearStreaming();
-      const result = buildResult(
-        response || "(empty response)",
-        this.getSessionOrThrow().getHistory(),
-        this.history,
-        historyBefore,
-        this.getContextState()
-      );
-      this.history.push(messageToHistoryEntry(createAssistantMessage(result.response)));
-      this.emit("complete", result);
-      this.emit("context_update", this.getContextState());
-    } catch (err) {
-      this.flushStreaming();
-      if (isAbortError(err)) {
-        const result = buildInterruptedResult(
-          this.getSessionOrThrow().getHistory(),
-          this.history,
-          historyBefore,
-          this.getContextState()
-        );
-        pushToolSummaryToHistory({ activeTools: this.activeTools, history: this.history });
-        this.clearStreaming();
-        if (result.response)
-          this.history.push(messageToHistoryEntry(createAssistantMessage(result.response)));
-        this.history.push(messageToHistoryEntry(createSystemMessage("Interrupted by user.")));
-        this.emit("interrupted", result);
-      } else {
-        pushToolSummaryToHistory({ activeTools: this.activeTools, history: this.history });
-        this.clearStreaming();
-        const errMsg = err instanceof Error ? err.message : String(err);
-        this.history.push(messageToHistoryEntry(createSystemMessage(`Error: ${errMsg}`)));
-        this.emit("error", err instanceof Error ? err : new Error(errMsg));
-      }
-    } finally {
-      this.executing = false;
-      this.emit("thinking", false);
-      if (this.sessionStore && this.session) {
-        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.clearPendingQueue();
-        setTimeout(() => this.executePrompt(queued, queuedDisplay, queuedRaw), 0);
-      }
-    }
+  async cancelBackgroundTask(taskId, reason) {
+    await this.ensureInitialized();
+    await this.getBackgroundTaskManagerOrThrow().cancel(taskId, reason);
   }
-  handleTextDelta(delta) {
-    this.streamingText += delta;
-    this.emit("text_delta", delta);
-    if (!this.flushTimer) {
-      this.flushTimer = setTimeout(() => {
-        this.flushTimer = null;
-      }, STREAMING_FLUSH_INTERVAL_MS);
-    }
+  async closeBackgroundTask(taskId) {
+    await this.ensureInitialized();
+    await this.getBackgroundTaskManagerOrThrow().close(taskId);
   }
-  handleToolExecution(event) {
-    const streamingState = { activeTools: this.activeTools, history: this.history };
-    if (event.type === "start") {
-      const toolState = applyToolStart(streamingState, event);
-      this.activeTools = streamingState.activeTools;
-      this.emit("tool_start", toolState);
-    } else {
-      const finished = applyToolEnd(streamingState, event);
-      this.activeTools = streamingState.activeTools;
-      if (finished) this.emit("tool_end", finished);
-    }
+  async sendBackgroundTask(taskId, input) {
+    await this.ensureInitialized();
+    await this.getBackgroundTaskManagerOrThrow().send(taskId, input);
+  }
+  async readBackgroundTaskLog(taskId, cursor) {
+    await this.ensureInitialized();
+    return this.getBackgroundTaskManagerOrThrow().readLog(taskId, cursor);
+  }
+  createBackgroundJobGroup(input) {
+    const orchestrator = this.getBackgroundJobOrchestratorOrThrow();
+    return orchestrator.createGroup({
+      ...input,
+      parentSessionId: this.getSessionOrThrow().getSessionId()
+    });
+  }
+  listBackgroundJobGroups() {
+    return this.getBackgroundJobOrchestratorOrThrow().listGroups();
   }
-  clearStreaming() {
-    this.streamingText = "";
-    this.activeTools = [];
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
-    }
+  getBackgroundJobGroup(groupId) {
+    return this.getBackgroundJobOrchestratorOrThrow().getGroup(groupId);
   }
-  flushStreaming() {
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
-    }
+  async waitBackgroundJobGroup(groupId) {
+    await this.ensureInitialized();
+    return this.getBackgroundJobOrchestratorOrThrow().waitGroup(groupId);
   }
-};
-
-// src/query.ts
-function createQuery(options) {
-  const session = new InteractiveSession({
-    cwd: options.cwd ?? process.cwd(),
-    provider: options.provider,
-    permissionMode: options.permissionMode ?? "bypassPermissions",
-    maxTurns: options.maxTurns,
-    permissionHandler: options.permissionHandler
-  });
-  if (options.onTextDelta) {
-    session.on("text_delta", options.onTextDelta);
+  listAgentDefinitions() {
+    const deps = retrieveAgentToolDeps(this.getSessionOrThrow());
+    return (deps?.agentDefinitions ?? []).map((agent) => ({
+      name: agent.name,
+      description: agent.description
+    }));
   }
-  return async (prompt) => {
-    return new Promise((resolve2, reject) => {
-      const onComplete = (result) => {
-        cleanup();
-        resolve2(result.response);
-      };
-      const onInterrupted = (result) => {
-        cleanup();
-        resolve2(result.response);
-      };
-      const onError = (error) => {
-        cleanup();
-        reject(error);
-      };
-      const cleanup = () => {
-        session.off("complete", onComplete);
-        session.off("interrupted", onInterrupted);
-        session.off("error", onError);
-      };
-      session.on("complete", onComplete);
-      session.on("interrupted", onInterrupted);
-      session.on("error", onError);
-      session.submit(prompt).catch((err) => {
-        cleanup();
-        reject(err instanceof Error ? err : new Error(String(err)));
-      });
+  listAgentJobs() {
+    return this.getSubagentManagerOrThrow().list();
+  }
+  async spawnAgentJob(input) {
+    await this.ensureInitialized();
+    const deps = this.getAgentToolDepsOrThrow();
+    const definition = this.resolveAgentDefinition(input.agentType, deps);
+    return this.getSubagentManagerOrThrow().spawn({
+      type: input.agentType,
+      label: input.label,
+      parentSessionId: this.getSessionOrThrow().getSessionId(),
+      mode: input.mode,
+      depth: (deps.subagentDepth ?? 0) + 1,
+      cwd: deps.cwd ?? this.cwd ?? process.cwd(),
+      prompt: input.prompt,
+      model: input.model ?? definition.model,
+      isolation: input.isolation,
+      allowedTools: definition.tools,
+      disallowedTools: definition.disallowedTools
     });
-  };
-}
-
-// 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));
+  async waitAgentJob(jobId) {
+    await this.ensureInitialized();
+    return this.getSubagentManagerOrThrow().wait(jobId);
   }
-  /** 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;
+  async sendAgentJob(jobId, prompt) {
+    await this.ensureInitialized();
+    await this.getSubagentManagerOrThrow().send(jobId, prompt);
   }
-  /** 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;
+  async cancelAgentJob(jobId, reason) {
+    await this.ensureInitialized();
+    await this.getSubagentManagerOrThrow().cancel(jobId, reason);
+  }
+  async closeAgentJob(jobId) {
+    await this.ensureInitialized();
+    await this.getSubagentManagerOrThrow().close(jobId);
+  }
+  setName(name) {
+    this.sessionName = name;
+    if (this.sessionStore && this.session) {
+      try {
+        const id = this.getSessionOrThrow().getSessionId();
+        const existing = this.sessionStore.load(id);
+        if (existing) {
+          existing.name = name;
+          existing.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          this.sessionStore.save(existing);
         }
+      } catch {
       }
     }
-    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"
+  attachTransport(transport) {
+    transport.attach(this);
+  }
+  async executeForkSkillCommand(skill, args, displayInput) {
+    if (this.executing) {
+      throw new Error("Cannot execute fork skill while another prompt is running.");
+    }
+    this.startForkSkillExecution(displayInput ?? `/${skill.name}`);
+    try {
+      const result = await executeSkill(
+        skill,
+        args,
+        { runInFork: (content, options) => this.runSkillInFork(content, options) },
+        { sessionId: this.getSessionOrThrow().getSessionId() }
+      );
+      await this.applyForkSkillResult(result.result ?? "(empty response)");
+      return result;
+    } catch (err) {
+      this.recordForkSkillError(err instanceof Error ? err : new Error(String(err)));
+      return { mode: "fork", result: "" };
+    } finally {
+      this.finishForkSkillExecution();
+    }
+  }
+  getBackgroundTaskManagerOrThrow() {
+    const manager = this.getBackgroundTaskManager();
+    if (!manager) {
+      throw new Error("Background task manager is not available for this session.");
+    }
+    return manager;
+  }
+  getBackgroundTaskManager() {
+    if (!this.session) return void 0;
+    return retrieveSessionBackgroundTaskManager(this.session) ?? retrieveAgentToolDeps(this.session)?.backgroundTaskManager;
+  }
+  getBackgroundJobOrchestratorOrThrow() {
+    if (this.backgroundJobOrchestrator) return this.backgroundJobOrchestrator;
+    const manager = this.getBackgroundTaskManagerOrThrow();
+    this.backgroundJobOrchestrator = new BackgroundJobOrchestrator({
+      manager,
+      initialGroups: this.backgroundJobGroups
     });
+    this.subscribeBackgroundJobGroupEvents();
+    return this.backgroundJobOrchestrator;
   }
-  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: "resume", description: "Resume a previous session", source: "builtin" },
-    { name: "rename", description: "Rename the current session", 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();
+  getAgentToolDepsOrThrow() {
+    const deps = retrieveAgentToolDeps(this.getSessionOrThrow());
+    if (!deps) {
+      throw new Error("Agent runtime dependencies are not available for this session.");
+    }
+    if (!deps.backgroundTaskManager) {
+      throw new Error("Background task manager is not available for this session.");
+    }
+    return deps;
   }
-  getCommands() {
-    return this.commands;
+  getSubagentManagerOrThrow() {
+    const deps = this.getAgentToolDepsOrThrow();
+    if (!deps.subagentManager) {
+      throw new Error("Subagent manager is not available for this session.");
+    }
+    return deps.subagentManager;
   }
-};
-
-// src/commands/skill-source.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync10, existsSync as existsSync11 } from "fs";
-import { join as join13, basename as basename2 } from "path";
-import { homedir as homedir4 } from "os";
-var BOOLEAN_KEYS = /* @__PURE__ */ new Set(["disable-model-invocation", "user-invocable"]);
-var LIST_KEYS2 = /* @__PURE__ */ new Set(["allowed-tools"]);
-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;
+  resolveAgentDefinition(agentType, deps) {
+    const definition = deps.customAgentRegistry?.(agentType);
+    if (!definition) {
+      throw new Error(`Unknown agent type: ${agentType}`);
     }
+    return definition;
+  }
+  subscribeBackgroundTaskEvents() {
+    if (this.backgroundTaskUnsubscribe || !this.session) return;
+    const manager = retrieveSessionBackgroundTaskManager(this.session) ?? retrieveAgentToolDeps(this.session)?.backgroundTaskManager;
+    if (!manager) return;
+    this.backgroundTaskUnsubscribe = manager.subscribe((event) => {
+      this.recordBackgroundTaskEvent(event);
+      this.emit("background_task_event", event);
+    });
   }
-  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 (!existsSync11(skillsDir)) return [];
-  const commands = [];
-  const entries = readdirSync4(skillsDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const skillFile = join13(skillsDir, entry.name, "SKILL.md");
-    if (!existsSync11(skillFile)) continue;
-    const content = readFileSync10(skillFile, "utf-8");
-    const frontmatter = parseFrontmatter2(content);
-    commands.push(buildCommand(frontmatter, content, entry.name));
+  subscribeBackgroundJobGroupEvents() {
+    if (this.backgroundJobUnsubscribe || !this.backgroundJobOrchestrator) return;
+    this.backgroundJobUnsubscribe = this.backgroundJobOrchestrator.subscribe((event) => {
+      this.recordBackgroundJobGroupEvent(event);
+      this.emit("background_job_group_event", event);
+    });
   }
-  return commands;
-}
-function scanCommandsDir(commandsDir) {
-  if (!existsSync11(commandsDir)) return [];
-  const commands = [];
-  const entries = readdirSync4(commandsDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
-    const filePath = join13(commandsDir, entry.name);
-    const content = readFileSync10(filePath, "utf-8");
-    const frontmatter = parseFrontmatter2(content);
-    const fallbackName = basename2(entry.name, ".md");
-    commands.push(buildCommand(frontmatter, content, fallbackName));
+  recordBackgroundTaskEvent(event) {
+    this.backgroundTasks = this.getBackgroundTaskSnapshots();
+    this.backgroundTaskEvents.push(event);
+    this.persistCurrentSession();
   }
-  return commands;
-}
-var SkillCommandSource = class {
-  name = "skill";
-  cwd;
-  home;
-  cachedCommands = null;
-  constructor(cwd, home) {
-    this.cwd = cwd;
-    this.home = home ?? homedir4();
+  recordBackgroundJobGroupEvent(event) {
+    this.backgroundJobGroups = this.getBackgroundJobGroupSnapshots();
+    this.backgroundJobGroupEvents.push(event);
+    this.persistCurrentSession();
+  }
+  getBackgroundTaskSnapshots() {
+    try {
+      return this.getBackgroundTaskManagerOrThrow().list();
+    } catch {
+      return this.backgroundTasks;
+    }
   }
-  getCommands() {
-    if (this.cachedCommands) return this.cachedCommands;
-    const sources = [
-      scanSkillsDir(join13(this.cwd, ".claude", "skills")),
-      scanCommandsDir(join13(this.cwd, ".claude", "commands")),
-      scanSkillsDir(join13(this.home, ".robota", "skills")),
-      scanSkillsDir(join13(this.cwd, ".agents", "skills"))
-    ];
-    const seen = /* @__PURE__ */ new Set();
-    const merged = [];
-    for (const commands of sources) {
-      for (const cmd of commands) {
-        if (!seen.has(cmd.name)) {
-          seen.add(cmd.name);
-          merged.push(cmd);
-        }
+  getBackgroundJobGroupSnapshots() {
+    try {
+      return this.backgroundJobOrchestrator?.listGroups() ?? this.backgroundJobGroups;
+    } catch {
+      return this.backgroundJobGroups;
+    }
+  }
+  persistCurrentSession() {
+    if (!this.sessionStore || !this.session) return;
+    this.backgroundTasks = this.getBackgroundTaskSnapshots();
+    this.backgroundJobGroups = this.getBackgroundJobGroupSnapshots();
+    persistSession(
+      this.sessionStore,
+      this.session,
+      this.sessionName,
+      this.cwd ?? "",
+      this.history,
+      {
+        tasks: this.backgroundTasks,
+        events: this.backgroundTaskEvents,
+        groups: this.backgroundJobGroups,
+        groupEvents: this.backgroundJobGroupEvents
       }
+    );
+  }
+  startForkSkillExecution(displayInput) {
+    this.executing = true;
+    this.clearStreaming();
+    this.emit("thinking", true);
+    this.history.push(messageToHistoryEntry(createUserMessage(displayInput)));
+  }
+  finishForkSkillExecution() {
+    this.executing = false;
+    this.emit("thinking", false);
+    this.persistCurrentSession();
+    if (!this.shuttingDown && this.pendingPrompt) {
+      const queued = this.pendingPrompt;
+      const queuedDisplay = this.pendingDisplayInput;
+      const queuedRaw = this.pendingRawInput;
+      this.clearPendingQueue();
+      setTimeout(() => this.executePrompt(queued, queuedDisplay, queuedRaw), 0);
     }
-    this.cachedCommands = merged;
-    return this.cachedCommands;
   }
-  getModelInvocableSkills() {
-    return this.getCommands().filter((cmd) => cmd.disableModelInvocation !== true);
+  recordForkSkillError(err) {
+    this.history.push(messageToHistoryEntry(createSystemMessage(`Error: ${err.message}`)));
+    this.emit("error", err);
   }
-  getUserInvocableSkills() {
-    return this.getCommands().filter((cmd) => cmd.userInvocable !== false);
+  resolveForkAgentDefinition(agentType, options) {
+    const deps = retrieveAgentToolDeps(this.getSessionOrThrow());
+    const definition = deps?.customAgentRegistry?.(agentType) ?? getBuiltInAgent(agentType);
+    if (!definition) {
+      throw new Error(`Unknown agent type: ${agentType}`);
+    }
+    if (options.allowedTools) {
+      return { ...definition, tools: options.allowedTools };
+    }
+    return definition;
   }
-};
-
-// src/commands/plugin-source.ts
-var PluginCommandSource = class {
-  name = "plugin";
-  plugins;
-  constructor(plugins) {
-    this.plugins = plugins;
+  async runSkillInFork(content, options) {
+    const parentSession = this.getSessionOrThrow();
+    const deps = retrieveAgentToolDeps(parentSession);
+    if (!deps) {
+      throw new Error("Fork execution is not available. Agent tool deps may not be initialized.");
+    }
+    const agentType = options.agent ?? "general-purpose";
+    const agentDefinition = this.resolveForkAgentDefinition(agentType, options);
+    const forkSession = createSubagentSession({
+      agentDefinition,
+      parentConfig: deps.config,
+      parentContext: deps.context,
+      parentTools: deps.tools,
+      provider: deps.provider,
+      terminal: deps.terminal,
+      isForkWorker: true,
+      permissionMode: deps.permissionMode,
+      permissionHandler: deps.permissionHandler,
+      hooks: deps.hooks,
+      hookTypeExecutors: deps.hookTypeExecutors,
+      onTextDelta: deps.onTextDelta,
+      onToolExecution: deps.onToolExecution
+    });
+    return forkSession.run(content);
   }
-  getCommands() {
-    const commands = [];
-    for (const plugin of this.plugins) {
-      for (const skill of plugin.skills) {
-        const baseName = skill.name.includes("@") ? skill.name.split("@")[0] : skill.name;
-        commands.push({
-          name: baseName,
-          description: `(${plugin.manifest.name}) ${skill.description}`,
-          source: "plugin",
-          skillContent: skill.skillContent,
-          pluginDir: plugin.pluginDir
-        });
+  async applyForkSkillResult(result) {
+    this.flushStreaming();
+    pushToolSummaryToHistory({ activeTools: this.activeTools, history: this.history });
+    this.clearStreaming();
+    const executionResult = {
+      response: result,
+      history: this.history,
+      toolSummaries: [],
+      contextState: this.getContextState()
+    };
+    this.history.push(messageToHistoryEntry(createAssistantMessage(result)));
+    this.emit("complete", executionResult);
+    this.emit("context_update", this.getContextState());
+  }
+  async executePrompt(input, displayInput, rawInput) {
+    this.executing = true;
+    this.clearStreaming();
+    this.emit("thinking", true);
+    this.history.push(messageToHistoryEntry(createUserMessage(displayInput ?? input)));
+    const historyBefore = this.getSessionOrThrow().getHistory().length;
+    try {
+      const response = await this.getSessionOrThrow().run(input, rawInput);
+      this.flushStreaming();
+      pushToolSummaryToHistory({ activeTools: this.activeTools, history: this.history });
+      this.clearStreaming();
+      const result = buildResult(
+        response || "(empty response)",
+        this.getSessionOrThrow().getHistory(),
+        this.history,
+        historyBefore,
+        this.getContextState()
+      );
+      this.history.push(messageToHistoryEntry(createAssistantMessage(result.response)));
+      this.emit("complete", result);
+      this.emit("context_update", this.getContextState());
+    } catch (err) {
+      this.flushStreaming();
+      if (isAbortError(err)) {
+        const result = buildInterruptedResult(
+          this.getSessionOrThrow().getHistory(),
+          this.history,
+          historyBefore,
+          this.getContextState()
+        );
+        pushToolSummaryToHistory({ activeTools: this.activeTools, history: this.history });
+        this.clearStreaming();
+        if (result.response)
+          this.history.push(messageToHistoryEntry(createAssistantMessage(result.response)));
+        this.history.push(messageToHistoryEntry(createSystemMessage("Interrupted by user.")));
+        this.emit("interrupted", result);
+      } else {
+        pushToolSummaryToHistory({ activeTools: this.activeTools, history: this.history });
+        this.clearStreaming();
+        const errMsg = err instanceof Error ? err.message : String(err);
+        this.history.push(messageToHistoryEntry(createSystemMessage(`Error: ${errMsg}`)));
+        this.emit("error", err instanceof Error ? err : new Error(errMsg));
       }
-      for (const cmd of plugin.commands) {
-        commands.push({
-          name: cmd.name,
-          description: cmd.description,
-          source: "plugin",
-          skillContent: cmd.skillContent,
-          pluginDir: plugin.pluginDir
-        });
+    } finally {
+      this.executing = false;
+      this.emit("thinking", false);
+      this.persistCurrentSession();
+      if (!this.shuttingDown && this.pendingPrompt) {
+        const queued = this.pendingPrompt;
+        const queuedDisplay = this.pendingDisplayInput;
+        const queuedRaw = this.pendingRawInput;
+        this.clearPendingQueue();
+        setTimeout(() => this.executePrompt(queued, queuedDisplay, queuedRaw), 0);
       }
     }
-    return commands;
   }
-};
-
-// src/utils/skill-prompt.ts
-import { execSync as execSync3 } from "child_process";
-function substituteVariables(content, args, context) {
-  const argParts = args ? args.split(/\s+/) : [];
-  let result = content;
-  result = result.replace(/\$ARGUMENTS\[(\d+)]/g, (_match, index) => {
-    return argParts[Number(index)] ?? "";
-  });
-  result = result.replace(/\$ARGUMENTS/g, args);
-  result = result.replace(/\$(\d)(?!\d|\w|\[)/g, (_match, digit) => {
-    return argParts[Number(digit)] ?? "";
-  });
-  result = result.replace(/\$\{CLAUDE_SESSION_ID}/g, context?.sessionId ?? "");
-  result = result.replace(/\$\{CLAUDE_SKILL_DIR}/g, context?.skillDir ?? "");
-  return result;
-}
-async function preprocessShellCommands(content) {
-  const shellPattern = /!`([^`]+)`/g;
-  if (!shellPattern.test(content)) {
-    return content;
+  handleTextDelta(delta) {
+    this.streamingText += delta;
+    this.emit("text_delta", delta);
+    if (!this.flushTimer) {
+      this.flushTimer = setTimeout(() => {
+        this.flushTimer = null;
+      }, STREAMING_FLUSH_INTERVAL_MS);
+    }
   }
-  shellPattern.lastIndex = 0;
-  let result = content;
-  let match;
-  const matches = [];
-  while ((match = shellPattern.exec(content)) !== null) {
-    matches.push({ full: match[0], command: match[1] });
+  handleToolExecution(event) {
+    const streamingState = { activeTools: this.activeTools, history: this.history };
+    if (event.type === "start") {
+      const toolState = applyToolStart(streamingState, event);
+      this.activeTools = streamingState.activeTools;
+      this.emit("tool_start", toolState);
+    } else {
+      const finished = applyToolEnd(streamingState, event);
+      this.activeTools = streamingState.activeTools;
+      if (finished) this.emit("tool_end", finished);
+    }
   }
-  for (const { full, command } of matches) {
-    let output = "";
-    try {
-      output = execSync3(command, {
-        timeout: 5e3,
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"]
-      }).trimEnd();
-    } catch {
-      output = "";
+  clearStreaming() {
+    this.streamingText = "";
+    this.activeTools = [];
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
     }
-    result = result.replace(full, output);
   }
-  return result;
-}
-async function buildSkillPrompt(input, registry, context) {
-  const parts = input.slice(1).split(/\s+/);
-  const cmd = parts[0]?.toLowerCase() ?? "";
-  const skillCmd = registry.getCommands().find((c) => c.name === cmd && (c.source === "skill" || c.source === "plugin"));
-  if (!skillCmd) return null;
-  const args = parts.slice(1).join(" ").trim();
-  const userInstruction = args || skillCmd.description;
-  if (skillCmd.skillContent) {
-    let processed = await preprocessShellCommands(skillCmd.skillContent);
-    processed = substituteVariables(processed, args, context);
-    return `<skill name="${cmd}">
-${processed}
-</skill>
+  flushStreaming() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+};
 
-Execute the "${cmd}" skill: ${userInstruction}`;
+// src/query.ts
+function createQuery(options) {
+  const session = new InteractiveSession({
+    cwd: options.cwd ?? process.cwd(),
+    provider: options.provider,
+    permissionMode: options.permissionMode ?? "bypassPermissions",
+    maxTurns: options.maxTurns,
+    permissionHandler: options.permissionHandler
+  });
+  if (options.onTextDelta) {
+    session.on("text_delta", options.onTextDelta);
   }
-  return `Use the "${cmd}" skill: ${userInstruction}`;
+  return async (prompt) => {
+    return new Promise((resolve2, reject) => {
+      const onComplete = (result) => {
+        cleanup();
+        resolve2(result.response);
+      };
+      const onInterrupted = (result) => {
+        cleanup();
+        resolve2(result.response);
+      };
+      const onError = (error) => {
+        cleanup();
+        reject(error);
+      };
+      const cleanup = () => {
+        session.off("complete", onComplete);
+        session.off("interrupted", onInterrupted);
+        session.off("error", onError);
+      };
+      session.on("complete", onComplete);
+      session.on("interrupted", onInterrupted);
+      session.on("error", onError);
+      session.submit(prompt).catch((err) => {
+        cleanup();
+        reject(err instanceof Error ? err : new Error(String(err)));
+      });
+    });
+  };
 }
 
 // src/types.ts
@@ -2985,6 +4321,12 @@ import {
   messageToHistoryEntry as messageToHistoryEntry2,
   getMessagesForAPI
 } from "@robota-sdk/agent-core";
+
+// src/subagents/index.ts
+import { SubagentManager as SubagentManager3 } from "@robota-sdk/agent-runtime";
+import { WorktreeSubagentRunner, createWorktreeSubagentRunner } from "@robota-sdk/agent-runtime";
+
+// src/index.ts
 import { evaluatePermission } from "@robota-sdk/agent-core";
 
 // src/permissions/permission-prompt.ts
@@ -3008,10 +4350,13 @@ async function promptForApproval(terminal, toolName, toolArgs) {
 }
 
 // src/index.ts
-import { runHooks } from "@robota-sdk/agent-core";
+import { runHooks as runHooks2 } from "@robota-sdk/agent-core";
 export {
   AgentExecutor,
   BUILT_IN_AGENTS,
+  BackgroundJobOrchestrator,
+  BackgroundTaskError,
+  BackgroundTaskManager,
   BuiltinCommandSource,
   BundlePluginInstaller,
   BundlePluginLoader,
@@ -3022,29 +4367,42 @@ export {
   PluginSettingsStore,
   PromptExecutor,
   SkillCommandSource,
+  SubagentManager3 as SubagentManager,
+  SystemCommandExecutor,
   TRUST_TO_MODE,
+  WorktreeSubagentRunner,
   assembleSubagentPrompt,
   buildSkillPrompt,
   chatEntryToMessage,
   createAgentTool,
+  createBackgroundProcessTool,
+  createCommandExecutionTool,
+  createDefaultTools,
   createQuery,
   createSubagentLogger,
   createSubagentSession,
+  createSystemCommands,
+  createWorktreeSubagentRunner,
   evaluatePermission,
+  executeSkill,
+  getBackgroundTaskTransitions,
   getBuiltInAgent,
   getForkWorkerSuffix,
   getMessagesForAPI,
   getSubagentSuffix,
   isChatEntry,
+  isTerminalBackgroundTaskStatus2 as isTerminalBackgroundTaskStatus,
   messageToHistoryEntry2 as messageToHistoryEntry,
-  parseFrontmatter2 as parseFrontmatter,
+  parseFrontmatter,
   preprocessShellCommands,
   projectPaths,
   promptForApproval,
   resolveSubagentLogDir,
   retrieveAgentToolDeps,
-  runHooks,
+  runHooks2 as runHooks,
   storeAgentToolDeps,
   substituteVariables,
+  summarizeBackgroundJobGroup,
+  transitionBackgroundTaskStatus,
   userPaths
 };