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

package/dist/node/index.d.cts

@@ -1,1066 +1,1399 @@
-import { ITerminalOutput, SessionStore, TPermissionHandler, ISessionLogger, Session, FileSessionLogger } from '@robota-sdk/agent-sessions';
+import { ITerminalOutput, ISessionLogger, TPermissionHandler, Session, SessionStore, FileSessionLogger } from '@robota-sdk/agent-sessions';
 export { ISpinner, ITerminalOutput } from '@robota-sdk/agent-sessions';
-import { TToolArgs, IHistoryEntry, IContextWindowState, IHookTypeExecutor, IHookDefinition, IHookInput, IHookResult, THooksConfig, TTrustLevel, TPermissionMode, IAIProvider, IToolWithEventService, TUniversalMessage } from '@robota-sdk/agent-core';
+import { TToolArgs, IHistoryEntry, IContextWindowState, THooksConfig, IToolWithEventService, IAIProvider, TPermissionMode, IHookTypeExecutor, IHookDefinition, IHookInput, IHookResult, TTrustLevel, TSessionEndReason, TUniversalMessage } from '@robota-sdk/agent-core';
 export { IAIProvider, IContextTokenUsage, IContextWindowState, IHistoryEntry, IHookInput, IPermissionLists, THookEvent, THooksConfig, TPermissionDecision, TPermissionMode, TRUST_TO_MODE, TToolArgs, TTrustLevel, chatEntryToMessage, evaluatePermission, getMessagesForAPI, isChatEntry, messageToHistoryEntry, runHooks } from '@robota-sdk/agent-core';
+import { IBackgroundTaskManager, TBackgroundTaskStatus, IBackgroundTaskError, TBackgroundTaskEvent, ISubagentRunner, IBackgroundTaskRunner, IBackgroundTaskListFilter, IBackgroundTaskState, IBackgroundTaskInput, IBackgroundTaskLogCursor, IBackgroundTaskLogPage, ISubagentJobState, TBackgroundTaskIsolation, ISubagentJobResult, ISubagentManager } from '@robota-sdk/agent-runtime';
+export { BackgroundTaskError, BackgroundTaskManager, IAgentBackgroundTaskRequest, IBackgroundTaskError, IBackgroundTaskHandle, IBackgroundTaskInput, IBackgroundTaskListFilter, IBackgroundTaskLogCursor, IBackgroundTaskLogPage, IBackgroundTaskManager, IBackgroundTaskManagerOptions, IBackgroundTaskRequest, IBackgroundTaskResult, IBackgroundTaskRunner, IBackgroundTaskStart, IBackgroundTaskState, IBaseBackgroundTaskRequest, IPreparedSubagentWorktree, IProcessBackgroundTaskRequest, ISerializableProviderProfile, ISubagentJobHandle, ISubagentJobResult, ISubagentJobStart, ISubagentJobState, ISubagentManager, ISubagentManagerOptions, ISubagentRunner, ISubagentSpawnRequest, ISubagentWorktreeAdapter, ISubagentWorktreePrepareRequest, IWorktreeSubagentRunnerOptions, SubagentManager, TBackgroundPermissionPolicy, TBackgroundPrimitive, TBackgroundTaskErrorCategory, TBackgroundTaskEvent, TBackgroundTaskEventListener, TBackgroundTaskIdFactory, TBackgroundTaskIsolation, TBackgroundTaskKind, TBackgroundTaskMode, TBackgroundTaskRunnerEvent, TBackgroundTaskStatus, TBackgroundTaskTimeoutReason, TBackgroundTaskTransitionEvent, TSubagentJobMode, TSubagentJobStatus, WorktreeSubagentRunner, createWorktreeSubagentRunner, getBackgroundTaskTransitions, isTerminalBackgroundTaskStatus, transitionBackgroundTaskStatus } from '@robota-sdk/agent-runtime';
 import { createZodFunctionTool } from '@robota-sdk/agent-tools';
 export { TToolResult } from '@robota-sdk/agent-tools';
 
-/**
- * Types for InteractiveSession — event-driven session wrapper.
- */
-
-/** Permission handler result — SDK-owned type (mirrors agent-sessions TPermissionResult).
- *  true = allow, false = deny, 'allow-session' = allow and remember for this session. */
-type TPermissionResultValue = boolean | 'allow-session';
-/** Tool execution state visible to clients. */
-interface IToolState {
-    toolName: string;
-    firstArg: string;
-    isRunning: boolean;
-    result?: 'success' | 'error' | 'denied';
-    diffLines?: IDiffLine[];
-    diffFile?: string;
-}
-/** A single diff line for Edit tool display. */
-interface IDiffLine {
-    type: 'add' | 'remove' | 'context';
-    text: string;
-    lineNumber: number;
-}
-/** Result of a completed prompt execution. */
-interface IExecutionResult {
-    response: string;
-    history: IHistoryEntry[];
-    toolSummaries: IToolSummary[];
-    contextState: IContextWindowState;
-}
-/** Summary of a tool call extracted from history. */
-interface IToolSummary {
-    name: string;
-    args: string;
-}
-/** Permission handler delegate — clients provide their own UI. */
-type TInteractivePermissionHandler = (toolName: string, toolArgs: TToolArgs) => Promise<TPermissionResultValue>;
-/** Events emitted by InteractiveSession. */
-interface IInteractiveSessionEvents {
-    text_delta: (delta: string) => void;
-    tool_start: (state: IToolState) => void;
-    tool_end: (state: IToolState) => void;
-    thinking: (isThinking: boolean) => void;
-    complete: (result: IExecutionResult) => void;
-    error: (error: Error) => void;
-    context_update: (state: IContextWindowState) => void;
-    interrupted: (result: IExecutionResult) => void;
-}
-type TInteractiveEventName = keyof IInteractiveSessionEvents;
-/**
- * Common interface for all transport adapters.
- * Each transport exposes InteractiveSession over a specific protocol.
- */
-interface ITransportAdapter {
-    /** Human-readable transport name (e.g., 'http', 'ws', 'mcp', 'headless') */
+type TCapabilityKind = 'builtin-command' | 'skill' | 'agent' | 'tool';
+type TCapabilitySafety = 'read-only' | 'write' | 'process' | 'network' | 'background-agent';
+interface ICapabilityDescriptor {
     readonly name: string;
-    /** Attach an InteractiveSession to this transport. */
-    attach(session: InteractiveSession): void;
-    /** Start serving. What this means depends on the transport. */
-    start(): Promise<void>;
-    /** Stop serving and clean up resources. */
-    stop(): Promise<void>;
+    readonly kind: TCapabilityKind;
+    readonly description: string;
+    readonly userInvocable: boolean;
+    readonly modelInvocable: boolean;
+    readonly argumentHint?: string;
+    readonly safety?: TCapabilitySafety;
 }
 
-/**
- * Prompt hook executor — evaluates a prompt via an AI model.
- *
- * Makes a single-turn LLM call with hook input context as the prompt.
- * Parses { ok: boolean, reason?: string } from the AI response.
- *
- * Exit codes:
- * - 0: ok: true (allow/proceed)
- * - 2: ok: false (block/deny), reason in stderr
- * - 1: execution error (provider failure, parse error)
- */
-
-/** A minimal provider interface for single-turn completion. */
-interface IPromptProvider {
-    complete(prompt: string): Promise<string>;
-}
-/** Factory that creates a provider instance, optionally for a specific model. */
-type TProviderFactory = (model?: string) => IPromptProvider;
-/** Constructor options for PromptExecutor. */
-interface IPromptExecutorOptions {
-    providerFactory: TProviderFactory;
-    defaultModel?: string;
+/** A command entry */
+interface ICommand {
+    /** Command name without slash (e.g., "mode") */
+    name: string;
+    /** Short description shown in autocomplete */
+    description: string;
+    /** Source identifier (e.g., "builtin", "skill") */
+    source: string;
+    /** Subcommands for hierarchical menus */
+    subcommands?: ICommand[];
+    /** Execute the command. Args is everything after the command name. */
+    execute?: (args: string) => void | Promise<void>;
+    /** Full SKILL.md content (only for skill commands) */
+    skillContent?: string;
+    /** Hint for the expected argument (Claude Code frontmatter) */
+    argumentHint?: string;
+    /** When true, models cannot invoke this skill autonomously */
+    disableModelInvocation?: boolean;
+    /** When true, models may invoke this command through the command execution tool */
+    modelInvocable?: boolean;
+    /** When false, users cannot invoke this skill directly */
+    userInvocable?: boolean;
+    /** Safety category for model-visible capability descriptors */
+    safety?: TCapabilitySafety;
+    /** List of tools this skill is allowed to use */
+    allowedTools?: string[];
+    /** Preferred model for executing this skill */
+    model?: string;
+    /** Effort level hint for the skill */
+    effort?: string;
+    /** Context scope for the skill (e.g., "project") */
+    context?: string;
+    /** Agent identity to use when executing this skill */
+    agent?: string;
+    /** Plugin installation directory (plugin skills/commands only) */
+    pluginDir?: string;
 }
-declare class PromptExecutor implements IHookTypeExecutor {
-    readonly type: "prompt";
-    private readonly providerFactory;
-    private readonly defaultModel;
-    constructor(options: IPromptExecutorOptions);
-    execute(definition: IHookDefinition, input: IHookInput): Promise<IHookResult>;
+/** A source that provides commands */
+interface ICommandSource {
+    name: string;
+    getCommands(): ICommand[];
 }
 
 /**
- * Agent hook executor — delegates to a sub-agent session.
- *
- * Creates a subagent session with maxTurns and timeout limits,
- * runs hook input as the initial prompt, and parses the result.
+ * System commands — SDK-level command execution logic.
  *
- * Exit codes:
- * - 0: ok: true (allow/proceed)
- * - 2: ok: false (block/deny), reason in stderr
- * - 1: execution error (session failure, parse error)
+ * Pure functions that operate on InteractiveSession.
+ * No React, no TUI, no framework dependencies.
+ * CLI wraps these as slash commands with UI chrome.
  */
 
-/** A minimal session interface for running a prompt. */
-interface IAgentSession {
-    run(prompt: string): Promise<string>;
+/** Result of a system command execution. */
+interface ICommandResult {
+    /** Human-readable output message */
+    message: string;
+    /** Command completed successfully */
+    success: boolean;
+    /** Additional structured data (command-specific) */
+    data?: Record<string, unknown>;
 }
-/** Factory that creates a session instance with the given options. */
-type TSessionFactory = (options: {
-    maxTurns?: number;
-    timeout?: number;
-}) => IAgentSession;
-/** Constructor options for AgentExecutor. */
-interface IAgentExecutorOptions {
-    sessionFactory: TSessionFactory;
+/** A system command with name, description, and execute logic. */
+interface ISystemCommand {
+    name: string;
+    description: string;
+    modelInvocable?: boolean;
+    userInvocable?: boolean;
+    argumentHint?: string;
+    safety?: TCapabilitySafety;
+    execute(session: InteractiveSession, args: string): Promise<ICommandResult> | ICommandResult;
 }
-declare class AgentExecutor implements IHookTypeExecutor {
-    readonly type: "agent";
-    private readonly sessionFactory;
-    constructor(options: IAgentExecutorOptions);
-    execute(definition: IHookDefinition, input: IHookInput): Promise<IHookResult>;
+/** Built-in system commands. */
+declare function createSystemCommands(): ISystemCommand[];
+/** Registry for system commands. */
+declare class SystemCommandExecutor {
+    private readonly commands;
+    constructor(commands?: ISystemCommand[]);
+    /** Register an additional command. */
+    register(command: ISystemCommand): void;
+    /** Execute a command by name. Returns null if command not found. */
+    execute(name: string, session: InteractiveSession, args: string): Promise<ICommandResult | null>;
+    /** List all registered commands. */
+    listCommands(): ISystemCommand[];
+    listModelInvocableCommands(): ICapabilityDescriptor[];
+    isModelInvocable(name: string): boolean;
+    executeModelInvocable(name: string, session: InteractiveSession, args: string): Promise<ICommandResult | null>;
+    /** Check if a command exists. */
+    hasCommand(name: string): boolean;
 }
 
-/**
- * Zod schemas and TypeScript types for Robota CLI settings
- */
+type TCommandModuleSessionRequirement = 'agent-runtime';
+/** Composable command capability module. */
+interface ICommandModule {
+    /** Stable module id for diagnostics and duplicate handling. */
+    readonly name: string;
+    /** Slash palette/autocomplete command sources contributed by this module. */
+    readonly commandSources?: readonly ICommandSource[];
+    /** Executable system commands contributed by this module. */
+    readonly systemCommands?: readonly ISystemCommand[];
+    /** Additional model-visible descriptors not derived from executable commands. */
+    readonly commandDescriptors?: readonly ICapabilityDescriptor[];
+    /** Runtime facilities required by this module. */
+    readonly sessionRequirements?: readonly TCommandModuleSessionRequirement[];
+}
 
-/**
- * Fully resolved config after merging all settings files and applying defaults.
- */
-interface IResolvedConfig {
-    defaultTrustLevel: 'safe' | 'moderate' | 'full';
-    /** Response language code (e.g., "ko", "en"). Undefined = no language constraint. */
-    language?: string;
-    provider: {
-        name: string;
-        model: string;
-        apiKey: string | undefined;
-    };
-    permissions: {
-        allow: string[];
-        deny: string[];
-    };
-    env: Record<string, string>;
-    hooks?: THooksConfig;
-    /** Plugin enablement map: plugin name -> enabled/disabled */
-    enabledPlugins?: Record<string, boolean>;
-    /** Extra marketplace sources: name -> { source } */
-    extraKnownMarketplaces?: Record<string, {
-        source: {
-            type: string;
-            repo?: string;
-            url?: string;
-            path?: string;
-            ref?: string;
-        };
-    }>;
+/** Aggregates commands from multiple sources */
+declare class CommandRegistry {
+    private sources;
+    addSource(source: ICommandSource): void;
+    addModule(module: ICommandModule): void;
+    /** Get all commands, optionally filtered by prefix */
+    getCommands(filter?: string): ICommand[];
+    /** Resolve a short name to its fully qualified plugin:name form */
+    resolveQualifiedName(shortName: string): string | null;
+    /** Get subcommands for a specific command */
+    getSubcommands(commandName: string): ICommand[];
+    getCapabilityDescriptors(): ICapabilityDescriptor[];
 }
 
-interface ILoadedContext {
-    /** Concatenated content of all AGENTS.md files found (root-first) */
-    agentsMd: string;
-    /** Concatenated content of all CLAUDE.md files found (root-first) */
-    claudeMd: string;
-    /** Extracted "Compact Instructions" section from CLAUDE.md, if present */
-    compactInstructions?: string;
+/** Command source for built-in commands */
+declare class BuiltinCommandSource implements ICommandSource {
+    readonly name = "builtin";
+    private readonly commands;
+    constructor();
+    getCommands(): ICommand[];
 }
 
-type TProjectType = 'node' | 'python' | 'rust' | 'go' | 'unknown';
-type TPackageManager = 'pnpm' | 'yarn' | 'npm' | 'bun';
-type TLanguage = 'typescript' | 'javascript' | 'python' | 'rust' | 'go' | 'unknown';
-interface IProjectInfo {
-    type: TProjectType;
+interface IFrontmatter {
     name?: string;
-    packageManager?: TPackageManager;
-    language: TLanguage;
+    description?: string;
+    argumentHint?: string;
+    disableModelInvocation?: boolean;
+    userInvocable?: boolean;
+    allowedTools?: string[];
+    model?: string;
+    effort?: string;
+    context?: string;
+    agent?: string;
+}
+/** Parse YAML-like frontmatter between --- markers */
+declare function parseFrontmatter(content: string): IFrontmatter | null;
+/** Command source that discovers skills from multiple directories */
+declare class SkillCommandSource implements ICommandSource {
+    readonly name = "skill";
+    private readonly cwd;
+    private readonly home;
+    private cachedCommands;
+    constructor(cwd: string, home?: string);
+    getCommands(): ICommand[];
+    getModelInvocableSkills(): ICommand[];
+    getUserInvocableSkills(): ICommand[];
 }
 
 /**
- * System prompt builder — assembles the system message sent to the AI model
- * from base role, project context, AGENTS.md/CLAUDE.md, tool list, and
- * permission trust level.
- */
-
-interface ISystemPromptParams {
-    /** Concatenated AGENTS.md content (may be empty string) */
-    agentsMd: string;
-    /** Concatenated CLAUDE.md content (may be empty string) */
-    claudeMd: string;
-    /** Human-readable tool descriptions, one per entry */
-    toolDescriptions: string[];
-    /** Active trust level governing permission checks */
-    trustLevel: TTrustLevel;
-    /** Detected project metadata */
-    projectInfo: IProjectInfo;
-    /** Current working directory */
-    cwd?: string;
-    /** Response language code (e.g., "ko", "en"). If set, AI must respond in this language. */
-    language?: string;
-    /** Discovered skills to expose in the system prompt */
-    skills?: Array<{
-        name: string;
-        description: string;
-        disableModelInvocation?: boolean;
-    }>;
-}
-
-/**
- * Session factory — assembles a fully-configured Session from config, context,
- * tools, and provider.
+ * PluginSettingsStore — single point of read/write for plugin-related settings.
  *
- * This is the main entry point for creating sessions. It wires together
- * the provider, tools, system prompt, and configuration that Session now
- * expects as pre-constructed dependencies.
+ * Shared by MarketplaceClient and BundlePluginInstaller to prevent
+ * concurrent writes from overwriting each other's changes.
  */
-
-/** Options for the createSession factory */
-interface ICreateSessionOptions {
-    /** Resolved CLI configuration (model, API key, permissions) */
-    config: IResolvedConfig;
-    /** Loaded AGENTS.md / CLAUDE.md context */
-    context: ILoadedContext;
-    /** Terminal I/O for permission prompts */
-    terminal: ITerminalOutput;
-    /** Project metadata for system prompt */
-    projectInfo?: IProjectInfo;
-    /** Initial permission mode (defaults to config.defaultTrustLevel → mode mapping) */
-    permissionMode?: TPermissionMode;
-    /** Maximum number of agentic turns per run() call. Undefined = unlimited. */
-    maxTurns?: number;
-    /** Optional session store for persistence */
-    sessionStore?: SessionStore;
-    /** Inject a pre-constructed AI provider (used by tests to avoid real API calls) */
-    provider?: IAIProvider;
-    /** Custom permission handler (overrides terminal-based prompts, used by Ink UI) */
-    permissionHandler?: TPermissionHandler;
-    /** Callback for text deltas — enables streaming text to the UI in real-time */
-    onTextDelta?: (delta: string) => void;
-    /** Custom prompt-for-approval function (injected from CLI) */
-    promptForApproval?: (terminal: ITerminalOutput, toolName: string, toolArgs: TToolArgs) => Promise<boolean>;
-    /** Additional tools to register beyond the defaults (e.g. agent-tool) */
-    additionalTools?: IToolWithEventService[];
-    /** Callback when a tool starts or finishes execution — enables real-time tool display in UI */
-    onToolExecution?: (event: {
-        type: 'start' | 'end';
-        toolName: string;
-        toolArgs?: TToolArgs;
-        success?: boolean;
-    }) => void;
-    /** Callback when context is compacted */
-    onCompact?: (summary: string) => void;
-    /** Instructions to include in the compaction prompt (e.g. from CLAUDE.md) */
-    compactInstructions?: string;
-    /** Custom system prompt builder function */
-    systemPromptBuilder?: (params: ISystemPromptParams) => string;
-    /** Custom tool descriptions for the system prompt */
-    toolDescriptions?: string[];
-    /** Session logger — injected for pluggable session event logging. */
-    sessionLogger?: ISessionLogger;
-    /** Provider factory for prompt hook executors (DI). */
-    providerFactory?: TProviderFactory;
-    /** Session factory for agent hook executors (DI). */
-    sessionFactory?: TSessionFactory;
-    /** Additional hook type executors beyond the defaults (prompt, agent). */
-    additionalHookExecutors?: IHookTypeExecutor[];
-    /** Override session ID (used when resuming a session to reuse the original ID) */
-    sessionId?: string;
+/** Source type for a marketplace registry. */
+type IMarketplaceSource$1 = {
+    type: 'github';
+    repo: string;
+    ref?: string;
+} | {
+    type: 'git';
+    url: string;
+    ref?: string;
+} | {
+    type: 'local';
+    path: string;
+} | {
+    type: 'url';
+    url: string;
+};
+/** Persisted marketplace source entry. */
+interface IPersistedMarketplaceSource {
+    source: IMarketplaceSource$1;
 }
-
-/**
- * Framework system prompt suffixes for subagent sessions.
- *
- * These functions generate the standard prompt content injected into
- * subagent sessions to control output format and behavior.
- */
-/** Options for assembling a subagent system prompt. */
-interface ISubagentPromptOptions {
-    /** Agent definition markdown body. */
-    agentBody: string;
-    /** CLAUDE.md content to include. */
-    claudeMd?: string;
-    /** AGENTS.md content to include. */
-    agentsMd?: string;
-    /** When true, use fork worker suffix instead of standard subagent suffix. */
-    isForkWorker: boolean;
+/** Shape of the plugin-related keys in settings.json. */
+interface IPluginSettings {
+    enabledPlugins: Record<string, boolean>;
+    extraKnownMarketplaces: Record<string, IPersistedMarketplaceSource>;
+}
+/** Centralized settings store for plugin configuration. */
+declare class PluginSettingsStore {
+    private readonly settingsPath;
+    constructor(settingsPath: string);
+    /** Read the full settings file from disk. */
+    private readAll;
+    /** Write the full settings file to disk. */
+    private writeAll;
+    /** Get the enabledPlugins map. */
+    getEnabledPlugins(): Record<string, boolean>;
+    /** Set a single plugin's enabled state. */
+    setPluginEnabled(pluginId: string, enabled: boolean): void;
+    /** Remove a plugin from enabledPlugins. */
+    removePluginEntry(pluginId: string): void;
+    /** Get all persisted marketplace sources. */
+    getMarketplaceSources(): Record<string, IPersistedMarketplaceSource>;
+    /** Add or update a marketplace source. */
+    setMarketplaceSource(name: string, source: IMarketplaceSource$1): void;
+    /** Remove a marketplace source. */
+    removeMarketplaceSource(name: string): void;
+    private getEnabledPluginsFrom;
+    private getMarketplaceSourcesFrom;
 }
-/**
- * Returns the standard subagent suffix appended to agent body for normal subagents.
- */
-declare function getSubagentSuffix(): string;
-/**
- * Returns the fork worker suffix for context:fork skill workers.
- */
-declare function getForkWorkerSuffix(): string;
-/**
- * Assembles the full system prompt for a subagent.
- *
- * Assembly order:
- * 1. Agent definition body
- * 2. CLAUDE.md content (if provided)
- * 3. AGENTS.md content (if provided)
- * 4. Framework suffix (fork worker OR standard subagent)
- */
-declare function assembleSubagentPrompt(options: ISubagentPromptOptions): string;
 
 /**
- * Definition of an agent that can be spawned as a subagent.
+ * Types for the BundlePlugin system.
  *
- * Built-in agents and custom (user-defined) agents share this shape.
- * Optional fields inherit from the parent session when omitted.
+ * A BundlePlugin is a directory-based plugin package that bundles
+ * skills, hooks, agents, and MCP server configurations.
  */
-interface IAgentDefinition {
-    /** Unique name used to reference the agent (e.g., 'Explore', 'Plan'). */
+/** Feature flags indicating what a bundle plugin provides. */
+interface IBundlePluginFeatures {
+    commands?: boolean;
+    agents?: boolean;
+    skills?: boolean;
+    hooks?: boolean;
+    mcp?: boolean;
+}
+/** Manifest read from `.claude-plugin/plugin.json`. */
+interface IBundlePluginManifest {
     name: string;
-    /** Human-readable description of the agent's purpose. */
+    version: string;
     description: string;
-    /** Markdown body content used as the agent's system prompt. */
-    systemPrompt: string;
-    /** Model override (e.g., 'claude-haiku-4-5', 'sonnet', 'opus'). Inherits parent model when omitted. */
-    model?: string;
-    /** Maximum number of agentic turns the subagent may execute. */
-    maxTurns?: number;
-    /** Allowlist of tool names. Only these tools are available when set. */
-    tools?: string[];
-    /** Denylist of tool names. These tools are removed from the inherited set. */
-    disallowedTools?: string[];
+    features: IBundlePluginFeatures;
+}
+/** A skill loaded from a bundle plugin's `skills/` directory. */
+interface IBundleSkill {
+    name: string;
+    description: string;
+    skillContent: string;
+    [key: string]: unknown;
+}
+/** A fully loaded bundle plugin with all its assets. */
+interface ILoadedBundlePlugin {
+    manifest: IBundlePluginManifest;
+    skills: IBundleSkill[];
+    commands: IBundleSkill[];
+    hooks: Record<string, unknown>;
+    mcpConfig?: unknown;
+    agents: string[];
+    pluginDir: string;
 }
+/** Map of plugin identifiers to enabled/disabled state. */
+type TEnabledPlugins = Record<string, boolean>;
 
 /**
- * Subagent session factory — assembles an isolated child Session for subagent execution.
+ * BundlePluginLoader — discovers and loads directory-based bundle plugins.
  *
- * Unlike `createSession`, this factory does not load config files or context from disk.
- * It receives pre-resolved config and context from the parent session, applies tool
- * filtering and model resolution from the agent definition, and creates a lightweight
- * Session suitable for subagent use.
+ * Scans the cache directory (`<pluginsDir>/cache/<marketplace>/<plugin>/<version>/`)
+ * for subdirectories containing `.claude-plugin/plugin.json`,
+ * reads manifests, loads skills (with frontmatter parsing), hooks, and agent definitions.
+ *
+ * For each plugin, the latest version directory (lexicographically last) is loaded.
  */
 
-/** Options for creating a subagent session. */
-interface ISubagentOptions {
-    /** Agent definition (built-in or custom). */
-    agentDefinition: IAgentDefinition;
-    /** Parent's resolved config (for provider, permissions, etc.). */
-    parentConfig: IResolvedConfig;
-    /** Parent's loaded context (CLAUDE.md, AGENTS.md). */
-    parentContext: ILoadedContext;
-    /** Parent session's available tools (to inherit/filter). */
-    parentTools: IToolWithEventService[];
-    /** AI provider instance. */
-    provider: IAIProvider;
-    /** Terminal output interface. */
-    terminal: ITerminalOutput;
-    /** Whether this is a fork worker (uses fork suffix instead of standard). */
-    isForkWorker?: boolean;
-    /** Permission mode from parent (bypassPermissions, acceptEdits, etc.). */
-    permissionMode?: TPermissionMode;
-    /** Permission handler from parent. */
-    permissionHandler?: TPermissionHandler;
-    /** Plugin hooks configuration from parent session. */
-    hooks?: Record<string, unknown>;
-    /** Hook type executors from parent session (prompt, agent, etc.). */
-    hookTypeExecutors?: IHookTypeExecutor[];
-    /** Streaming callback. */
-    onTextDelta?: (delta: string) => void;
-    /** Tool execution callback. */
-    onToolExecution?: (event: {
-        type: 'start' | 'end';
-        toolName: string;
-        toolArgs?: TToolArgs;
-        success?: boolean;
-    }) => void;
+/** Loader for directory-based bundle plugins from the cache directory. */
+declare class BundlePluginLoader {
+    private readonly pluginsDir;
+    private readonly enabledPlugins;
+    constructor(pluginsDir: string, enabledPlugins?: TEnabledPlugins);
+    /** Load all discovered and enabled bundle plugins (sync). */
+    loadPluginsSync(): ILoadedBundlePlugin[];
+    /** Load all discovered and enabled bundle plugins (async wrapper). */
+    loadAll(): Promise<ILoadedBundlePlugin[]>;
+    /**
+     * Discover and load plugins from the cache directory.
+     *
+     * Directory structure: `<pluginsDir>/cache/<marketplace>/<plugin>/<version>/`
+     * For each marketplace/plugin pair, the latest version (lexicographically last) is loaded.
+     */
+    private discoverAndLoad;
+    /** Read and validate a plugin.json manifest. Returns null on failure. */
+    private readManifest;
+    /**
+     * Check if a plugin is explicitly disabled.
+     * Checks both `name@marketplace` and `name` keys.
+     * Plugins not listed in enabledPlugins are enabled by default.
+     */
+    private isDisabled;
+    /** Load a single plugin's skills, hooks, agents, and MCP config. */
+    private loadPlugin;
+    /** Load skills from the plugin's skills/ directory. */
+    private loadSkills;
+    /** Load commands from the plugin's commands/ directory (flat .md files). */
+    private loadCommands;
+    /** Load hooks from hooks/hooks.json if present. */
+    private loadHooks;
+    /** Load MCP server configuration if present. Checks `.mcp.json` at plugin root first. */
+    private loadMcpConfig;
+    /** Load agent definitions from agents/ directory if present. */
+    private loadAgents;
 }
-/**
- * Create a fully-configured Session for subagent execution.
- *
- * Assembles provider, tools, and system prompt from parent context and
- * agent definition, then returns a new Session instance.
- */
-declare function createSubagentSession(options: ISubagentOptions): Session;
 
 /**
- * Subagent transcript logger — creates a FileSessionLogger that writes
- * subagent session logs into a subdirectory of the parent session's log folder.
- *
- * Log structure:
- *   {baseLogsDir}/{parentSessionId}/subagents/{agentId}.jsonl
- */
-
-/**
- * Create a FileSessionLogger for a subagent session.
- *
- * The logger writes JSONL files into a `subagents/` subdirectory under the
- * parent session's log folder. The directory is created if it does not exist.
- *
- * @param parentSessionId - ID of the parent session (used as directory name)
- * @param agentId - Unique identifier for this subagent run
- * @param baseLogsDir - Root logs directory (e.g., `.robota/logs`)
- * @returns A FileSessionLogger writing to the subagent directory
- */
-declare function createSubagentLogger(parentSessionId: string, _agentId: string, baseLogsDir: string): FileSessionLogger;
-/**
- * Resolve the subagent log directory path without creating it.
- *
- * Useful when the caller needs the path for display or configuration
- * but does not want to create the directory immediately.
- *
- * @param parentSessionId - ID of the parent session
- * @param baseLogsDir - Root logs directory
- * @returns The resolved subagent log directory path
+ * Shared types for marketplace client and registry.
  */
-declare function resolveSubagentLogDir(parentSessionId: string, baseLogsDir: string): string;
+/** Source specification for a marketplace. */
+type IMarketplaceSource = {
+    type: 'github';
+    repo: string;
+    ref?: string;
+} | {
+    type: 'git';
+    url: string;
+    ref?: string;
+} | {
+    type: 'local';
+    path: string;
+} | {
+    type: 'url';
+    url: string;
+};
+/** A single plugin entry in a marketplace manifest. */
+interface IMarketplacePluginEntry {
+    name: string;
+    title: string;
+    description: string;
+    source: string | {
+        type: 'github';
+        repo: string;
+    } | {
+        type: 'url';
+        url: string;
+    };
+    tags: string[];
+}
+/** Manifest format read from `.claude-plugin/marketplace.json`. */
+interface IMarketplaceManifest {
+    name: string;
+    version: string;
+    plugins: IMarketplacePluginEntry[];
+}
+/** Entry in known_marketplaces.json. */
+interface IKnownMarketplaceEntry {
+    source: IMarketplaceSource;
+    installLocation: string;
+    lastUpdated: string;
+}
+/** Shape of known_marketplaces.json. */
+type IKnownMarketplacesRegistry = Record<string, IKnownMarketplaceEntry>;
+/** Exec function type for running shell commands. */
+type ExecFn$1 = (command: string, options: {
+    timeout: number;
+    stdio?: string;
+}) => string | Buffer;
+/** Options for constructing a MarketplaceClient. */
+interface IMarketplaceClientOptions {
+    /** Base plugins directory (e.g., `~/.robota/plugins`). */
+    pluginsDir: string;
+    /** Custom exec function for testing (replaces child_process.execSync). */
+    exec?: ExecFn$1;
+}
 
 /**
- * Session initialization helpers for InteractiveSession.
+ * MarketplaceClient — manages marketplace registries via shallow git clones.
  *
- * Handles async config/context loading, plugin merging, and session creation.
- * Also provides session-restore (resume/fork) logic.
+ * Marketplaces are git repositories containing `.claude-plugin/marketplace.json`.
+ * They are cloned to `~/.robota/plugins/marketplaces/<name>/` and tracked
+ * in `known_marketplaces.json`.
  */
 
-/** Standard construction: cwd + provider. Config/context loaded internally. */
-interface IInteractiveSessionStandardOptions {
-    cwd: string;
-    provider: IAIProvider;
-    permissionMode?: ICreateSessionOptions['permissionMode'];
-    maxTurns?: number;
-    permissionHandler?: TInteractivePermissionHandler;
-    sessionStore?: SessionStore;
-    sessionName?: string;
-    resumeSessionId?: string;
-    forkSession?: boolean;
-}
-/** Test/advanced construction: inject pre-built session directly. */
-interface IInteractiveSessionInjectedOptions {
-    session: Session;
-    cwd?: string;
-    provider?: IAIProvider;
-    permissionMode?: ICreateSessionOptions['permissionMode'];
-    maxTurns?: number;
-    permissionHandler?: TInteractivePermissionHandler;
-    sessionStore?: SessionStore;
-    sessionName?: string;
-    resumeSessionId?: string;
-    forkSession?: boolean;
+/** Manages marketplace registries via shallow git clones. */
+declare class MarketplaceClient {
+    private readonly pluginsDir;
+    private readonly exec;
+    private readonly marketplacesDir;
+    private readonly registryPath;
+    constructor(options: IMarketplaceClientOptions);
+    /**
+     * Add a marketplace by cloning its repository.
+     *
+     * 1. Shallow git clone (`--depth 1`) to `marketplaces/<name>/`.
+     * 2. Read `.claude-plugin/marketplace.json` for the `name` field.
+     * 3. Register in `known_marketplaces.json`.
+     *
+     * Returns the registered marketplace name from the manifest.
+     */
+    addMarketplace(source: IMarketplaceSource): string;
+    /**
+     * Remove a marketplace.
+     * Uninstalls all plugins from that marketplace, then deletes the clone directory
+     * and removes from the registry.
+     */
+    removeMarketplace(name: string): void;
+    /**
+     * Update a marketplace by running git pull on its clone.
+     * The manifest is re-read from disk on demand (via fetchManifest), so the
+     * updated manifest is automatically available after pull.
+     */
+    updateMarketplace(name: string): void;
+    /** List all registered marketplaces. */
+    listMarketplaces(): Array<{
+        name: string;
+        source: IMarketplaceSource;
+        lastUpdated: string;
+    }>;
+    /** Read the marketplace manifest from a registered marketplace's clone. */
+    fetchManifest(marketplaceName: string): IMarketplaceManifest;
+    /** Get the clone directory path for a registered marketplace. */
+    getMarketplaceDir(name: string): string;
+    /**
+     * Get the current git SHA (first 12 chars) for a marketplace clone.
+     * Used as a version identifier when plugins lack explicit versions.
+     */
+    getMarketplaceSha(name: string): string;
+    /** List all available plugins across all marketplaces. */
+    listAvailablePlugins(): Array<IMarketplacePluginEntry & {
+        marketplace: string;
+    }>;
+    /** Resolve a marketplace source to a git clone URL. */
+    private resolveCloneUrl;
+    /** Read and parse a marketplace.json from a file path. */
+    private readManifestFromPath;
+    /** Default exec implementation using child_process. */
+    private defaultExec;
 }
-/** Union of standard and injected construction options. */
-type IInteractiveSessionOptions = IInteractiveSessionStandardOptions | IInteractiveSessionInjectedOptions;
 
 /**
- * InteractiveSession — the single entry point for all SDK consumers.
- *
- * Wraps Session (composition). Manages streaming text accumulation,
- * tool execution state tracking, prompt queuing, abort orchestration,
- * message history, and system command execution.
+ * BundlePluginInstaller — installs, uninstalls, enables, and disables bundle plugins.
  *
- * Config/context loading is internal. Consumer provides cwd + provider.
+ * Resolves plugin sources from marketplace manifests, copies/clones to the
+ * cache directory, and tracks installations in `installed_plugins.json`.
  */
 
-declare class InteractiveSession {
-    private session;
-    private readonly commandExecutor;
-    private readonly listeners;
-    private initialized;
-    private initPromise;
-    private streamingText;
-    private flushTimer;
-    private activeTools;
-    private executing;
-    private pendingPrompt;
-    private pendingDisplayInput;
-    private pendingRawInput;
-    private history;
-    private sessionStore?;
-    private sessionName?;
-    private cwd?;
-    private pendingRestoreMessages;
-    private resumeSessionId?;
-    private forkSession;
-    constructor(options: IInteractiveSessionOptions);
-    private initializeAsync;
-    private ensureInitialized;
-    private getSessionOrThrow;
-    on<E extends TInteractiveEventName>(event: E, handler: IInteractiveSessionEvents[E]): void;
-    off<E extends TInteractiveEventName>(event: E, handler: IInteractiveSessionEvents[E]): void;
-    private emit;
-    submit(input: string, displayInput?: string, rawInput?: string): Promise<void>;
-    executeCommand(name: string, args: string): Promise<{
-        message: string;
-        success: boolean;
-        data?: Record<string, unknown>;
-    } | null>;
-    listCommands(): Array<{
-        name: string;
-        description: string;
-    }>;
-    abort(): void;
-    cancelQueue(): void;
-    private clearPendingQueue;
-    isExecuting(): boolean;
-    getPendingPrompt(): string | null;
-    getFullHistory(): IHistoryEntry[];
-    getMessages(): TUniversalMessage[];
-    getStreamingText(): string;
-    getActiveTools(): IToolState[];
-    getContextState(): IContextWindowState;
-    getName(): string | undefined;
-    getSession(): Session;
-    setName(name: string): void;
-    attachTransport(transport: ITransportAdapter): void;
-    private executePrompt;
-    private handleTextDelta;
-    private handleToolExecution;
-    private clearStreaming;
-    private flushStreaming;
+/** Record of an installed plugin in installed_plugins.json. */
+interface IInstalledPluginRecord {
+    pluginName: string;
+    marketplace: string;
+    version: string;
+    installPath: string;
+    installedAt: string;
+}
+/** Shape of installed_plugins.json. */
+type IInstalledPluginsRegistry = Record<string, IInstalledPluginRecord>;
+/** Exec function type for running shell commands. */
+type ExecFn = (command: string, options: {
+    timeout: number;
+    stdio?: string;
+}) => string | Buffer;
+/** Options for constructing a BundlePluginInstaller. */
+interface IBundlePluginInstallerOptions {
+    /** Base plugins directory (e.g., `~/.robota/plugins`). */
+    pluginsDir: string;
+    /** Shared settings store for enable/disable persistence. */
+    settingsStore: PluginSettingsStore;
+    /** MarketplaceClient for reading marketplace manifests. */
+    marketplaceClient: MarketplaceClient;
+    /** Custom exec function for testing (replaces child_process.execSync). */
+    exec?: ExecFn;
+}
+/** Installs, uninstalls, enables, and disables bundle plugins. */
+declare class BundlePluginInstaller {
+    private readonly pluginsDir;
+    private readonly cacheDir;
+    private readonly registryPath;
+    private readonly settingsStore;
+    private readonly marketplaceClient;
+    private readonly exec;
+    constructor(options: IBundlePluginInstallerOptions);
+    /**
+     * Install a plugin from a marketplace.
+     *
+     * 1. Read marketplace manifest to find the plugin entry.
+     * 2. Resolve source (relative path, github, or url).
+     * 3. Copy/clone to `cache/<marketplace>/<plugin>/<version>/`.
+     * 4. Record in `installed_plugins.json`.
+     */
+    install(pluginName: string, marketplaceName: string): Promise<void>;
+    /**
+     * Uninstall a plugin.
+     * Removes from cache and from installed_plugins.json.
+     */
+    uninstall(pluginId: string): Promise<void>;
+    /** Enable a plugin by setting its enabledPlugins entry to true. */
+    enable(pluginId: string): Promise<void>;
+    /** Disable a plugin by setting its enabledPlugins entry to false. */
+    disable(pluginId: string): Promise<void>;
+    /** Get all installed plugins. */
+    getInstalledPlugins(): IInstalledPluginsRegistry;
+    /** Get plugins installed from a specific marketplace. */
+    getPluginsByMarketplace(marketplaceName: string): IInstalledPluginRecord[];
+    /** Resolve the version for a plugin entry. */
+    private resolveVersion;
+    /**
+     * Normalize source object — Claude Code manifests use `source` key instead of `type`.
+     * e.g., { source: "url", url: "..." } → { type: "url", url: "..." }
+     */
+    private normalizeSource;
+    /** Resolve the source and install the plugin. */
+    private resolveAndInstall;
+    /** Clone a git repository to the target directory. */
+    private cloneToDir;
+    /** Read the installed_plugins.json registry. */
+    private readRegistry;
+    /** Write the installed_plugins.json registry. */
+    private writeRegistry;
+    /** Default exec implementation using child_process. */
+    private defaultExec;
 }
 
 /**
- * createQuery() — factory that returns a prompt-only convenience function.
+ * Command source that discovers skills and commands from loaded BundlePlugins.
  *
- * Usage:
- *   const query = createQuery({ provider });
- *   const answer = await query('What files are here?');
+ * - Skills: exposed as `/name` with `(plugin-name)` hint in description.
+ * - Commands: exposed as `/plugin:command` (already namespaced by the loader).
  */
+declare class PluginCommandSource implements ICommandSource {
+    readonly name = "plugin";
+    private readonly plugins;
+    constructor(plugins: ILoadedBundlePlugin[]);
+    getCommands(): ICommand[];
+}
 
-interface ICreateQueryOptions {
-    /** AI provider instance (required). */
-    provider: IAIProvider;
-    /** Working directory. Defaults to process.cwd(). */
-    cwd?: string;
-    /** Permission mode. Defaults to 'bypassPermissions' for programmatic use. */
-    permissionMode?: TPermissionMode;
-    /** Maximum agentic turns per query. */
-    maxTurns?: number;
-    /** Permission handler callback. */
-    permissionHandler?: TInteractivePermissionHandler;
-    /** Streaming text callback. */
-    onTextDelta?: (delta: string) => void;
+/**
+ * Build a skill prompt from slash command input.
+ * Supports variable substitution and shell command preprocessing.
+ */
+
+/** Context variables available during skill prompt processing */
+interface SkillPromptContext {
+    /** Current session ID — substituted for ${CLAUDE_SESSION_ID} */
+    sessionId?: string;
+    /** Directory containing SKILL.md — substituted for ${CLAUDE_SKILL_DIR} */
+    skillDir?: string;
 }
 /**
- * Create a prompt-only query function bound to a provider.
- *
- * ```typescript
- * import { createQuery } from '@robota-sdk/agent-sdk';
- * import { AnthropicProvider } from '@robota-sdk/agent-provider-anthropic';
+ * Substitute variables in skill content.
  *
- * const query = createQuery({ provider: new AnthropicProvider({ apiKey: '...' }) });
- * const answer = await query('List all TypeScript files');
- * ```
+ * Supported variables:
+ * - `$ARGUMENTS` — all arguments passed to the skill
+ * - `$ARGUMENTS[N]` — argument by index (0-based)
+ * - `$N` — shorthand for `$ARGUMENTS[N]` (single digit, 0-9)
+ * - `${CLAUDE_SESSION_ID}` — current session ID
+ * - `${CLAUDE_SKILL_DIR}` — directory containing SKILL.md
  */
-declare function createQuery(options: ICreateQueryOptions): (prompt: string) => Promise<string>;
+declare function substituteVariables(content: string, args: string, context?: SkillPromptContext): string;
+/**
+ * Preprocess shell commands in skill content.
+ * Matches `` !`...` `` patterns and replaces them with command output.
+ * Commands have a 5-second timeout.
+ */
+declare function preprocessShellCommands(content: string): Promise<string>;
+/** Build a skill prompt from a slash command input and registry */
+declare function buildSkillPrompt(input: string, registry: CommandRegistry, context?: SkillPromptContext): Promise<string | null>;
 
-/** A command entry */
-interface ICommand {
-    /** Command name without slash (e.g., "mode") */
-    name: string;
-    /** Short description shown in autocomplete */
-    description: string;
-    /** Source identifier (e.g., "builtin", "skill") */
-    source: string;
-    /** Subcommands for hierarchical menus */
-    subcommands?: ICommand[];
-    /** Execute the command. Args is everything after the command name. */
-    execute?: (args: string) => void | Promise<void>;
-    /** Full SKILL.md content (only for skill commands) */
-    skillContent?: string;
-    /** Hint for the expected argument (Claude Code frontmatter) */
-    argumentHint?: string;
-    /** When true, models cannot invoke this skill autonomously */
-    disableModelInvocation?: boolean;
-    /** When false, users cannot invoke this skill directly */
-    userInvocable?: boolean;
-    /** List of tools this skill is allowed to use */
-    allowedTools?: string[];
-    /** Preferred model for executing this skill */
-    model?: string;
-    /** Effort level hint for the skill */
-    effort?: string;
-    /** Context scope for the skill (e.g., "project") */
-    context?: string;
-    /** Agent identity to use when executing this skill */
+/**
+ * Skill execution logic.
+ * Handles both fork-based (subagent) and inject-based (user message) execution.
+ */
+
+/** Options passed to the fork execution callback */
+interface IForkExecutionOptions {
+    /** Agent identity to use (e.g., 'Explore', 'Plan') */
     agent?: string;
-    /** Plugin installation directory (plugin skills/commands only) */
-    pluginDir?: string;
+    /** Tools the subagent is allowed to use */
+    allowedTools?: string[];
 }
-/** A source that provides commands */
-interface ICommandSource {
-    name: string;
-    getCommands(): ICommand[];
+/** Callback interface for skill execution infrastructure */
+interface ISkillExecutionCallbacks {
+    /**
+     * Run skill content in an isolated subagent session.
+     * The content becomes the subagent's prompt.
+     * Returns the subagent's response.
+     */
+    runInFork?: (content: string, options: IForkExecutionOptions) => Promise<string>;
 }
-
-/** Aggregates commands from multiple sources */
-declare class CommandRegistry {
-    private sources;
-    addSource(source: ICommandSource): void;
-    /** Get all commands, optionally filtered by prefix */
-    getCommands(filter?: string): ICommand[];
-    /** Resolve a short name to its fully qualified plugin:name form */
-    resolveQualifiedName(shortName: string): string | null;
-    /** Get subcommands for a specific command */
-    getSubcommands(commandName: string): ICommand[];
+/** Result of skill execution */
+interface ISkillExecutionResult {
+    /** Execution mode used */
+    mode: 'fork' | 'inject';
+    /** For inject mode: the prompt to send as a user message */
+    prompt?: string;
+    /** For fork mode: the subagent's response */
+    result?: string;
 }
+/**
+ * Execute a skill command.
+ *
+ * When `context: 'fork'`, the skill runs in an isolated subagent session
+ * via the `runInFork` callback. Throws if `runInFork` is not available.
+ * For non-fork skills, the content is returned as a prompt for injection
+ * into the current session.
+ */
+declare function executeSkill(skill: ICommand, args: string, callbacks: ISkillExecutionCallbacks, context?: SkillPromptContext): Promise<ISkillExecutionResult>;
 
-/** Command source for built-in commands */
-declare class BuiltinCommandSource implements ICommandSource {
-    readonly name = "builtin";
-    private readonly commands;
-    constructor();
-    getCommands(): ICommand[];
+type TBackgroundJobWaitPolicy = 'detached' | 'wait_all' | 'wait_any' | 'manual';
+type TBackgroundJobGroupStatus = 'running' | 'completed';
+interface IBackgroundJobResultEnvelope {
+    taskId: string;
+    label: string;
+    status: TBackgroundTaskStatus;
+    summary?: string;
+    outputRef?: string;
+    error?: IBackgroundTaskError;
+    startedAt?: string;
+    completedAt?: string;
 }
-
-interface IFrontmatter {
-    name?: string;
-    description?: string;
-    argumentHint?: string;
-    disableModelInvocation?: boolean;
-    userInvocable?: boolean;
-    allowedTools?: string[];
-    model?: string;
-    effort?: string;
-    context?: string;
-    agent?: string;
+interface IBackgroundJobGroupState {
+    id: string;
+    parentSessionId: string;
+    waitPolicy: TBackgroundJobWaitPolicy;
+    taskIds: string[];
+    status: TBackgroundJobGroupStatus;
+    createdAt: string;
+    updatedAt: string;
+    label?: string;
+    completedAt?: string;
+    results: IBackgroundJobResultEnvelope[];
 }
-/** Parse YAML-like frontmatter between --- markers */
-declare function parseFrontmatter(content: string): IFrontmatter | null;
-/** Command source that discovers skills from multiple directories */
-declare class SkillCommandSource implements ICommandSource {
-    readonly name = "skill";
-    private readonly cwd;
-    private readonly home;
-    private cachedCommands;
-    constructor(cwd: string, home?: string);
-    getCommands(): ICommand[];
-    getModelInvocableSkills(): ICommand[];
-    getUserInvocableSkills(): ICommand[];
+interface IBackgroundJobGroupSummary {
+    groupId: string;
+    status: TBackgroundJobGroupStatus;
+    total: number;
+    completed: number;
+    failed: number;
+    cancelled: number;
+    pending: number;
+    lines: string[];
 }
-
-/**
- * PluginSettingsStore — single point of read/write for plugin-related settings.
- *
- * Shared by MarketplaceClient and BundlePluginInstaller to prevent
- * concurrent writes from overwriting each other's changes.
- */
-/** Source type for a marketplace registry. */
-type IMarketplaceSource$1 = {
-    type: 'github';
-    repo: string;
-    ref?: string;
-} | {
-    type: 'git';
-    url: string;
-    ref?: string;
+interface IBackgroundJobGroupCreateRequest {
+    parentSessionId: string;
+    waitPolicy: TBackgroundJobWaitPolicy;
+    taskIds: string[];
+    label?: string;
+}
+type TBackgroundJobGroupEvent = {
+    type: 'background_job_group_created';
+    group: IBackgroundJobGroupState;
 } | {
-    type: 'local';
-    path: string;
+    type: 'background_job_group_updated';
+    group: IBackgroundJobGroupState;
 } | {
-    type: 'url';
-    url: string;
+    type: 'background_job_group_completed';
+    group: IBackgroundJobGroupState;
 };
-/** Persisted marketplace source entry. */
-interface IPersistedMarketplaceSource {
-    source: IMarketplaceSource$1;
-}
-/** Shape of the plugin-related keys in settings.json. */
-interface IPluginSettings {
-    enabledPlugins: Record<string, boolean>;
-    extraKnownMarketplaces: Record<string, IPersistedMarketplaceSource>;
+type TBackgroundJobGroupEventListener = (event: TBackgroundJobGroupEvent) => void;
+type TBackgroundJobGroupIdFactory = (request: IBackgroundJobGroupCreateRequest) => string;
+interface IBackgroundJobOrchestratorOptions {
+    manager: IBackgroundTaskManager;
+    now?: () => string;
+    idFactory?: TBackgroundJobGroupIdFactory;
+    initialGroups?: readonly IBackgroundJobGroupState[];
 }
-/** Centralized settings store for plugin configuration. */
-declare class PluginSettingsStore {
-    private readonly settingsPath;
-    constructor(settingsPath: string);
-    /** Read the full settings file from disk. */
-    private readAll;
-    /** Write the full settings file to disk. */
-    private writeAll;
-    /** Get the enabledPlugins map. */
-    getEnabledPlugins(): Record<string, boolean>;
-    /** Set a single plugin's enabled state. */
-    setPluginEnabled(pluginId: string, enabled: boolean): void;
-    /** Remove a plugin from enabledPlugins. */
-    removePluginEntry(pluginId: string): void;
-    /** Get all persisted marketplace sources. */
-    getMarketplaceSources(): Record<string, IPersistedMarketplaceSource>;
-    /** Add or update a marketplace source. */
-    setMarketplaceSource(name: string, source: IMarketplaceSource$1): void;
-    /** Remove a marketplace source. */
-    removeMarketplaceSource(name: string): void;
-    private getEnabledPluginsFrom;
-    private getMarketplaceSourcesFrom;
+declare class BackgroundJobOrchestrator {
+    private readonly manager;
+    private readonly now;
+    private readonly idFactory;
+    private readonly unsubscribeManager;
+    private readonly listeners;
+    private readonly groups;
+    private sequence;
+    constructor(options: IBackgroundJobOrchestratorOptions);
+    createGroup(request: IBackgroundJobGroupCreateRequest): IBackgroundJobGroupState;
+    listGroups(): IBackgroundJobGroupState[];
+    getGroup(groupId: string): IBackgroundJobGroupState | undefined;
+    waitGroup(groupId: string): Promise<IBackgroundJobGroupState>;
+    subscribe(listener: TBackgroundJobGroupEventListener): () => void;
+    dispose(): void;
+    private nextGroupId;
+    private restoreGroup;
+    private createRecord;
+    private captureExistingTerminalTasks;
+    private handleTaskEvent;
+    private captureTask;
+    private evaluateCompletion;
+    private emit;
 }
+declare function summarizeBackgroundJobGroup(group: IBackgroundJobGroupState): IBackgroundJobGroupSummary;
 
 /**
- * Types for the BundlePlugin system.
- *
- * A BundlePlugin is a directory-based plugin package that bundles
- * skills, hooks, agents, and MCP server configurations.
+ * Types for InteractiveSession — event-driven session wrapper.
  */
-/** Feature flags indicating what a bundle plugin provides. */
-interface IBundlePluginFeatures {
-    commands?: boolean;
-    agents?: boolean;
-    skills?: boolean;
-    hooks?: boolean;
-    mcp?: boolean;
+
+/** Permission handler result — SDK-owned type (mirrors agent-sessions TPermissionResult).
+ *  true = allow, false = deny, 'allow-session' = allow and remember for this session. */
+type TPermissionResultValue = boolean | 'allow-session';
+/** Tool execution state visible to clients. */
+interface IToolState {
+    toolName: string;
+    firstArg: string;
+    isRunning: boolean;
+    result?: 'success' | 'error' | 'denied';
+    diffLines?: IDiffLine[];
+    diffFile?: string;
 }
-/** Manifest read from `.claude-plugin/plugin.json`. */
-interface IBundlePluginManifest {
-    name: string;
-    version: string;
-    description: string;
-    features: IBundlePluginFeatures;
+/** A single diff line for Edit tool display. */
+interface IDiffLine {
+    type: 'add' | 'remove' | 'context';
+    text: string;
+    lineNumber: number;
 }
-/** A skill loaded from a bundle plugin's `skills/` directory. */
-interface IBundleSkill {
+/** Result of a completed prompt execution. */
+interface IExecutionResult {
+    response: string;
+    history: IHistoryEntry[];
+    toolSummaries: IToolSummary[];
+    contextState: IContextWindowState;
+}
+/** Summary of a tool call extracted from history. */
+interface IToolSummary {
     name: string;
-    description: string;
-    skillContent: string;
-    [key: string]: unknown;
+    args: string;
 }
-/** A fully loaded bundle plugin with all its assets. */
-interface ILoadedBundlePlugin {
-    manifest: IBundlePluginManifest;
-    skills: IBundleSkill[];
-    commands: IBundleSkill[];
-    hooks: Record<string, unknown>;
-    mcpConfig?: unknown;
-    agents: string[];
-    pluginDir: string;
+/** Permission handler delegate — clients provide their own UI. */
+type TInteractivePermissionHandler = (toolName: string, toolArgs: TToolArgs) => Promise<TPermissionResultValue>;
+/** Events emitted by InteractiveSession. */
+interface IInteractiveSessionEvents {
+    text_delta: (delta: string) => void;
+    tool_start: (state: IToolState) => void;
+    tool_end: (state: IToolState) => void;
+    thinking: (isThinking: boolean) => void;
+    complete: (result: IExecutionResult) => void;
+    error: (error: Error) => void;
+    context_update: (state: IContextWindowState) => void;
+    interrupted: (result: IExecutionResult) => void;
+    background_task_event: (event: TBackgroundTaskEvent) => void;
+    background_job_group_event: (event: TBackgroundJobGroupEvent) => void;
 }
-/** Map of plugin identifiers to enabled/disabled state. */
-type TEnabledPlugins = Record<string, boolean>;
-
+type TInteractiveEventName = keyof IInteractiveSessionEvents;
 /**
- * BundlePluginLoader — discovers and loads directory-based bundle plugins.
- *
- * Scans the cache directory (`<pluginsDir>/cache/<marketplace>/<plugin>/<version>/`)
- * for subdirectories containing `.claude-plugin/plugin.json`,
- * reads manifests, loads skills (with frontmatter parsing), hooks, and agent definitions.
- *
- * For each plugin, the latest version directory (lexicographically last) is loaded.
+ * Common interface for all transport adapters.
+ * Each transport exposes InteractiveSession over a specific protocol.
  */
-
-/** Loader for directory-based bundle plugins from the cache directory. */
-declare class BundlePluginLoader {
-    private readonly pluginsDir;
-    private readonly enabledPlugins;
-    constructor(pluginsDir: string, enabledPlugins?: TEnabledPlugins);
-    /** Load all discovered and enabled bundle plugins (sync). */
-    loadPluginsSync(): ILoadedBundlePlugin[];
-    /** Load all discovered and enabled bundle plugins (async wrapper). */
-    loadAll(): Promise<ILoadedBundlePlugin[]>;
-    /**
-     * Discover and load plugins from the cache directory.
-     *
-     * Directory structure: `<pluginsDir>/cache/<marketplace>/<plugin>/<version>/`
-     * For each marketplace/plugin pair, the latest version (lexicographically last) is loaded.
-     */
-    private discoverAndLoad;
-    /** Read and validate a plugin.json manifest. Returns null on failure. */
-    private readManifest;
-    /**
-     * Check if a plugin is explicitly disabled.
-     * Checks both `name@marketplace` and `name` keys.
-     * Plugins not listed in enabledPlugins are enabled by default.
-     */
-    private isDisabled;
-    /** Load a single plugin's skills, hooks, agents, and MCP config. */
-    private loadPlugin;
-    /** Load skills from the plugin's skills/ directory. */
-    private loadSkills;
-    /** Load commands from the plugin's commands/ directory (flat .md files). */
-    private loadCommands;
-    /** Load hooks from hooks/hooks.json if present. */
-    private loadHooks;
-    /** Load MCP server configuration if present. Checks `.mcp.json` at plugin root first. */
-    private loadMcpConfig;
-    /** Load agent definitions from agents/ directory if present. */
-    private loadAgents;
+interface ITransportAdapter {
+    /** Human-readable transport name (e.g., 'http', 'ws', 'mcp', 'headless') */
+    readonly name: string;
+    /** Attach an InteractiveSession to this transport. */
+    attach(session: InteractiveSession): void;
+    /** Start serving. What this means depends on the transport. */
+    start(): Promise<void>;
+    /** Stop serving and clean up resources. */
+    stop(): Promise<void>;
 }
 
 /**
- * Shared types for marketplace client and registry.
+ * Definition of an agent that can be spawned as a subagent.
+ *
+ * Built-in agents and custom (user-defined) agents share this shape.
+ * Optional fields inherit from the parent session when omitted.
  */
-/** Source specification for a marketplace. */
-type IMarketplaceSource = {
-    type: 'github';
-    repo: string;
-    ref?: string;
-} | {
-    type: 'git';
-    url: string;
-    ref?: string;
-} | {
-    type: 'local';
-    path: string;
-} | {
-    type: 'url';
-    url: string;
-};
-/** A single plugin entry in a marketplace manifest. */
-interface IMarketplacePluginEntry {
+interface IAgentDefinition {
+    /** Unique name used to reference the agent (e.g., 'Explore', 'Plan'). */
     name: string;
-    title: string;
+    /** Human-readable description of the agent's purpose. */
     description: string;
-    source: string | {
-        type: 'github';
-        repo: string;
-    } | {
-        type: 'url';
-        url: string;
-    };
-    tags: string[];
-}
-/** Manifest format read from `.claude-plugin/marketplace.json`. */
-interface IMarketplaceManifest {
-    name: string;
-    version: string;
-    plugins: IMarketplacePluginEntry[];
-}
-/** Entry in known_marketplaces.json. */
-interface IKnownMarketplaceEntry {
-    source: IMarketplaceSource;
-    installLocation: string;
-    lastUpdated: string;
-}
-/** Shape of known_marketplaces.json. */
-type IKnownMarketplacesRegistry = Record<string, IKnownMarketplaceEntry>;
-/** Exec function type for running shell commands. */
-type ExecFn$1 = (command: string, options: {
-    timeout: number;
-    stdio?: string;
-}) => string | Buffer;
-/** Options for constructing a MarketplaceClient. */
-interface IMarketplaceClientOptions {
-    /** Base plugins directory (e.g., `~/.robota/plugins`). */
-    pluginsDir: string;
-    /** Custom exec function for testing (replaces child_process.execSync). */
-    exec?: ExecFn$1;
+    /** Markdown body content used as the agent's system prompt. */
+    systemPrompt: string;
+    /** Model override (e.g., 'claude-haiku-4-5', 'sonnet', 'opus'). Inherits parent model when omitted. */
+    model?: string;
+    /** Maximum number of agentic turns the subagent may execute. */
+    maxTurns?: number;
+    /** Allowlist of tool names. Only these tools are available when set. */
+    tools?: string[];
+    /** Denylist of tool names. These tools are removed from the inherited set. */
+    disallowedTools?: string[];
 }
 
 /**
- * MarketplaceClient — manages marketplace registries via shallow git clones.
- *
- * Marketplaces are git repositories containing `.claude-plugin/marketplace.json`.
- * They are cloned to `~/.robota/plugins/marketplaces/<name>/` and tracked
- * in `known_marketplaces.json`.
+ * Zod schemas and TypeScript types for Robota CLI settings
  */
 
-/** Manages marketplace registries via shallow git clones. */
-declare class MarketplaceClient {
-    private readonly pluginsDir;
-    private readonly exec;
-    private readonly marketplacesDir;
-    private readonly registryPath;
-    constructor(options: IMarketplaceClientOptions);
-    /**
-     * Add a marketplace by cloning its repository.
-     *
-     * 1. Shallow git clone (`--depth 1`) to `marketplaces/<name>/`.
-     * 2. Read `.claude-plugin/marketplace.json` for the `name` field.
-     * 3. Register in `known_marketplaces.json`.
-     *
-     * Returns the registered marketplace name from the manifest.
-     */
-    addMarketplace(source: IMarketplaceSource): string;
-    /**
-     * Remove a marketplace.
-     * Uninstalls all plugins from that marketplace, then deletes the clone directory
-     * and removes from the registry.
-     */
-    removeMarketplace(name: string): void;
-    /**
-     * Update a marketplace by running git pull on its clone.
-     * The manifest is re-read from disk on demand (via fetchManifest), so the
-     * updated manifest is automatically available after pull.
-     */
-    updateMarketplace(name: string): void;
-    /** List all registered marketplaces. */
-    listMarketplaces(): Array<{
+/**
+ * Fully resolved config after merging all settings files and applying defaults.
+ */
+interface IResolvedConfig {
+    defaultTrustLevel: 'safe' | 'moderate' | 'full';
+    /** Response language code (e.g., "ko", "en"). Undefined = no language constraint. */
+    language?: string;
+    /** Active provider profile key when providers/currentProvider are used. */
+    currentProvider?: string;
+    provider: {
         name: string;
-        source: IMarketplaceSource;
-        lastUpdated: string;
-    }>;
-    /** Read the marketplace manifest from a registered marketplace's clone. */
-    fetchManifest(marketplaceName: string): IMarketplaceManifest;
-    /** Get the clone directory path for a registered marketplace. */
-    getMarketplaceDir(name: string): string;
-    /**
-     * Get the current git SHA (first 12 chars) for a marketplace clone.
-     * Used as a version identifier when plugins lack explicit versions.
-     */
-    getMarketplaceSha(name: string): string;
-    /** List all available plugins across all marketplaces. */
-    listAvailablePlugins(): Array<IMarketplacePluginEntry & {
-        marketplace: string;
+        model: string;
+        apiKey: string | undefined;
+        baseURL?: string;
+        timeout?: number;
+    };
+    permissions: {
+        allow: string[];
+        deny: string[];
+    };
+    env: Record<string, string>;
+    hooks?: THooksConfig;
+    /** Plugin enablement map: plugin name -> enabled/disabled */
+    enabledPlugins?: Record<string, boolean>;
+    /** Extra marketplace sources: name -> { source } */
+    extraKnownMarketplaces?: Record<string, {
+        source: {
+            type: string;
+            repo?: string;
+            url?: string;
+            path?: string;
+            ref?: string;
+        };
     }>;
-    /** Resolve a marketplace source to a git clone URL. */
-    private resolveCloneUrl;
-    /** Read and parse a marketplace.json from a file path. */
-    private readManifestFromPath;
-    /** Default exec implementation using child_process. */
-    private defaultExec;
+}
+
+interface ILoadedContext {
+    /** Concatenated content of all AGENTS.md files found (root-first) */
+    agentsMd: string;
+    /** Concatenated content of all CLAUDE.md files found (root-first) */
+    claudeMd: string;
+    /** Extracted "Compact Instructions" section from CLAUDE.md, if present */
+    compactInstructions?: string;
 }
 
 /**
- * BundlePluginInstaller — installs, uninstalls, enables, and disables bundle plugins.
+ * Subagent session factory — assembles an isolated child Session for subagent execution.
  *
- * Resolves plugin sources from marketplace manifests, copies/clones to the
- * cache directory, and tracks installations in `installed_plugins.json`.
+ * Unlike `createSession`, this factory does not load config files or context from disk.
+ * It receives pre-resolved config and context from the parent session, applies tool
+ * filtering and model resolution from the agent definition, and creates a lightweight
+ * Session suitable for subagent use.
  */
 
-/** Record of an installed plugin in installed_plugins.json. */
-interface IInstalledPluginRecord {
-    pluginName: string;
-    marketplace: string;
-    version: string;
-    installPath: string;
-    installedAt: string;
+/** Options for creating a subagent session. */
+interface ISubagentOptions {
+    /** Agent definition (built-in or custom). */
+    agentDefinition: IAgentDefinition;
+    /** Parent's resolved config (for provider, permissions, etc.). */
+    parentConfig: IResolvedConfig;
+    /** Parent's loaded context (CLAUDE.md, AGENTS.md). */
+    parentContext: ILoadedContext;
+    /** Parent session's available tools (to inherit/filter). */
+    parentTools: IToolWithEventService[];
+    /** AI provider instance. */
+    provider: IAIProvider;
+    /** Terminal output interface. */
+    terminal: ITerminalOutput;
+    /** Stable session ID for transcript files. */
+    sessionId?: string;
+    /** Optional logger for subagent transcripts. */
+    sessionLogger?: ISessionLogger;
+    /** Whether this is a fork worker (uses fork suffix instead of standard). */
+    isForkWorker?: boolean;
+    /** Permission mode from parent (bypassPermissions, acceptEdits, etc.). */
+    permissionMode?: TPermissionMode;
+    /** Permission handler from parent. */
+    permissionHandler?: TPermissionHandler;
+    /** Plugin hooks configuration from parent session. */
+    hooks?: Record<string, unknown>;
+    /** Hook type executors from parent session (prompt, agent, etc.). */
+    hookTypeExecutors?: IHookTypeExecutor[];
+    /** Streaming callback. */
+    onTextDelta?: (delta: string) => void;
+    /** Tool execution callback. */
+    onToolExecution?: (event: {
+        type: 'start' | 'end';
+        toolName: string;
+        toolArgs?: TToolArgs;
+        success?: boolean;
+    }) => void;
 }
-/** Shape of installed_plugins.json. */
-type IInstalledPluginsRegistry = Record<string, IInstalledPluginRecord>;
-/** Exec function type for running shell commands. */
-type ExecFn = (command: string, options: {
-    timeout: number;
-    stdio?: string;
-}) => string | Buffer;
-/** Options for constructing a BundlePluginInstaller. */
-interface IBundlePluginInstallerOptions {
-    /** Base plugins directory (e.g., `~/.robota/plugins`). */
-    pluginsDir: string;
-    /** Shared settings store for enable/disable persistence. */
-    settingsStore: PluginSettingsStore;
-    /** MarketplaceClient for reading marketplace manifests. */
-    marketplaceClient: MarketplaceClient;
-    /** Custom exec function for testing (replaces child_process.execSync). */
-    exec?: ExecFn;
+/**
+ * Create a fully-configured Session for subagent execution.
+ *
+ * Assembles provider, tools, and system prompt from parent context and
+ * agent definition, then returns a new Session instance.
+ */
+declare function createSubagentSession(options: ISubagentOptions): Session;
+
+interface IInProcessSubagentRunnerDeps {
+    config: IResolvedConfig;
+    context: ILoadedContext;
+    tools: IToolWithEventService[];
+    terminal: ITerminalOutput;
+    provider: IAIProvider;
+    permissionMode?: TPermissionMode;
+    permissionHandler?: TPermissionHandler;
+    hooks?: ISubagentOptions['hooks'];
+    hookTypeExecutors?: IHookTypeExecutor[];
+    onTextDelta?: (delta: string) => void;
+    onToolExecution?: (event: {
+        type: 'start' | 'end';
+        toolName: string;
+        toolArgs?: TToolArgs;
+        success?: boolean;
+    }) => void;
+    customAgentRegistry?: (name: string) => IAgentDefinition | undefined;
 }
-/** Installs, uninstalls, enables, and disables bundle plugins. */
-declare class BundlePluginInstaller {
-    private readonly pluginsDir;
-    private readonly cacheDir;
-    private readonly registryPath;
-    private readonly settingsStore;
-    private readonly marketplaceClient;
-    private readonly exec;
-    constructor(options: IBundlePluginInstallerOptions);
-    /**
-     * Install a plugin from a marketplace.
-     *
-     * 1. Read marketplace manifest to find the plugin entry.
-     * 2. Resolve source (relative path, github, or url).
-     * 3. Copy/clone to `cache/<marketplace>/<plugin>/<version>/`.
-     * 4. Record in `installed_plugins.json`.
-     */
-    install(pluginName: string, marketplaceName: string): Promise<void>;
-    /**
-     * Uninstall a plugin.
-     * Removes from cache and from installed_plugins.json.
-     */
-    uninstall(pluginId: string): Promise<void>;
-    /** Enable a plugin by setting its enabledPlugins entry to true. */
-    enable(pluginId: string): Promise<void>;
-    /** Disable a plugin by setting its enabledPlugins entry to false. */
-    disable(pluginId: string): Promise<void>;
-    /** Get all installed plugins. */
-    getInstalledPlugins(): IInstalledPluginsRegistry;
-    /** Get plugins installed from a specific marketplace. */
-    getPluginsByMarketplace(marketplaceName: string): IInstalledPluginRecord[];
-    /** Resolve the version for a plugin entry. */
-    private resolveVersion;
-    /**
-     * Normalize source object — Claude Code manifests use `source` key instead of `type`.
-     * e.g., { source: "url", url: "..." } → { type: "url", url: "..." }
-     */
-    private normalizeSource;
-    /** Resolve the source and install the plugin. */
-    private resolveAndInstall;
-    /** Clone a git repository to the target directory. */
-    private cloneToDir;
-    /** Read the installed_plugins.json registry. */
-    private readRegistry;
-    /** Write the installed_plugins.json registry. */
-    private writeRegistry;
-    /** Default exec implementation using child_process. */
-    private defaultExec;
+type TSubagentRunnerFactory = (deps: IInProcessSubagentRunnerDeps) => ISubagentRunner;
+
+/**
+ * Prompt hook executor — evaluates a prompt via an AI model.
+ *
+ * Makes a single-turn LLM call with hook input context as the prompt.
+ * Parses { ok: boolean, reason?: string } from the AI response.
+ *
+ * Exit codes:
+ * - 0: ok: true (allow/proceed)
+ * - 2: ok: false (block/deny), reason in stderr
+ * - 1: execution error (provider failure, parse error)
+ */
+
+/** A minimal provider interface for single-turn completion. */
+interface IPromptProvider {
+    complete(prompt: string): Promise<string>;
+}
+/** Factory that creates a provider instance, optionally for a specific model. */
+type TProviderFactory = (model?: string) => IPromptProvider;
+/** Constructor options for PromptExecutor. */
+interface IPromptExecutorOptions {
+    providerFactory: TProviderFactory;
+    defaultModel?: string;
+}
+declare class PromptExecutor implements IHookTypeExecutor {
+    readonly type: "prompt";
+    private readonly providerFactory;
+    private readonly defaultModel;
+    constructor(options: IPromptExecutorOptions);
+    execute(definition: IHookDefinition, input: IHookInput): Promise<IHookResult>;
+}
+
+/**
+ * Agent hook executor — delegates to a sub-agent session.
+ *
+ * Creates a subagent session with maxTurns and timeout limits,
+ * runs hook input as the initial prompt, and parses the result.
+ *
+ * Exit codes:
+ * - 0: ok: true (allow/proceed)
+ * - 2: ok: false (block/deny), reason in stderr
+ * - 1: execution error (session failure, parse error)
+ */
+
+/** A minimal session interface for running a prompt. */
+interface IAgentSession {
+    run(prompt: string): Promise<string>;
+}
+/** Factory that creates a session instance with the given options. */
+type TSessionFactory = (options: {
+    maxTurns?: number;
+    timeout?: number;
+}) => IAgentSession;
+/** Constructor options for AgentExecutor. */
+interface IAgentExecutorOptions {
+    sessionFactory: TSessionFactory;
+}
+declare class AgentExecutor implements IHookTypeExecutor {
+    readonly type: "agent";
+    private readonly sessionFactory;
+    constructor(options: IAgentExecutorOptions);
+    execute(definition: IHookDefinition, input: IHookInput): Promise<IHookResult>;
+}
+
+type TProjectType = 'node' | 'python' | 'rust' | 'go' | 'unknown';
+type TPackageManager = 'pnpm' | 'yarn' | 'npm' | 'bun';
+type TLanguage = 'typescript' | 'javascript' | 'python' | 'rust' | 'go' | 'unknown';
+interface IProjectInfo {
+    type: TProjectType;
+    name?: string;
+    packageManager?: TPackageManager;
+    language: TLanguage;
+}
+
+interface ISystemPromptParams {
+    /** Concatenated AGENTS.md content (may be empty string) */
+    agentsMd: string;
+    /** Concatenated CLAUDE.md content (may be empty string) */
+    claudeMd: string;
+    /** Human-readable tool descriptions, one per entry */
+    toolDescriptions: string[];
+    /** Active trust level governing permission checks */
+    trustLevel: TTrustLevel;
+    /** Detected project metadata */
+    projectInfo: IProjectInfo;
+    /** Current working directory */
+    cwd?: string;
+    /** Response language code (e.g., "ko", "en"). If set, AI must respond in this language. */
+    language?: string;
+    /** Discovered skills to expose in the system prompt */
+    skills?: Array<{
+        name: string;
+        description: string;
+        disableModelInvocation?: boolean;
+    }>;
+    /** Discovered agents to expose in the system prompt */
+    agents?: Array<{
+        name: string;
+        description: string;
+    }>;
+    /** Command descriptors to expose to the model */
+    commandDescriptors?: ICapabilityDescriptor[];
+}
+
+/**
+ * Session factory — assembles a fully-configured Session from config, context,
+ * tools, and provider.
+ *
+ * This is the main entry point for creating sessions. It wires together
+ * the provider, tools, system prompt, and configuration that Session now
+ * expects as pre-constructed dependencies.
+ */
+
+/** Options for the createSession factory */
+interface ICreateSessionOptions {
+    /** Resolved CLI configuration (model, API key, permissions) */
+    config: IResolvedConfig;
+    /** Working directory used for project context, skills, and agent definitions. */
+    cwd?: string;
+    /** Loaded AGENTS.md / CLAUDE.md context */
+    context: ILoadedContext;
+    /** Terminal I/O for permission prompts */
+    terminal: ITerminalOutput;
+    /** Project metadata for system prompt */
+    projectInfo?: IProjectInfo;
+    /** Initial permission mode (defaults to config.defaultTrustLevel → mode mapping) */
+    permissionMode?: TPermissionMode;
+    /** Maximum number of agentic turns per run() call. Undefined = unlimited. */
+    maxTurns?: number;
+    /** Optional session store for persistence */
+    sessionStore?: SessionStore;
+    /** Inject a pre-constructed AI provider (used by tests to avoid real API calls) */
+    provider?: IAIProvider;
+    /** Custom permission handler (overrides terminal-based prompts, used by Ink UI) */
+    permissionHandler?: TPermissionHandler;
+    /** Callback for text deltas — enables streaming text to the UI in real-time */
+    onTextDelta?: (delta: string) => void;
+    /** Custom prompt-for-approval function (injected from CLI) */
+    promptForApproval?: (terminal: ITerminalOutput, toolName: string, toolArgs: TToolArgs) => Promise<boolean>;
+    /** Additional tools to register beyond the defaults (e.g. agent-tool) */
+    additionalTools?: IToolWithEventService[];
+    /** Additional background task runners composed by the runtime shell. */
+    backgroundTaskRunners?: IBackgroundTaskRunner[];
+    /** Runtime shell override for subagent execution. Defaults to the SDK in-process runner. */
+    subagentRunnerFactory?: TSubagentRunnerFactory;
+    /** Enable agent tool, agent definitions, and subagent runtime wiring for this session. */
+    enableAgentRuntime?: boolean;
+    /** Callback when a tool starts or finishes execution — enables real-time tool display in UI */
+    onToolExecution?: (event: {
+        type: 'start' | 'end';
+        toolName: string;
+        toolArgs?: TToolArgs;
+        success?: boolean;
+    }) => void;
+    /** Callback when context is compacted */
+    onCompact?: (summary: string) => void;
+    /** Instructions to include in the compaction prompt (e.g. from CLAUDE.md) */
+    compactInstructions?: string;
+    /** Custom system prompt builder function */
+    systemPromptBuilder?: (params: ISystemPromptParams) => string;
+    /** Custom tool descriptions for the system prompt */
+    toolDescriptions?: string[];
+    /** Session logger — injected for pluggable session event logging. */
+    sessionLogger?: ISessionLogger;
+    /** Provider factory for prompt hook executors (DI). */
+    providerFactory?: TProviderFactory;
+    /** Session factory for agent hook executors (DI). */
+    sessionFactory?: TSessionFactory;
+    /** Additional hook type executors beyond the defaults (prompt, agent). */
+    additionalHookExecutors?: IHookTypeExecutor[];
+    /** Override session ID (used when resuming a session to reuse the original ID) */
+    sessionId?: string;
+    /** Pre-approved tool names — added to permissions.allow as ToolName(*) patterns. */
+    allowedTools?: string[];
+    /** Text to append to the generated system prompt. */
+    appendSystemPrompt?: string;
+    /** Model command execution bridge. */
+    modelCommandExecutor?: (command: string, args: string) => Promise<ICommandResult | null>;
+    /** Predicate for commands allowed through the model command execution bridge. */
+    isModelCommandInvocable?: (command: string) => boolean;
+    /** Model-visible command descriptors. */
+    commandDescriptors?: ICapabilityDescriptor[];
+}
+
+/**
+ * Default tool set factory — creates the standard set of CLI tools.
+ */
+
+/**
+ * Create the default set of CLI tools.
+ * Returns the 8 standard tools as IToolWithEventService[].
+ */
+declare function createDefaultTools(): IToolWithEventService[];
+
+/**
+ * Framework system prompt suffixes for subagent sessions.
+ *
+ * These functions generate the standard prompt content injected into
+ * subagent sessions to control output format and behavior.
+ */
+/** Options for assembling a subagent system prompt. */
+interface ISubagentPromptOptions {
+    /** Agent definition markdown body. */
+    agentBody: string;
+    /** CLAUDE.md content to include. */
+    claudeMd?: string;
+    /** AGENTS.md content to include. */
+    agentsMd?: string;
+    /** When true, use fork worker suffix instead of standard subagent suffix. */
+    isForkWorker: boolean;
 }
+/**
+ * Returns the standard subagent suffix appended to agent body for normal subagents.
+ */
+declare function getSubagentSuffix(): string;
+/**
+ * Returns the fork worker suffix for context:fork skill workers.
+ */
+declare function getForkWorkerSuffix(): string;
+/**
+ * Assembles the full system prompt for a subagent.
+ *
+ * Assembly order:
+ * 1. Agent definition body
+ * 2. CLAUDE.md content (if provided)
+ * 3. AGENTS.md content (if provided)
+ * 4. Framework suffix (fork worker OR standard subagent)
+ */
+declare function assembleSubagentPrompt(options: ISubagentPromptOptions): string;
 
 /**
- * Command source that discovers skills and commands from loaded BundlePlugins.
+ * Subagent transcript logger — creates a FileSessionLogger that writes
+ * subagent session logs into a subdirectory of the parent session's log folder.
  *
- * - Skills: exposed as `/name` with `(plugin-name)` hint in description.
- * - Commands: exposed as `/plugin:command` (already namespaced by the loader).
+ * Log structure:
+ *   {baseLogsDir}/{parentSessionId}/subagents/{agentId}.jsonl
  */
-declare class PluginCommandSource implements ICommandSource {
-    readonly name = "plugin";
-    private readonly plugins;
-    constructor(plugins: ILoadedBundlePlugin[]);
-    getCommands(): ICommand[];
-}
 
 /**
- * System commands — SDK-level command execution logic.
+ * Create a FileSessionLogger for a subagent session.
  *
- * Pure functions that operate on InteractiveSession.
- * No React, no TUI, no framework dependencies.
- * CLI wraps these as slash commands with UI chrome.
+ * The logger writes JSONL files into a `subagents/` subdirectory under the
+ * parent session's log folder. The directory is created if it does not exist.
+ *
+ * @param parentSessionId - ID of the parent session (used as directory name)
+ * @param agentId - Unique identifier for this subagent run
+ * @param baseLogsDir - Root logs directory (e.g., `.robota/logs`)
+ * @returns A FileSessionLogger writing to the subagent directory
  */
+declare function createSubagentLogger(parentSessionId: string, _agentId: string, baseLogsDir: string): FileSessionLogger;
+/**
+ * Resolve the subagent log directory path without creating it.
+ *
+ * Useful when the caller needs the path for display or configuration
+ * but does not want to create the directory immediately.
+ *
+ * @param parentSessionId - ID of the parent session
+ * @param baseLogsDir - Root logs directory
+ * @returns The resolved subagent log directory path
+ */
+declare function resolveSubagentLogDir(parentSessionId: string, baseLogsDir: string): string;
 
-/** Result of a system command execution. */
-interface ICommandResult {
-    /** Human-readable output message */
-    message: string;
-    /** Command completed successfully */
-    success: boolean;
-    /** Additional structured data (command-specific) */
-    data?: Record<string, unknown>;
+/**
+ * Session initialization helpers for InteractiveSession.
+ *
+ * Handles async config/context loading, plugin merging, and session creation.
+ * Also provides session-restore (resume/fork) logic.
+ */
+
+/** Standard construction: cwd + provider. Config/context loaded internally. */
+interface IInteractiveSessionStandardOptions {
+    cwd: string;
+    provider: IAIProvider;
+    permissionMode?: ICreateSessionOptions['permissionMode'];
+    maxTurns?: number;
+    permissionHandler?: TInteractivePermissionHandler;
+    sessionStore?: SessionStore;
+    sessionName?: string;
+    resumeSessionId?: string;
+    forkSession?: boolean;
+    /** Skip AGENTS.md/CLAUDE.md loading and plugin discovery. */
+    bare?: boolean;
+    /** Pre-approved tool names passed to createSession. */
+    allowedTools?: string[];
+    /** Text to append to the system prompt. */
+    appendSystemPrompt?: string;
+    /** Runtime-composed background task runners. */
+    backgroundTaskRunners?: IBackgroundTaskRunner[];
+    /** Runtime shell override for subagent execution. */
+    subagentRunnerFactory?: TSubagentRunnerFactory;
+    /** Optional command modules composed into this session. */
+    commandModules?: readonly ICommandModule[];
+    /** Model-visible command descriptors derived from the composed command executor. */
+    commandDescriptors?: readonly ICapabilityDescriptor[];
+    /** Model command execution bridge. */
+    modelCommandExecutor?: (command: string, args: string) => Promise<ICommandResult | null>;
+    /** Predicate for commands allowed through the model command execution bridge. */
+    isModelCommandInvocable?: (command: string) => boolean;
 }
-/** A system command with name, description, and execute logic. */
-interface ISystemCommand {
-    name: string;
-    description: string;
-    execute(session: InteractiveSession, args: string): Promise<ICommandResult> | ICommandResult;
+/** Test/advanced construction: inject pre-built session directly. */
+interface IInteractiveSessionInjectedOptions {
+    session: Session;
+    cwd?: string;
+    provider?: IAIProvider;
+    permissionMode?: ICreateSessionOptions['permissionMode'];
+    maxTurns?: number;
+    permissionHandler?: TInteractivePermissionHandler;
+    sessionStore?: SessionStore;
+    sessionName?: string;
+    resumeSessionId?: string;
+    forkSession?: boolean;
+    /** Optional command modules composed into this injected session. */
+    commandModules?: readonly ICommandModule[];
 }
+/** Union of standard and injected construction options. */
+type IInteractiveSessionOptions = IInteractiveSessionStandardOptions | IInteractiveSessionInjectedOptions;
 
 /**
- * Build a skill prompt from slash command input.
- * Supports variable substitution and shell command preprocessing.
+ * InteractiveSession — the single entry point for all SDK consumers.
+ *
+ * Wraps Session (composition). Manages streaming text accumulation,
+ * tool execution state tracking, prompt queuing, abort orchestration,
+ * message history, and system command execution.
+ *
+ * Config/context loading is internal. Consumer provides cwd + provider.
  */
 
-/** Context variables available during skill prompt processing */
-interface SkillPromptContext {
-    /** Current session ID — substituted for ${CLAUDE_SESSION_ID} */
-    sessionId?: string;
-    /** Directory containing SKILL.md — substituted for ${CLAUDE_SKILL_DIR} */
-    skillDir?: string;
+interface IInteractiveSessionShutdownOptions {
+    reason?: TSessionEndReason;
+    message?: string;
+}
+declare class InteractiveSession {
+    private session;
+    private readonly commandExecutor;
+    private readonly listeners;
+    private initialized;
+    private initPromise;
+    private streamingText;
+    private flushTimer;
+    private activeTools;
+    private executing;
+    private pendingPrompt;
+    private pendingDisplayInput;
+    private pendingRawInput;
+    private history;
+    private sessionStore?;
+    private sessionName?;
+    private cwd?;
+    private pendingRestoreMessages;
+    private backgroundTasks;
+    private backgroundTaskEvents;
+    private backgroundJobGroups;
+    private backgroundJobGroupEvents;
+    private resumeSessionId?;
+    private forkSession;
+    private backgroundTaskUnsubscribe;
+    private backgroundJobUnsubscribe;
+    private backgroundJobOrchestrator;
+    private readonly commandModules;
+    private shuttingDown;
+    private shutdownPromise;
+    constructor(options: IInteractiveSessionOptions);
+    private initializeAsync;
+    private ensureInitialized;
+    private getSessionOrThrow;
+    on<E extends TInteractiveEventName>(event: E, handler: IInteractiveSessionEvents[E]): void;
+    off<E extends TInteractiveEventName>(event: E, handler: IInteractiveSessionEvents[E]): void;
+    private emit;
+    submit(input: string, displayInput?: string, rawInput?: string): Promise<void>;
+    executeCommand(name: string, args: string): Promise<{
+        message: string;
+        success: boolean;
+        data?: Record<string, unknown>;
+    } | null>;
+    executeModelCommand(name: string, args: string): Promise<{
+        message: string;
+        success: boolean;
+        data?: Record<string, unknown>;
+    } | null>;
+    executeSkillCommand(skill: ICommand, args: string, displayInput?: string, rawInput?: string): Promise<ISkillExecutionResult>;
+    listCommands(): Array<{
+        name: string;
+        description: string;
+    }>;
+    listModelInvocableCommands(): Array<{
+        name: string;
+        description: string;
+    }>;
+    abort(): void;
+    shutdown(options?: IInteractiveSessionShutdownOptions): Promise<void>;
+    cancelQueue(): void;
+    private clearPendingQueue;
+    isExecuting(): boolean;
+    getPendingPrompt(): string | null;
+    getFullHistory(): IHistoryEntry[];
+    getMessages(): TUniversalMessage[];
+    getStreamingText(): string;
+    getActiveTools(): IToolState[];
+    getContextState(): IContextWindowState;
+    getName(): string | undefined;
+    getSession(): Session;
+    listBackgroundTasks(filter?: IBackgroundTaskListFilter): IBackgroundTaskState[];
+    getBackgroundTask(taskId: string): IBackgroundTaskState | undefined;
+    cancelBackgroundTask(taskId: string, reason?: string): Promise<void>;
+    closeBackgroundTask(taskId: string): Promise<void>;
+    sendBackgroundTask(taskId: string, input: IBackgroundTaskInput): Promise<void>;
+    readBackgroundTaskLog(taskId: string, cursor?: IBackgroundTaskLogCursor): Promise<IBackgroundTaskLogPage>;
+    createBackgroundJobGroup(input: Omit<IBackgroundJobGroupCreateRequest, 'parentSessionId'>): IBackgroundJobGroupState;
+    listBackgroundJobGroups(): IBackgroundJobGroupState[];
+    getBackgroundJobGroup(groupId: string): IBackgroundJobGroupState | undefined;
+    waitBackgroundJobGroup(groupId: string): Promise<IBackgroundJobGroupState>;
+    listAgentDefinitions(): Array<{
+        name: string;
+        description: string;
+    }>;
+    listAgentJobs(): ISubagentJobState[];
+    spawnAgentJob(input: {
+        agentType: string;
+        label: string;
+        mode: 'foreground' | 'background';
+        prompt: string;
+        model?: string;
+        isolation?: TBackgroundTaskIsolation;
+    }): Promise<ISubagentJobState>;
+    waitAgentJob(jobId: string): Promise<ISubagentJobResult>;
+    sendAgentJob(jobId: string, prompt: string): Promise<void>;
+    cancelAgentJob(jobId: string, reason?: string): Promise<void>;
+    closeAgentJob(jobId: string): Promise<void>;
+    setName(name: string): void;
+    attachTransport(transport: ITransportAdapter): void;
+    private executeForkSkillCommand;
+    private getBackgroundTaskManagerOrThrow;
+    private getBackgroundTaskManager;
+    private getBackgroundJobOrchestratorOrThrow;
+    private getAgentToolDepsOrThrow;
+    private getSubagentManagerOrThrow;
+    private resolveAgentDefinition;
+    private subscribeBackgroundTaskEvents;
+    private subscribeBackgroundJobGroupEvents;
+    private recordBackgroundTaskEvent;
+    private recordBackgroundJobGroupEvent;
+    private getBackgroundTaskSnapshots;
+    private getBackgroundJobGroupSnapshots;
+    private persistCurrentSession;
+    private startForkSkillExecution;
+    private finishForkSkillExecution;
+    private recordForkSkillError;
+    private resolveForkAgentDefinition;
+    private runSkillInFork;
+    private applyForkSkillResult;
+    private executePrompt;
+    private handleTextDelta;
+    private handleToolExecution;
+    private clearStreaming;
+    private flushStreaming;
 }
+
 /**
- * Substitute variables in skill content.
+ * createQuery() — factory that returns a prompt-only convenience function.
  *
- * Supported variables:
- * - `$ARGUMENTS` — all arguments passed to the skill
- * - `$ARGUMENTS[N]` — argument by index (0-based)
- * - `$N` — shorthand for `$ARGUMENTS[N]` (single digit, 0-9)
- * - `${CLAUDE_SESSION_ID}` — current session ID
- * - `${CLAUDE_SKILL_DIR}` — directory containing SKILL.md
+ * Usage:
+ *   const query = createQuery({ provider });
+ *   const answer = await query('What files are here?');
  */
-declare function substituteVariables(content: string, args: string, context?: SkillPromptContext): string;
+
+interface ICreateQueryOptions {
+    /** AI provider instance (required). */
+    provider: IAIProvider;
+    /** Working directory. Defaults to process.cwd(). */
+    cwd?: string;
+    /** Permission mode. Defaults to 'bypassPermissions' for programmatic use. */
+    permissionMode?: TPermissionMode;
+    /** Maximum agentic turns per query. */
+    maxTurns?: number;
+    /** Permission handler callback. */
+    permissionHandler?: TInteractivePermissionHandler;
+    /** Streaming text callback. */
+    onTextDelta?: (delta: string) => void;
+}
 /**
- * Preprocess shell commands in skill content.
- * Matches `` !`...` `` patterns and replaces them with command output.
- * Commands have a 5-second timeout.
+ * Create a prompt-only query function bound to a provider.
+ *
+ * ```typescript
+ * import { createQuery } from '@robota-sdk/agent-sdk';
+ * import { AnthropicProvider } from '@robota-sdk/agent-provider-anthropic';
+ *
+ * const query = createQuery({ provider: new AnthropicProvider({ apiKey: '...' }) });
+ * const answer = await query('List all TypeScript files');
+ * ```
  */
-declare function preprocessShellCommands(content: string): Promise<string>;
-/** Build a skill prompt from a slash command input and registry */
-declare function buildSkillPrompt(input: string, registry: CommandRegistry, context?: SkillPromptContext): Promise<string | null>;
+declare function createQuery(options: ICreateQueryOptions): (prompt: string) => Promise<string>;
 
 /**
  * All built-in agent definitions shipped with the SDK.
@@ -1076,9 +1409,10 @@ declare function getBuiltInAgent(name: string): IAgentDefinition | undefined;
 /**
  * AgentTool — spawn a sub-agent with isolated context.
  *
- * Uses `createSubagentSession` to assemble a child Session with filtered tools,
- * model resolution, and framework system prompt. The sub-agent shares the same
- * config and context but has its own conversation history.
+ * Uses `SubagentManager` with an in-process runner to assemble a child Session
+ * with filtered tools, model resolution, and framework system prompt. The
+ * sub-agent shares the same config and context but has its own conversation
+ * history.
  *
  * Each call to `createAgentTool(deps)` returns a fresh tool instance with deps
  * captured in closure, eliminating module-level mutable state and enabling
@@ -1086,29 +1420,16 @@ declare function getBuiltInAgent(name: string): IAgentDefinition | undefined;
  */
 
 /** Dependencies injected at creation time via createAgentTool factory */
-interface IAgentToolDeps {
-    config: IResolvedConfig;
-    context: ILoadedContext;
-    tools: IToolWithEventService[];
-    terminal: ITerminalOutput;
-    /** AI provider instance (passed from consumer). */
-    provider: IAIProvider;
-    /** Permission mode from parent session (bypassPermissions, acceptEdits, etc.). */
-    permissionMode?: TPermissionMode;
-    permissionHandler?: TPermissionHandler;
-    /** Plugin hooks configuration from parent session. */
-    hooks?: Record<string, unknown>;
-    /** Hook type executors from parent session (prompt, agent, etc.). */
-    hookTypeExecutors?: IHookTypeExecutor[];
-    onTextDelta?: (delta: string) => void;
-    onToolExecution?: (event: {
-        type: 'start' | 'end';
-        toolName: string;
-        toolArgs?: TToolArgs;
-        success?: boolean;
-    }) => void;
+interface IAgentToolDeps extends IInProcessSubagentRunnerDeps {
+    cwd?: string;
+    parentSessionId?: string;
+    subagentDepth?: number;
+    subagentManager?: ISubagentManager;
+    backgroundTaskManager?: IBackgroundTaskManager;
     /** Optional custom agent registry for resolving non-built-in agent types. */
     customAgentRegistry?: (name: string) => IAgentDefinition | undefined;
+    /** Model-visible and command-visible agent definitions available to this session. */
+    agentDefinitions?: IAgentDefinition[];
 }
 /** Store agent tool deps keyed by a session (or any object). */
 declare function storeAgentToolDeps(key: object, deps: IAgentToolDeps): void;
@@ -1121,6 +1442,19 @@ declare function retrieveAgentToolDeps(key: object): IAgentToolDeps | undefined;
  */
 declare function createAgentTool(deps: IAgentToolDeps): ReturnType<typeof createZodFunctionTool>;
 
+interface ICommandExecutionToolDeps {
+    isModelInvocable: (command: string) => boolean;
+    execute: (command: string, args: string) => Promise<ICommandResult | null>;
+}
+declare function createCommandExecutionTool(deps: ICommandExecutionToolDeps): ReturnType<typeof createZodFunctionTool>;
+
+interface IBackgroundProcessToolDeps {
+    backgroundTaskManager: IBackgroundTaskManager;
+    cwd?: string;
+    parentSessionId?: string;
+}
+declare function createBackgroundProcessTool(deps: IBackgroundProcessToolDeps): ReturnType<typeof createZodFunctionTool>;
+
 /**
  * Standard Robota storage paths.
  *
@@ -1151,4 +1485,4 @@ declare function userPaths(): {
  */
 declare function promptForApproval(terminal: ITerminalOutput, toolName: string, toolArgs: TToolArgs): Promise<boolean>;
 
-export { AgentExecutor, BUILT_IN_AGENTS, BuiltinCommandSource, BundlePluginInstaller, BundlePluginLoader, CommandRegistry, type IAgentDefinition, type IAgentExecutorOptions, type IAgentSession, type IAgentToolDeps, type IBundlePluginFeatures, type IBundlePluginInstallerOptions, type IBundlePluginManifest, type IBundleSkill, type ICommand, type ICommandResult, type ICommandSource, type ICreateQueryOptions, type IDiffLine, type IExecutionResult, type IInstalledPluginRecord, type IInstalledPluginsRegistry, type IInteractiveSessionEvents, type IInteractiveSessionOptions, type IKnownMarketplaceEntry, type IKnownMarketplacesRegistry, type ILoadedBundlePlugin, type IMarketplaceClientOptions, type IMarketplaceManifest, type IMarketplacePluginEntry, type IMarketplaceSource, type IPluginSettings, type IPromptExecutorOptions, type IPromptProvider, type ISubagentOptions, type ISubagentPromptOptions, type ISystemCommand, type IToolState, type IToolSummary, type ITransportAdapter, InteractiveSession, MarketplaceClient, PluginCommandSource, PluginSettingsStore, PromptExecutor, SkillCommandSource, type SkillPromptContext, type TEnabledPlugins, type TInteractiveEventName, type TInteractivePermissionHandler, type TPermissionResultValue, type TProviderFactory, type TSessionFactory, assembleSubagentPrompt, buildSkillPrompt, createAgentTool, createQuery, createSubagentLogger, createSubagentSession, getBuiltInAgent, getForkWorkerSuffix, getSubagentSuffix, parseFrontmatter, preprocessShellCommands, projectPaths, promptForApproval, resolveSubagentLogDir, retrieveAgentToolDeps, storeAgentToolDeps, substituteVariables, userPaths };
+export { AgentExecutor, BUILT_IN_AGENTS, BackgroundJobOrchestrator, BuiltinCommandSource, BundlePluginInstaller, BundlePluginLoader, CommandRegistry, type IAgentDefinition, type IAgentExecutorOptions, type IAgentSession, type IAgentToolDeps, type IBackgroundJobGroupCreateRequest, type IBackgroundJobGroupState, type IBackgroundJobGroupSummary, type IBackgroundJobOrchestratorOptions, type IBackgroundJobResultEnvelope, type IBackgroundProcessToolDeps, type IBundlePluginFeatures, type IBundlePluginInstallerOptions, type IBundlePluginManifest, type IBundleSkill, type ICapabilityDescriptor, type ICommand, type ICommandExecutionToolDeps, type ICommandModule, type ICommandResult, type ICommandSource, type ICreateQueryOptions, type IDiffLine, type IExecutionResult, type IForkExecutionOptions, type IInProcessSubagentRunnerDeps, type IInstalledPluginRecord, type IInstalledPluginsRegistry, type IInteractiveSessionEvents, type IInteractiveSessionOptions, type IInteractiveSessionShutdownOptions, type IKnownMarketplaceEntry, type IKnownMarketplacesRegistry, type ILoadedBundlePlugin, type IMarketplaceClientOptions, type IMarketplaceManifest, type IMarketplacePluginEntry, type IMarketplaceSource, type IPluginSettings, type IPromptExecutorOptions, type IPromptProvider, type ISkillExecutionCallbacks, type ISkillExecutionResult, type ISubagentOptions, type ISubagentPromptOptions, type ISystemCommand, type IToolState, type IToolSummary, type ITransportAdapter, InteractiveSession, MarketplaceClient, PluginCommandSource, PluginSettingsStore, PromptExecutor, SkillCommandSource, type SkillPromptContext, SystemCommandExecutor, type TBackgroundJobGroupEvent, type TBackgroundJobGroupEventListener, type TBackgroundJobGroupIdFactory, type TBackgroundJobGroupStatus, type TBackgroundJobWaitPolicy, type TCapabilityKind, type TCapabilitySafety, type TCommandModuleSessionRequirement, type TEnabledPlugins, type TInteractiveEventName, type TInteractivePermissionHandler, type TPermissionResultValue, type TProviderFactory, type TSessionFactory, type TSubagentRunnerFactory, assembleSubagentPrompt, buildSkillPrompt, createAgentTool, createBackgroundProcessTool, createCommandExecutionTool, createDefaultTools, createQuery, createSubagentLogger, createSubagentSession, createSystemCommands, executeSkill, getBuiltInAgent, getForkWorkerSuffix, getSubagentSuffix, parseFrontmatter, preprocessShellCommands, projectPaths, promptForApproval, resolveSubagentLogDir, retrieveAgentToolDeps, storeAgentToolDeps, substituteVariables, summarizeBackgroundJobGroup, userPaths };