@robota-sdk/agent-sdk 3.0.0-beta.6 → 3.0.0-beta.60

package/dist/node/index.d.cts

@@ -1,191 +1,1395 @@
-import { TTrustLevel, TPermissionMode, IAIProvider, TToolArgs, IToolWithEventService } from '@robota-sdk/agent-core';
-export { IContextTokenUsage, IContextWindowState, IHookInput, IPermissionLists, THookEvent, THooksConfig, TPermissionDecision, TPermissionMode, TRUST_TO_MODE, TToolArgs, TTrustLevel, evaluatePermission, runHooks } from '@robota-sdk/agent-core';
-import * as _robota_sdk_agent_tools from '@robota-sdk/agent-tools';
-export { TToolResult, bashTool, editTool, globTool, grepTool, readTool, writeTool } from '@robota-sdk/agent-tools';
-import { ITerminalOutput, SessionStore, TPermissionHandler, ISessionLogger, Session } from '@robota-sdk/agent-sessions';
-export { FileSessionLogger, ISessionLogger, ISessionOptions, ISessionRecord, ISpinner, ITerminalOutput, Session, SessionStore, SilentSessionLogger, TPermissionHandler, TPermissionResult, TSessionLogData } from '@robota-sdk/agent-sessions';
-import { z } from 'zod';
+import { ICompactEvent, ITerminalOutput, ISessionLogger, TPermissionHandler, Session, SessionStore, FileSessionLogger } from '@robota-sdk/agent-sessions';
+export { ICompactEvent, ISpinner, ITerminalOutput, TCompactTrigger } from '@robota-sdk/agent-sessions';
+import { TUniversalValue, TSessionEndReason, TPermissionMode, IToolWithEventService, IContextWindowState, IProviderProfileConfig, IProviderDefinition, IProviderSetupStepDefinition, TProviderSetupField, IProviderProbeResult, TToolArgs, IHistoryEntry, THooksConfig, IAIProvider, IHookTypeExecutor, IHookDefinition, IHookInput, IHookResult, TTrustLevel, 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, IBackgroundTaskListFilter, IBackgroundTaskState, IBackgroundTaskLogCursor, IBackgroundTaskLogPage, TBackgroundTaskEvent, ISubagentRunner, IBackgroundTaskRunner, IBackgroundTaskInput, 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';
+
+type TCapabilityKind = 'builtin-command' | 'skill' | 'agent' | 'tool';
+type TCapabilitySafety = 'read-only' | 'write' | 'process' | 'network' | 'background-agent';
+interface ICapabilityDescriptor {
+    readonly name: string;
+    readonly kind: TCapabilityKind;
+    readonly description: string;
+    readonly userInvocable: boolean;
+    readonly modelInvocable: boolean;
+    readonly argumentHint?: string;
+    readonly safety?: TCapabilitySafety;
+}
+
+/** 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;
+}
+/** A source that provides commands */
+interface ICommandSource {
+    name: string;
+    getCommands(): ICommand[];
+}
+
+declare const STATUSLINE_COMMAND_DESCRIPTION = "Configure TUI status-line visibility and fields such as model, context, tokens, session, and git branch.";
+declare const STATUSLINE_COMMAND_ARGUMENT_HINT = "on | off | reset | git on | git off";
+interface IStatusLineCommandSettings {
+    enabled: boolean;
+    gitBranch: boolean;
+}
+type TStatusLineCommandSettingsPatch = Partial<IStatusLineCommandSettings> & Record<string, TUniversalValue>;
+declare const DEFAULT_STATUS_LINE_COMMAND_SETTINGS: Readonly<IStatusLineCommandSettings>;
+declare function buildStatusLineCommandSubcommands(source?: string): ICommand[];
+declare function isStatusLineCommandSettingsPatch(value: Record<string, TUniversalValue>): value is TStatusLineCommandSettingsPatch;
+
+type TCommandEffect = {
+    type: 'model-change-requested';
+    modelId: string;
+} | {
+    type: 'language-change-requested';
+    language: string;
+} | {
+    type: 'settings-reset-requested';
+} | {
+    type: 'session-exit-requested';
+    reason?: TSessionEndReason;
+    message?: string;
+} | {
+    type: 'session-restart-requested';
+    reason: TSessionEndReason;
+    message: string;
+} | {
+    type: 'plugin-tui-requested';
+} | {
+    type: 'plugin-registry-reload-requested';
+} | {
+    type: 'session-picker-requested';
+} | {
+    type: 'session-renamed';
+    name: string;
+} | {
+    type: 'conversation-history-cleared';
+} | {
+    type: 'statusline-settings-patch';
+    patch: TStatusLineCommandSettingsPatch;
+};
+
+/** Choice option for command-owned follow-up prompts. */
+interface ICommandChoicePromptOption {
+    value: string;
+    label: string;
+}
+/** Generic prompt descriptor rendered by host UIs for command interactions. */
+type TCommandInteractionPrompt = {
+    kind: 'choice';
+    title: string;
+    options: readonly ICommandChoicePromptOption[];
+    maxVisible?: number;
+} | {
+    kind: 'text';
+    title: string;
+    placeholder?: string;
+    allowEmpty?: boolean;
+    masked?: boolean;
+    validate?: (value: string) => string | undefined;
+};
+/** Stateful command continuation owned by the command module. */
+interface ICommandInteraction {
+    prompt: TCommandInteractionPrompt;
+    submit(value: string): Promise<ICommandResult> | ICommandResult;
+    cancel?(): Promise<ICommandResult> | ICommandResult;
+}
+
+type TCommandResultDataValue = TUniversalValue | object | readonly object[];
+/** Result of a system command execution. */
+interface ICommandResult {
+    /** Human-readable output message */
+    message: string;
+    /** Command completed successfully */
+    success: boolean;
+    /** Additional structured data (command-specific diagnostics only) */
+    data?: Record<string, TCommandResultDataValue>;
+    /** Typed host effects requested by the command */
+    effects?: readonly TCommandEffect[];
+    /** Command-owned follow-up prompt and continuation */
+    interaction?: ICommandInteraction;
+}
+
+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 IBackgroundJobGroupState {
+    id: string;
+    parentSessionId: string;
+    waitPolicy: TBackgroundJobWaitPolicy;
+    taskIds: string[];
+    status: TBackgroundJobGroupStatus;
+    createdAt: string;
+    updatedAt: string;
+    label?: string;
+    completedAt?: string;
+    results: IBackgroundJobResultEnvelope[];
+}
+interface IBackgroundJobGroupSummary {
+    groupId: string;
+    status: TBackgroundJobGroupStatus;
+    total: number;
+    completed: number;
+    failed: number;
+    cancelled: number;
+    pending: number;
+    lines: string[];
+}
+interface IBackgroundJobGroupCreateRequest {
+    parentSessionId: string;
+    waitPolicy: TBackgroundJobWaitPolicy;
+    taskIds: string[];
+    label?: string;
+}
+type TBackgroundJobGroupEvent = {
+    type: 'background_job_group_created';
+    group: IBackgroundJobGroupState;
+} | {
+    type: 'background_job_group_updated';
+    group: IBackgroundJobGroupState;
+} | {
+    type: 'background_job_group_completed';
+    group: IBackgroundJobGroupState;
+};
+type TBackgroundJobGroupEventListener = (event: TBackgroundJobGroupEvent) => void;
+type TBackgroundJobGroupIdFactory = (request: IBackgroundJobGroupCreateRequest) => string;
+interface IBackgroundJobOrchestratorOptions {
+    manager: IBackgroundTaskManager;
+    now?: () => string;
+    idFactory?: TBackgroundJobGroupIdFactory;
+    initialGroups?: readonly IBackgroundJobGroupState[];
+}
+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;
+
+declare const PLUGIN_COMMAND_DESCRIPTION = "Manage plugins";
+declare const PLUGIN_COMMAND_ARGUMENT_HINT = "manage | install <name@marketplace> | uninstall <name@marketplace> | enable <name@marketplace> | disable <name@marketplace> | marketplace <action>";
+declare const RELOAD_PLUGINS_COMMAND_DESCRIPTION = "Reload all plugin resources";
+type TPluginInstallScope = 'user' | 'project';
+interface ICommandInstalledPlugin {
+    name: string;
+    description: string;
+    enabled: boolean;
+}
+interface ICommandAvailablePlugin {
+    name: string;
+    description: string;
+    installed: boolean;
+}
+interface ICommandMarketplaceSource {
+    name: string;
+    type: string;
+}
+interface ICommandPluginReloadResult {
+    loadedPluginCount: number;
+}
+interface ICommandPluginAdapter {
+    listInstalled(): Promise<readonly ICommandInstalledPlugin[]>;
+    listAvailablePlugins(marketplace: string): Promise<readonly ICommandAvailablePlugin[]>;
+    install(pluginId: string, scope?: TPluginInstallScope): Promise<void>;
+    uninstall(pluginId: string): Promise<void>;
+    enable(pluginId: string): Promise<void>;
+    disable(pluginId: string): Promise<void>;
+    marketplaceAdd(source: string): Promise<string>;
+    marketplaceRemove(name: string): Promise<void>;
+    marketplaceUpdate(name: string): Promise<void>;
+    marketplaceList(): Promise<readonly ICommandMarketplaceSource[]>;
+    reloadPlugins(): Promise<ICommandPluginReloadResult>;
+}
+declare function createPluginTuiRequestedEffect(): TCommandEffect;
+declare function createPluginRegistryReloadRequestedEffect(): TCommandEffect;
+declare function resolvePluginCommandAdapter(context: ICommandHostContext): ICommandPluginAdapter | undefined;
+declare function buildPluginCommandSubcommands(): ICommand[];
+
+interface ICommandSettingsDocument {
+    [key: string]: TUniversalValue;
+}
+interface ICommandSettingsAdapter<TSettings extends ICommandSettingsDocument = ICommandSettingsDocument> {
+    read(): TSettings;
+    write(settings: TSettings): void;
+}
+interface ICommandProcessAdapter {
+    requestExit(reason?: TSessionEndReason): void;
+    requestRestart(reason: TSessionEndReason, message: string): void;
+}
+interface ICommandPickerAdapter<TItem extends ICommandSettingsDocument> {
+    pick(items: readonly TItem[]): Promise<TItem | undefined> | TItem | undefined;
+}
+interface ICommandPermissionModeAdapter {
+    getPermissionMode(): TPermissionMode;
+    setPermissionMode(mode: TPermissionMode): void;
+    listSessionAllowedTools(): readonly string[];
+}
+interface ICommandHostAdapters {
+    settings?: ICommandSettingsAdapter;
+    process?: ICommandProcessAdapter;
+    permissionMode?: ICommandPermissionModeAdapter;
+    plugin?: ICommandPluginAdapter;
+}
+
+interface IEditCheckpointRecorder {
+    captureFile(filePath: string): Promise<void> | void;
+}
+interface IEditCheckpointTurnInput {
+    sessionId: string;
+    prompt: string;
+}
+interface IEditCheckpointSummary {
+    id: string;
+    sessionId: string;
+    sequence: number;
+    prompt: string;
+    createdAt: string;
+    fileCount: number;
+}
+interface IEditCheckpointFileRecord {
+    originalPath: string;
+    existed: boolean;
+    snapshotFile?: string;
+}
+interface IEditCheckpointManifest extends IEditCheckpointSummary {
+    version: 1;
+    files: IEditCheckpointFileRecord[];
+}
+type TEditCheckpointFileRestoreAction = 'restore-preimage' | 'delete-created-file';
+interface IEditCheckpointFileInspection {
+    originalPath: string;
+    relativePath: string;
+    existed: boolean;
+    restoreAction: TEditCheckpointFileRestoreAction;
+    snapshotAvailable: boolean;
+    snapshotSizeBytes?: number;
+}
+interface IEditCheckpointInspectionPlan {
+    checkpointIds: string[];
+    fileCount: number;
+}
+interface IEditCheckpointInspection {
+    target: IEditCheckpointSummary;
+    capturedFiles: IEditCheckpointFileInspection[];
+    restoreToCheckpoint: IEditCheckpointInspectionPlan;
+    rollbackThroughCheckpoint: IEditCheckpointInspectionPlan;
+}
+interface IEditCheckpointRestoreResult {
+    target: IEditCheckpointSummary;
+    restoredCheckpointCount: number;
+    restoredFileCount: number;
+    removedCheckpointCount: number;
+}
+
+interface IEditCheckpointStoreOptions {
+    cwd: string;
+    now?: () => Date;
+}
+declare class EditCheckpointStore {
+    private readonly cwd;
+    private readonly rootDir;
+    private readonly now;
+    private activeTurn;
+    constructor(options: IEditCheckpointStoreOptions);
+    beginTurn(input: IEditCheckpointTurnInput): Promise<IEditCheckpointSummary>;
+    captureFile(filePath: string): Promise<void>;
+    finalizeTurn(): Promise<IEditCheckpointSummary | undefined>;
+    list(sessionId: string): IEditCheckpointSummary[];
+    inspect(sessionId: string, checkpointId: string): IEditCheckpointInspection;
+    restoreToCheckpoint(sessionId: string, checkpointId: string): Promise<IEditCheckpointRestoreResult>;
+    rollbackThroughCheckpoint(sessionId: string, checkpointId: string): Promise<IEditCheckpointRestoreResult>;
+    private createFileRecord;
+    private restoreFile;
+    private loadManifests;
+    private nextSequence;
+    private writeManifest;
+    private sessionDir;
+    private checkpointDir;
+}
+
+declare function wrapEditCheckpointTools(tools: readonly IToolWithEventService[], recorder: IEditCheckpointRecorder): IToolWithEventService[];
+
+declare const MEMORY_INDEX_MAX_LINES = 200;
+declare const MEMORY_INDEX_MAX_BYTES: number;
+type TMemoryType = 'user' | 'feedback' | 'project' | 'reference';
+interface IStartupMemory {
+    content: string;
+    path: string;
+    lineCount: number;
+    truncated: boolean;
+}
+interface IMemoryTopicSummary {
+    name: string;
+    path: string;
+}
+interface IProjectMemorySummary {
+    indexPath: string;
+    topicsPath: string;
+    topics: IMemoryTopicSummary[];
+}
+interface IAppendMemoryInput {
+    type: TMemoryType;
+    topic: string;
+    text: string;
+}
+interface IAppendMemoryResult {
+    indexPath: string;
+    topicPath: string;
+    topic: string;
+    deduplicated: boolean;
+}
+declare function isMemoryType(value: string): value is TMemoryType;
+declare class ProjectMemoryStore {
+    private readonly cwd;
+    private readonly now;
+    constructor(cwd: string, now?: () => Date);
+    getIndexPath(): string;
+    getTopicsPath(): string;
+    loadStartupMemory(): IStartupMemory;
+    list(): IProjectMemorySummary;
+    readTopic(topic: string): string;
+    append(input: IAppendMemoryInput): IAppendMemoryResult;
+}
+
+type TMemoryCandidateStatus = 'pending' | 'approved' | 'rejected' | 'saved' | 'skipped';
+interface IMemoryCandidate {
+    id: string;
+    type: TMemoryType;
+    topic: string;
+    text: string;
+    sourceMessageIds: string[];
+    confidence: number;
+    createdAt: string;
+    reason: string;
+}
+interface IMemoryPendingRecord extends IMemoryCandidate {
+    status: TMemoryCandidateStatus;
+    updatedAt: string;
+    decisionReason?: string;
+}
+interface IMemoryReference {
+    topic: string;
+    path: string;
+    score: number;
+    truncated: boolean;
+}
+interface IMemoryEvent {
+    type: 'memory_candidate_extracted' | 'memory_candidate_queued' | 'memory_candidate_saved' | 'memory_candidate_skipped' | 'memory_candidate_approved' | 'memory_candidate_rejected' | 'memory_retrieved';
+    at: string;
+    candidateId?: string;
+    topic?: string;
+    reason?: string;
+    data?: Record<string, TUniversalValue>;
+}
+
+type TAutoCompactThreshold$1 = number | false;
+declare const DEFAULT_AUTO_COMPACT_THRESHOLD = 0.835;
+declare const AUTO_COMPACT_THRESHOLD_SETTINGS_KEY = "autoCompactThreshold";
+interface ICompactContextResult {
+    before: IContextWindowState;
+    after: IContextWindowState;
+}
+/** Read context-window state through the command host facade. */
+declare function readCommandContextState(context: ICommandHostContext): IContextWindowState;
+/** Read the effective automatic compact policy through the command host facade. */
+declare function readAutoCompactThreshold(context: ICommandHostContext): TAutoCompactThreshold$1;
+/** Read the source of the effective automatic compact policy. */
+declare function readAutoCompactThresholdSource(context: ICommandHostContext): TAutoCompactThresholdSource;
+/** Update the active session's automatic compact policy through the command host facade. */
+declare function setCommandAutoCompactThreshold(context: ICommandHostContext, threshold: TAutoCompactThreshold$1, source: TAutoCompactThresholdSource): void;
+/** Persist an automatic compact policy value through the host settings adapter, when present. */
+declare function writeAutoCompactThresholdSetting(context: ICommandHostContext, threshold: TAutoCompactThreshold$1): boolean;
+/** Remove the persisted automatic compact policy through the host settings adapter, when present. */
+declare function resetAutoCompactThresholdSetting(context: ICommandHostContext): boolean;
+/** Run manual compaction through the command host facade and return before/after state. */
+declare function compactCommandContext(context: ICommandHostContext, instructions?: string): Promise<ICompactContextResult>;
+
+interface ICommandListEntry {
+    name: string;
+    description: string;
+}
+type TAutoCompactThresholdSource = 'default' | 'settings' | 'session';
+interface ICommandSessionRuntime {
+    clearHistory(): void;
+    compact(instructions?: string): Promise<void>;
+    getContextState(): IContextWindowState;
+    getPermissionMode(): TPermissionMode;
+    setPermissionMode(mode: TPermissionMode): void;
+    getSessionId(): string;
+    getMessageCount(): number;
+    getSessionAllowedTools(): readonly string[];
+    getAutoCompactThreshold?(): number | false;
+    setAutoCompactThreshold?(threshold: TAutoCompactThreshold$1): void;
+}
+interface ICommandHostContext {
+    clearConversationHistory?(): void;
+    getSession(): ICommandSessionRuntime;
+    getContextState(): IContextWindowState;
+    getAutoCompactThreshold(): TAutoCompactThreshold$1;
+    getAutoCompactThresholdSource?(): TAutoCompactThresholdSource;
+    setAutoCompactThreshold?(threshold: TAutoCompactThreshold$1, source?: TAutoCompactThresholdSource): void;
+    getCommandHostAdapters?(): ICommandHostAdapters;
+    compactContext(instructions?: string): Promise<void>;
+    getCwd(): string;
+    listCommands?(): ICommandListEntry[];
+    listEditCheckpoints(): IEditCheckpointSummary[];
+    inspectEditCheckpoint?(checkpointId: string): IEditCheckpointInspection;
+    restoreEditCheckpoint(checkpointId: string): Promise<IEditCheckpointRestoreResult>;
+    rollbackEditCheckpoint(checkpointId: string): Promise<IEditCheckpointRestoreResult>;
+    getUsedMemoryReferences(): IMemoryReference[];
+    recordMemoryEvent(event: IMemoryEvent): void;
+    listBackgroundTasks(filter?: IBackgroundTaskListFilter): IBackgroundTaskState[];
+    readBackgroundTaskLog(taskId: string, cursor?: IBackgroundTaskLogCursor): Promise<IBackgroundTaskLogPage>;
+    cancelBackgroundTask(taskId: string, reason?: string): Promise<void>;
+    closeBackgroundTask(taskId: string): Promise<void>;
+}
+
+type TSystemCommandLifecycle = 'inline' | 'blocking' | 'background';
+/** A user-visible command with descriptor metadata and execute logic. */
+interface ISystemCommand {
+    name: string;
+    description: string;
+    modelInvocable?: boolean;
+    userInvocable?: boolean;
+    argumentHint?: string;
+    safety?: TCapabilitySafety;
+    subcommands?: readonly ICommand[];
+    lifecycle?: TSystemCommandLifecycle;
+    execute(context: ICommandHostContext, args: string): Promise<ICommandResult> | ICommandResult;
+}
+
+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[];
+}
+
+interface IProviderProfileSettings extends IProviderProfileConfig {
+    [key: string]: TUniversalValue;
+}
+interface ILegacyProviderSettings {
+    [key: string]: TUniversalValue;
+    name?: string;
+    model?: string;
+    apiKey?: string;
+    baseURL?: string;
+    timeout?: number;
+    options?: Record<string, TUniversalValue>;
+}
+type TProviderSettingsDocument = Record<string, TUniversalValue> & {
+    currentProvider?: string;
+    providers?: Record<string, IProviderProfileSettings>;
+    provider?: ILegacyProviderSettings;
+};
+interface IProviderSetupInput {
+    profile: string;
+    type: string;
+    model?: string;
+    apiKey?: string;
+    apiKeyEnv?: string;
+    baseURL?: string;
+    timeout?: number;
+    setCurrent?: boolean;
+}
+interface IProviderSetupPatch {
+    currentProvider?: string;
+    providers: Record<string, IProviderProfileSettings>;
+}
+interface IProviderSettingsBuildOptions {
+    providerDefinitions?: readonly IProviderDefinition[];
+}
+declare function upsertProviderProfile(settings: TProviderSettingsDocument, profileName: string, profile: IProviderProfileSettings): TProviderSettingsDocument;
+declare function setCurrentProvider(settings: TProviderSettingsDocument, profileName: string): TProviderSettingsDocument;
+declare function validateProviderProfile(profileName: string, profile: IProviderProfileSettings, options?: IProviderSettingsBuildOptions): void;
+declare function buildProviderSetupPatch(input: IProviderSetupInput, options?: IProviderSettingsBuildOptions): IProviderSetupPatch;
+declare function buildProviderProfile(input: IProviderSetupInput, options?: IProviderSettingsBuildOptions): IProviderProfileSettings;
+declare function mergeProviderPatch(settings: TProviderSettingsDocument, patch: IProviderSetupPatch): TProviderSettingsDocument;
+
+interface IProviderCommandSettingsAdapter {
+    readMergedSettings(): TProviderSettingsDocument;
+    readTargetSettings(): TProviderSettingsDocument;
+    writeTargetSettings(settings: TProviderSettingsDocument): void;
+}
+interface IProviderCommandModuleOptions {
+    providerDefinitions: readonly IProviderDefinition[];
+    settings: IProviderCommandSettingsAdapter;
+}
+
+type TProviderSetupType = string;
+type TPromptInput = (label: string, masked?: boolean) => Promise<string>;
+interface IProviderSetupPromptStep extends IProviderSetupStepDefinition {
+    key: TProviderSetupField;
+}
+interface IProviderSetupFlowState {
+    type: TProviderSetupType;
+    steps: readonly IProviderSetupPromptStep[];
+    stepIndex: number;
+    values: Partial<Record<TProviderSetupField, string>>;
+}
+type TProviderSetupFlowSubmitResult = {
+    status: 'next';
+    state: IProviderSetupFlowState;
+} | {
+    status: 'complete';
+    input: IProviderSetupInput;
+} | {
+    status: 'error';
+    state: IProviderSetupFlowState;
+    message: string;
+};
+declare function createProviderSetupFlow(type: TProviderSetupType, providerDefinitions: readonly IProviderDefinition[]): IProviderSetupFlowState;
+declare function formatProviderSetupSelectionPrompt(providerDefinitions: readonly IProviderDefinition[]): string;
+declare function resolveProviderSetupSelection(rawValue: string, providerDefinitions: readonly IProviderDefinition[]): TProviderSetupType;
+declare function getProviderSetupStep(state: IProviderSetupFlowState): IProviderSetupPromptStep;
+declare function submitProviderSetupValue(state: IProviderSetupFlowState, rawValue: string): TProviderSetupFlowSubmitResult;
+declare function runProviderSetupPromptFlow(type: TProviderSetupType, promptInput: TPromptInput, providerDefinitions: readonly IProviderDefinition[]): Promise<IProviderSetupInput>;
+declare function formatProviderSetupPromptLabel(step: IProviderSetupPromptStep): string;
+declare function formatProviderSetupChoiceLabel(definition: IProviderDefinition): string;
+declare function validateProviderSetupValue(step: IProviderSetupPromptStep, value: string): string | undefined;
+
+declare function isEnvReference(value: string): boolean;
+declare function formatEnvReference(name: string): string;
+declare function resolveEnvReference(value: string): string | undefined;
+declare function hasUsableSecretReference(value: string | undefined): boolean;
+
+declare function testProviderProfileCommand(currentProvider: string | undefined, providers: Record<string, IProviderProfileSettings> | undefined, profileArg: string | undefined, options: IProviderCommandModuleOptions): Promise<ICommandResult>;
+declare function probeProviderProfile(profile: IProviderProfileConfig): Promise<IProviderProbeResult>;
+
+declare const HELP_COMMAND_DESCRIPTION = "Show available commands";
+declare function formatCommandHelpMessage(context: ICommandHostContext): string;
+
+declare const BACKGROUND_COMMAND_DESCRIPTION = "List and control background tasks";
+declare const BACKGROUND_COMMAND_USAGE = "Usage: background list | background read <task-id> [offset] | background cancel <task-id> | background close <task-id>";
+declare function buildBackgroundCommandSubcommands(): ICommand[];
+declare function formatCommandBackgroundTask(task: IBackgroundTaskState): string;
+declare function formatCommandBackgroundTaskList(tasks: IBackgroundTaskState[]): string;
+declare function parseCommandBackgroundLogCursor(value?: string): IBackgroundTaskLogCursor | undefined;
+declare function listCommandBackgroundTasks(context: ICommandHostContext, filter?: IBackgroundTaskListFilter): IBackgroundTaskState[];
+declare function readCommandBackgroundTaskLog(context: ICommandHostContext, taskId: string, cursor?: IBackgroundTaskLogCursor): Promise<IBackgroundTaskLogPage>;
+declare function cancelCommandBackgroundTask(context: ICommandHostContext, taskId: string, reason?: string): Promise<void>;
+declare function closeCommandBackgroundTask(context: ICommandHostContext, taskId: string): Promise<void>;
+
+declare const MODEL_COMMAND_DESCRIPTION = "Change AI model";
+declare const MODEL_COMMAND_ARGUMENT_HINT = "<model-id>";
+declare function buildModelCommandSubcommands(source?: string): ICommand[];
+
+declare const LANGUAGE_COMMAND_DESCRIPTION = "Set response language";
+declare const LANGUAGE_COMMAND_ARGUMENT_HINT = "<code>";
+declare const RECOMMENDED_RESPONSE_LANGUAGES: readonly [{
+    readonly code: "ko";
+    readonly description: "Korean";
+}, {
+    readonly code: "en";
+    readonly description: "English";
+}, {
+    readonly code: "ja";
+    readonly description: "Japanese";
+}, {
+    readonly code: "zh";
+    readonly description: "Chinese";
+}];
+type TRecommendedResponseLanguage = (typeof RECOMMENDED_RESPONSE_LANGUAGES)[number]['code'];
+declare function buildLanguageCommandSubcommands(source?: string): ICommand[];
+declare function parseLanguageArgument(args: string): string | undefined;
+declare function formatLanguageUsageMessage(commandName?: string): string;
+
+declare const PERMISSION_MODE_COMMAND_DESCRIPTION = "Show/change permission mode";
+declare const PERMISSION_MODE_ARGUMENT_HINT = "plan | default | acceptEdits | bypassPermissions";
+declare const PERMISSIONS_COMMAND_DESCRIPTION = "Show permission rules";
+interface IPermissionsCommandState {
+    readonly mode: TPermissionMode;
+    readonly sessionAllowed: readonly string[];
+}
+declare const VALID_PERMISSION_MODES: readonly TPermissionMode[];
+declare function buildPermissionModeSubcommands(source?: string): ICommand[];
+declare function parsePermissionModeArgument(args: string): string | undefined;
+declare function isPermissionMode(value: string): value is TPermissionMode;
+declare function formatInvalidPermissionModeMessage(): string;
+declare function resolvePermissionModeAdapter(context: ICommandHostContext): ICommandPermissionModeAdapter;
+declare function readCommandPermissionMode(context: ICommandHostContext): TPermissionMode;
+declare function writeCommandPermissionMode(context: ICommandHostContext, mode: TPermissionMode): void;
+declare function listCommandSessionAllowedTools(context: ICommandHostContext): readonly string[];
+declare function readCommandPermissionsState(context: ICommandHostContext): IPermissionsCommandState;
+declare function formatCommandPermissionsMessage(state: IPermissionsCommandState): string;
+
+declare const CLEAR_COMMAND_DESCRIPTION = "Clear conversation history";
+declare const RENAME_COMMAND_DESCRIPTION = "Rename the current session";
+declare const RENAME_COMMAND_USAGE = "Usage: rename <name>";
+declare const RESUME_COMMAND_DESCRIPTION = "Resume a previous session";
+declare const COST_COMMAND_DESCRIPTION = "Show session info";
+declare const EXIT_COMMAND_DESCRIPTION = "Exit CLI";
+interface ICommandSessionInfo {
+    sessionId: string;
+    messageCount: number;
+}
+declare function clearConversationHistory(context: ICommandHostContext): void;
+declare function parseSessionNameArgument(args: string): string | undefined;
+declare function createSessionRenamedEffect(name: string): TCommandEffect;
+declare function createSessionPickerRequestedEffect(): TCommandEffect;
+declare function createSessionExitRequestedEffect(): TCommandEffect;
+declare function readCommandSessionInfo(context: ICommandHostContext): ICommandSessionInfo;
+
+declare const REWIND_COMMAND_DESCRIPTION = "List, inspect, restore, or rollback edit checkpoints.";
+declare const REWIND_COMMAND_ARGUMENT_HINT = "list | inspect CHECKPOINT_ID | restore CHECKPOINT_ID | code CHECKPOINT_ID | rollback CHECKPOINT_ID";
+declare function buildRewindCommandSubcommands(source?: string): ICommand[];
+declare function listCommandEditCheckpoints(context: ICommandHostContext): readonly IEditCheckpointSummary[];
+declare function inspectCommandEditCheckpoint(context: ICommandHostContext, checkpointId: string): IEditCheckpointInspection;
+declare function restoreCommandEditCheckpoint(context: ICommandHostContext, checkpointId: string): Promise<IEditCheckpointRestoreResult>;
+declare function rollbackCommandEditCheckpoint(context: ICommandHostContext, checkpointId: string): Promise<IEditCheckpointRestoreResult>;
+
+declare const MEMORY_COMMAND_DESCRIPTION = "Project memory command. Use it to inspect project memory when stored context may help, save durable preferences, project conventions, feedback, or references worth reusing across sessions, review pending candidates, and report memory provenance. Do not store secrets, credentials, or transient facts.";
+declare const MEMORY_COMMAND_ARGUMENT_HINT = "list | show [topic] | add <user|feedback|project|reference> <topic> <text> | pending | approve <id> | reject <id> | used";
+declare const MEMORY_COMMAND_USAGE = "Usage: memory list | memory show [topic] | memory add <user|feedback|project|reference> <topic> <text> | memory pending | memory approve <id> | memory reject <id> | memory used";
+interface ICommandProjectMemoryStore {
+    list(): IProjectMemorySummary;
+    loadStartupMemory(): IStartupMemory;
+    readTopic(topic: string): string;
+    append(input: IAppendMemoryInput): IAppendMemoryResult;
+}
+interface ICommandPendingMemoryStore {
+    get(id: string): IMemoryPendingRecord | undefined;
+    list(status?: TMemoryCandidateStatus): IMemoryPendingRecord[];
+    mark(id: string, status: TMemoryCandidateStatus, reason: string): IMemoryPendingRecord;
+    upsert(candidate: IMemoryCandidate, status: TMemoryCandidateStatus, reason: string): void;
+}
+interface ICommandMemoryStores {
+    project: ICommandProjectMemoryStore;
+    pending: ICommandPendingMemoryStore;
+}
+
+declare function buildMemoryCommandSubcommands(source?: string): ICommand[];
+declare function createCommandProjectMemoryStore(cwd: string, now?: () => Date): ICommandProjectMemoryStore;
+declare function createCommandPendingMemoryStore(cwd: string, now?: () => Date): ICommandPendingMemoryStore;
+declare function createCommandMemoryStores(context: ICommandHostContext, now?: () => Date): ICommandMemoryStores;
+declare function isCommandMemoryType(value: string): value is TMemoryType;
+declare function hasSensitiveCommandMemoryContent(text: string): boolean;
+declare function listCommandUsedMemoryReferences(context: ICommandHostContext): readonly IMemoryReference[];
+declare function recordCommandMemoryEvent(context: ICommandHostContext, event: Omit<IMemoryEvent, 'at'>, now?: () => Date): void;
+
+/** Aggregates commands from multiple sources */
+declare class CommandRegistry {
+    private sources;
+    addSource(source: ICommandSource): void;
+    replaceSource(name: string, 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[];
+}
+
+/** Command source for SDK-owned built-in commands. */
+declare class BuiltinCommandSource implements ICommandSource {
+    readonly name = "builtin";
+    private readonly commands;
+    constructor(systemCommands?: readonly ISystemCommand[]);
+    getCommands(): ICommand[];
+}
+declare function createBuiltinCommandModule(): ICommandModule;
+
+interface IFrontmatter {
+    name?: string;
+    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[];
+}
+
+/**
+ * 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;
+} | {
+    type: 'local';
+    path: string;
+} | {
+    type: 'url';
+    url: string;
+};
+/** 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>;
+}
+/** 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;
+}
+
+/**
+ * Types for the BundlePlugin system.
+ *
+ * A BundlePlugin is a directory-based plugin package that bundles
+ * skills, hooks, agents, and MCP server configurations.
+ */
+/** 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;
+    version: string;
+    description: 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>;
+
+/**
+ * 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.
+ */
+
+/** 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;
+}
+
+/**
+ * Shared types for marketplace client and registry.
+ */
+/** 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;
+}
+
+/**
+ * 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`.
+ */
+
+/** 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;
+}
+
+/**
+ * BundlePluginInstaller — installs, uninstalls, enables, and disables bundle plugins.
+ *
+ * Resolves plugin sources from marketplace manifests, copies/clones to the
+ * cache directory, and tracks installations in `installed_plugins.json`.
+ */
+
+/** 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;
+}
+
+/**
+ * Command source that discovers skills and commands from loaded BundlePlugins.
+ *
+ * - 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[];
+}
+
+/** 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: ICommandHostContext, args: string): Promise<ICommandResult | null>;
+    getCommand(name: string): ISystemCommand | undefined;
+    executeCommand(command: ISystemCommand, session: ICommandHostContext, args: string): Promise<ICommandResult>;
+    /** List all registered commands. */
+    listCommands(): ISystemCommand[];
+    listModelInvocableCommands(): ICapabilityDescriptor[];
+    isModelInvocable(name: string): boolean;
+    executeModelInvocable(name: string, session: ICommandHostContext, args: string): Promise<ICommandResult | null>;
+    /** Check if a command exists. */
+    hasCommand(name: string): boolean;
+}
+
+/** Built-in system commands. */
+declare function createSystemCommands(): ISystemCommand[];
+
+/**
+ * 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;
+}
+/**
+ * Substitute variables in skill content.
+ *
+ * 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 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>;
+
+/**
+ * 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;
+    /** Tools the subagent is allowed to use */
+    allowedTools?: string[];
+}
+/** 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>;
+}
+/** 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>;
+
+/**
+ * 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;
+    toolResultData?: string;
+}
+/** A single diff line for Edit tool display. */
+interface IDiffLine {
+    type: 'add' | 'remove' | 'context' | 'hunk';
+    text: string;
+    lineNumber: number;
+}
+interface IUsageSnapshot {
+    kind: 'exact' | 'estimated';
+    scope: 'turn';
+    totalTokens: number;
+    promptTokens?: number;
+    completionTokens?: number;
+    contextUsedTokens: number;
+    contextMaxTokens: number;
+    contextUsedPercentage: number;
+    costStatus: 'unknown' | 'estimated' | 'exact';
+}
+/** Result of a completed prompt execution. */
+interface IExecutionResult {
+    response: string;
+    history: IHistoryEntry[];
+    toolSummaries: IToolSummary[];
+    contextState: IContextWindowState;
+    usage?: IUsageSnapshot;
+}
+/** 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;
+    compact: (event: ICompactEvent) => void;
+    interrupted: (result: IExecutionResult) => void;
+    background_task_event: (event: TBackgroundTaskEvent) => void;
+    background_job_group_event: (event: TBackgroundJobGroupEvent) => 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') */
+    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>;
+}
+
+/**
+ * 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.
+ */
+interface IAgentDefinition {
+    /** Unique name used to reference the agent (e.g., 'Explore', 'Plan'). */
+    name: string;
+    /** Human-readable description of the agent's purpose. */
+    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[];
+}
 
 /**
  * Zod schemas and TypeScript types for Robota CLI settings
  */
 
-declare const HooksSchema: z.ZodOptional<z.ZodObject<{
-    PreToolUse: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        matcher: z.ZodString;
-        hooks: z.ZodArray<z.ZodObject<{
-            type: z.ZodLiteral<"command">;
-            command: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            type: "command";
-            command: string;
-        }, {
-            type: "command";
-            command: string;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }, {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }>, "many">>;
-    PostToolUse: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        matcher: z.ZodString;
-        hooks: z.ZodArray<z.ZodObject<{
-            type: z.ZodLiteral<"command">;
-            command: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            type: "command";
-            command: string;
-        }, {
-            type: "command";
-            command: string;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }, {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }>, "many">>;
-    SessionStart: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        matcher: z.ZodString;
-        hooks: z.ZodArray<z.ZodObject<{
-            type: z.ZodLiteral<"command">;
-            command: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            type: "command";
-            command: string;
-        }, {
-            type: "command";
-            command: string;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }, {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }>, "many">>;
-    Stop: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        matcher: z.ZodString;
-        hooks: z.ZodArray<z.ZodObject<{
-            type: z.ZodLiteral<"command">;
-            command: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            type: "command";
-            command: string;
-        }, {
-            type: "command";
-            command: string;
-        }>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }, {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }>, "many">>;
-}, "strip", z.ZodTypeAny, {
-    PreToolUse?: {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }[] | undefined;
-    PostToolUse?: {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }[] | undefined;
-    SessionStart?: {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }[] | undefined;
-    Stop?: {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }[] | undefined;
-}, {
-    PreToolUse?: {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }[] | undefined;
-    PostToolUse?: {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }[] | undefined;
-    SessionStart?: {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }[] | undefined;
-    Stop?: {
-        matcher: string;
-        hooks: {
-            type: "command";
-            command: string;
-        }[];
-    }[] | undefined;
-}>>;
 /**
  * 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;
         model: string;
         apiKey: string | undefined;
+        baseURL?: string;
+        timeout?: number;
+        options?: Record<string, TUniversalValue>;
     };
     permissions: {
         allow: string[];
         deny: string[];
     };
     env: Record<string, string>;
-    hooks?: z.infer<typeof HooksSchema>;
+    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;
+        };
+    }>;
+    /** Auto-compact threshold as a 0-1 fraction. Set false to disable automatic compaction. */
+    autoCompactThreshold?: number | false;
 }
 
 interface ILoadedContext {
@@ -193,16 +1397,156 @@ interface ILoadedContext {
     agentsMd: string;
     /** Concatenated content of all CLAUDE.md files found (root-first) */
     claudeMd: string;
+    /** Startup project memory index loaded from .robota/memory/MEMORY.md, if present */
+    memoryMd?: string;
+    /** Formatted active task context loaded from .agents/tasks/*.md, if present */
+    taskContext?: string;
     /** Extracted "Compact Instructions" section from CLAUDE.md, if present */
     compactInstructions?: string;
 }
+
 /**
- * Load all AGENTS.md and CLAUDE.md files found by walking up from `cwd`.
- * Files from higher directories appear before files from lower directories.
+ * Subagent session factory — assembles an isolated child Session for subagent execution.
  *
- * @param cwd - Starting directory for the walk-up search
+ * 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.
  */
-declare function loadContext(cwd: string): Promise<ILoadedContext>;
+
+/** 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;
+        denied?: boolean;
+        toolResultData?: string;
+    }) => void;
+}
+/**
+ * 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;
+        denied?: boolean;
+        toolResultData?: string;
+    }) => void;
+    customAgentRegistry?: (name: string) => IAgentDefinition | undefined;
+}
+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';
@@ -213,33 +1557,71 @@ interface IProjectInfo {
     packageManager?: TPackageManager;
     language: TLanguage;
 }
-/**
- * Detect the project type, language, name, and package manager from `cwd`.
- */
-declare function detectProject(cwd: string): Promise<IProjectInfo>;
-
-/**
- * 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;
+    /** Startup project memory index loaded from .robota/memory/MEMORY.md */
+    memoryMd?: string;
+    /** Formatted active task context loaded from .agents/tasks/*.md */
+    taskContext?: 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[];
 }
-/**
- * Assemble the full system prompt string from the provided parameters.
- */
-declare function buildSystemPrompt(params: ISystemPromptParams): string;
+
+type TReversibleExecutionIsolation = 'none' | 'worktree' | 'provider-sandbox';
+type TReversibleRollbackLayer = 'none' | 'edit-checkpoint' | 'worktree' | 'provider-sandbox';
+type TReversibleSideEffect = 'none' | 'file-mutation' | 'shell-process' | 'subagent' | 'unknown';
+type TReversibleSafetyStatus = 'reversible' | 'read-only' | 'requires-checkpoint' | 'requires-isolation' | 'unknown';
+interface IReversibleExecutionOptions {
+    mode: 'local-first';
+    isolation?: TReversibleExecutionIsolation;
+    enforceUntrackedSideEffects?: boolean;
+}
+interface IReversibleToolSafetyContext {
+    checkpointAvailable: boolean;
+    isolation: TReversibleExecutionIsolation;
+}
+interface IReversibleToolSafetyInput {
+    toolName: string;
+    toolArgs?: TToolArgs;
+    context: IReversibleToolSafetyContext;
+}
+interface IReversibleToolSafetyReport {
+    toolName: string;
+    reversible: boolean;
+    sideEffect: TReversibleSideEffect;
+    rollbackLayer: TReversibleRollbackLayer;
+    status: TReversibleSafetyStatus;
+    message: string;
+}
+declare function evaluateReversibleToolSafety(input: IReversibleToolSafetyInput): IReversibleToolSafetyReport;
+declare function wrapReversibleExecutionTools(tools: readonly IToolWithEventService[], options: IReversibleExecutionOptions & {
+    checkpointAvailable: boolean;
+}): IToolWithEventService[];
 
 /**
  * Session factory — assembles a fully-configured Session from config, context,
@@ -250,10 +1632,13 @@ declare function buildSystemPrompt(params: ISystemPromptParams): string;
  * expects as pre-constructed dependencies.
  */
 
+type TAutoCompactThreshold = number | false;
 /** 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 */
@@ -272,35 +1657,69 @@ interface ICreateSessionOptions {
     permissionHandler?: TPermissionHandler;
     /** Callback for text deltas — enables streaming text to the UI in real-time */
     onTextDelta?: (delta: string) => void;
+    /** Callback when context window usage is refreshed */
+    onContextUpdate?: (state: IContextWindowState) => 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;
+        denied?: boolean;
+        toolResultData?: string;
+    }) => void;
     /** Callback when context is compacted */
     onCompact?: (summary: string) => void;
+    /** Callback with structured compaction metadata */
+    onCompactEvent?: (event: ICompactEvent) => void;
     /** Instructions to include in the compaction prompt (e.g. from CLAUDE.md) */
     compactInstructions?: string;
+    /** Auto-compact threshold as a 0-1 fraction. Set false to disable automatic compaction. */
+    autoCompactThreshold?: TAutoCompactThreshold;
     /** 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[];
+    /** Recorder used to snapshot files before Write/Edit tools mutate them. */
+    editCheckpointRecorder?: IEditCheckpointRecorder;
+    /** Opt-in local-first reversible execution policy for write/shell tools. */
+    reversibleExecution?: IReversibleExecutionOptions;
 }
-/**
- * Create a fully-configured Session instance.
- *
- * Assembles provider, tools, and system prompt, then passes them
- * to Session as pre-constructed dependencies.
- */
-declare function createSession(options: ICreateSessionOptions): Session;
 
 /**
  * Default tool set factory — creates the standard set of CLI tools.
  */
 
-/** Human-readable descriptions of the built-in tools (for system prompt) */
-declare const DEFAULT_TOOL_DESCRIPTIONS: string[];
 /**
  * Create the default set of CLI tools.
  * Returns the 8 standard tools as IToolWithEventService[].
@@ -308,54 +1727,409 @@ declare const DEFAULT_TOOL_DESCRIPTIONS: string[];
 declare function createDefaultTools(): IToolWithEventService[];
 
 /**
- * Provider factory — creates an AI provider from resolved config.
+ * 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;
+
+/**
+ * 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 an AI provider from the resolved config.
- * Currently supports Anthropic only. Throws if no API key is available.
+ * 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 createProvider(config: IResolvedConfig): IAIProvider;
+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;
+
+/**
+ * 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[];
+    /** Host adapters available to composed command modules. */
+    commandHostAdapters?: ICommandHostAdapters;
+    /** 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;
+    /** Preloaded config to avoid duplicate discovery when caller needs it too. */
+    config?: IResolvedConfig;
+    /** Opt-in local-first reversible execution policy for write/shell tools. */
+    reversibleExecution?: IReversibleExecutionOptions;
+}
+/** 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[];
+    /** Host adapters available to composed command modules. */
+    commandHostAdapters?: ICommandHostAdapters;
+}
+/** 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.
+ *
+ * Config/context loading is internal. Consumer provides cwd + provider.
+ */
+
+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 memoryEvents;
+    private usedMemoryReferences;
+    private editCheckpointStore;
+    private resumeSessionId?;
+    private forkSession;
+    private backgroundTaskUnsubscribe;
+    private backgroundJobUnsubscribe;
+    private backgroundJobOrchestrator;
+    private readonly commandModules;
+    private readonly commandHostAdapters?;
+    private autoCompactThresholdSource;
+    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<ICommandResult | null>;
+    executeModelCommand(name: string, args: string): Promise<ICommandResult | 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;
+    getAutoCompactThreshold(): number | false;
+    getAutoCompactThresholdSource(): TAutoCompactThresholdSource;
+    setAutoCompactThreshold(threshold: TAutoCompactThreshold$1, source?: TAutoCompactThresholdSource): void;
+    getCommandHostAdapters(): ICommandHostAdapters;
+    clearConversationHistory(): void;
+    compactContext(instructions?: string): Promise<void>;
+    getName(): string | undefined;
+    getCwd(): string;
+    getSession(): Session;
+    listEditCheckpoints(): IEditCheckpointSummary[];
+    inspectEditCheckpoint(checkpointId: string): IEditCheckpointInspection;
+    restoreEditCheckpoint(checkpointId: string): Promise<IEditCheckpointRestoreResult>;
+    rollbackEditCheckpoint(checkpointId: string): Promise<IEditCheckpointRestoreResult>;
+    getUsedMemoryReferences(): IMemoryReference[];
+    recordMemoryEvent(event: IMemoryEvent): void;
+    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 executeForegroundCommand;
+    private executePrompt;
+    private getEditCheckpointStore;
+    private beginEditCheckpointTurn;
+    private finalizeEditCheckpointTurn;
+    private handleTextDelta;
+    private handleCompactEvent;
+    private handleToolExecution;
+    private clearStreaming;
+    private flushStreaming;
+}
 
 /**
- * query() — single entry point for running an AI agent conversation.
- * Automatically loads config, context, and project info.
+ * createQuery() — factory that returns a prompt-only convenience function.
+ *
+ * Usage:
+ *   const query = createQuery({ provider });
+ *   const answer = await query('What files are here?');
  */
 
-interface IQueryOptions {
+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;
-    provider?: IAIProvider;
-    permissionHandler?: (toolName: string, toolArgs: TToolArgs) => Promise<boolean>;
+    /** Permission handler callback. */
+    permissionHandler?: TInteractivePermissionHandler;
+    /** Streaming text callback. */
     onTextDelta?: (delta: string) => void;
-    /** Callback when context is compacted */
-    onCompact?: (summary: string) => void;
 }
 /**
- * query() — single entry point for running an AI agent conversation.
- * Equivalent to Claude Agent SDK's query() function.
- * Automatically loads config, context, and project info.
+ * 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 query(prompt: string, options?: IQueryOptions): Promise<string>;
+declare function createQuery(options: ICreateQueryOptions): (prompt: string) => Promise<string>;
+
+type TSelfHostingVerificationPhase = 'checkpoint' | 'edit' | 'handoff' | 'verify' | 'recover';
+type TSelfHostingLoopState = 'idle' | 'checkpointed' | 'editing' | 'verifying' | 'passed' | 'failed' | 'rolled_back' | 'cancelled';
+type TSelfHostingLoopEvent = 'checkpoint_created' | 'edits_started' | 'edits_applied' | 'verify_passed' | 'verify_failed' | 'rollback_completed' | 'cancelled';
+interface ISelfHostingVerificationPlanInput {
+    changedFiles: readonly string[];
+    packageScopes?: readonly string[];
+    baseRef?: string;
+}
+interface ISelfHostingVerificationStep {
+    id: string;
+    phase: TSelfHostingVerificationPhase;
+    description: string;
+    required: boolean;
+    command?: string;
+}
+interface ISelfHostingVerificationPlan {
+    changedFiles: readonly string[];
+    packageScopes: readonly string[];
+    baseRef: string;
+    steps: readonly ISelfHostingVerificationStep[];
+}
+declare function planSelfHostingVerification(input: ISelfHostingVerificationPlanInput): ISelfHostingVerificationPlan;
+declare function transitionSelfHostingLoop(state: TSelfHostingLoopState, event: TSelfHostingLoopEvent): TSelfHostingLoopState;
 
 /**
- * Load and merge all settings files, validate with Zod, return resolved config.
- *
- * @param cwd - The working directory (project root) to search for .robota/
+ * All built-in agent definitions shipped with the SDK.
+ * Order matters: general-purpose is the default fallback.
  */
-declare function loadConfig(cwd: string): Promise<IResolvedConfig>;
+declare const BUILT_IN_AGENTS: IAgentDefinition[];
+/**
+ * Look up a built-in agent definition by name.
+ * Returns `undefined` if no built-in agent matches.
+ */
+declare function getBuiltInAgent(name: string): IAgentDefinition | undefined;
 
 /**
- * Permission prompt — this is now CLI-specific.
- * Re-exported here for backward compatibility.
- * The canonical implementation lives in @robota-sdk/agent-cli.
+ * AgentTool — spawn a sub-agent with isolated context.
+ *
+ * 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
+ * multiple concurrent sessions without race conditions.
  */
 
+/** Dependencies injected at creation time via createAgentTool factory */
+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;
+/** Retrieve agent tool deps for a given session key. */
+declare function retrieveAgentToolDeps(key: object): IAgentToolDeps | undefined;
 /**
- * Prompt the user for approval before running a tool.
+ * Create an agent tool instance with deps captured in closure.
+ *
+ * Each session gets its own tool instance — no shared mutable state.
  */
-declare function promptForApproval(terminal: ITerminalOutput, toolName: string, toolArgs: TToolArgs): Promise<boolean>;
+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.
@@ -369,6 +2143,8 @@ declare function projectPaths(cwd: string): {
     settingsLocal: string;
     logs: string;
     sessions: string;
+    memory: string;
+    checkpoints: string;
 };
 /** User-level ~/.robota/ paths. */
 declare function userPaths(): {
@@ -376,14 +2152,42 @@ declare function userPaths(): {
     sessions: string;
 };
 
-/** Dependencies injected at registration time */
-interface IAgentToolDeps {
-    config: IResolvedConfig;
-    context: ILoadedContext;
-    projectInfo?: IProjectInfo;
+type TTaskFileStatus = 'todo' | 'in-progress' | 'blocked' | 'completed' | 'unknown';
+interface ITaskContextFile {
+    path: string;
+    relativePath: string;
+    title: string;
+    status: TTaskFileStatus;
+    branch?: string;
+    scope?: string;
+    objective?: string;
+    openItems: readonly string[];
 }
-/** Set dependencies for the agent tool. Must be called before tool is used. */
-declare function setAgentToolDeps(deps: IAgentToolDeps): void;
-declare const agentTool: _robota_sdk_agent_tools.FunctionTool;
+interface ITaskSelectionOptions {
+    currentBranch?: string;
+    maxTasks?: number;
+}
+interface IUpdateTaskFileStatusOptions {
+    now?: Date;
+    progressMessage?: string;
+}
+declare function readCurrentGitBranch(cwd: string): string | undefined;
+declare function discoverTaskFiles(cwd: string): string[];
+declare function parseTaskFile(taskPath: string, cwd: string): ITaskContextFile;
+declare function selectRelevantTasks(tasks: readonly ITaskContextFile[], options?: ITaskSelectionOptions): ITaskContextFile[];
+declare function formatTaskContext(tasks: readonly ITaskContextFile[]): string;
+declare function loadTaskContext(cwd: string, options?: ITaskSelectionOptions): string;
+declare function updateTaskFileStatus(taskPath: string, status: TTaskFileStatus, options?: IUpdateTaskFileStatusOptions): void;
+
+/**
+ * Interactive permission prompt — asks the user whether to allow a tool invocation
+ * using an arrow-key selector. Canonical implementation (SSOT).
+ * Used by both agent-sdk query() and agent-cli.
+ */
+
+/**
+ * Prompt the user for approval before running a tool.
+ */
+declare function promptForApproval(terminal: ITerminalOutput, toolName: string, toolArgs: TToolArgs): Promise<boolean>;
 
-export { DEFAULT_TOOL_DESCRIPTIONS, type ICreateSessionOptions, type ILoadedContext, type IProjectInfo, type IQueryOptions, type IResolvedConfig, type ISystemPromptParams, agentTool, buildSystemPrompt, createDefaultTools, createProvider, createSession, detectProject, loadConfig, loadContext, projectPaths, promptForApproval, query, setAgentToolDeps, userPaths };
+export { AUTO_COMPACT_THRESHOLD_SETTINGS_KEY, AgentExecutor, BACKGROUND_COMMAND_DESCRIPTION, BACKGROUND_COMMAND_USAGE, BUILT_IN_AGENTS, BackgroundJobOrchestrator, BuiltinCommandSource, BundlePluginInstaller, BundlePluginLoader, CLEAR_COMMAND_DESCRIPTION, COST_COMMAND_DESCRIPTION, CommandRegistry, DEFAULT_AUTO_COMPACT_THRESHOLD, DEFAULT_STATUS_LINE_COMMAND_SETTINGS, EXIT_COMMAND_DESCRIPTION, EditCheckpointStore, HELP_COMMAND_DESCRIPTION, type IAgentDefinition, type IAgentExecutorOptions, type IAgentSession, type IAgentToolDeps, type IAppendMemoryInput, type IAppendMemoryResult, 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 ICommandAvailablePlugin, type ICommandChoicePromptOption, type ICommandExecutionToolDeps, type ICommandHostAdapters, type ICommandHostContext, type ICommandInstalledPlugin, type ICommandInteraction, type ICommandListEntry, type ICommandMarketplaceSource, type ICommandMemoryStores, type ICommandModule, type ICommandPendingMemoryStore, type ICommandPermissionModeAdapter, type ICommandPickerAdapter, type ICommandPluginAdapter, type ICommandPluginReloadResult, type ICommandProcessAdapter, type ICommandProjectMemoryStore, type ICommandResult, type ICommandSessionInfo, type ICommandSessionRuntime, type ICommandSettingsAdapter, type ICommandSettingsDocument, type ICommandSource, type ICompactContextResult, type ICreateQueryOptions, type IDiffLine, type IEditCheckpointFileInspection, type IEditCheckpointFileRecord, type IEditCheckpointInspection, type IEditCheckpointInspectionPlan, type IEditCheckpointManifest, type IEditCheckpointRecorder, type IEditCheckpointRestoreResult, type IEditCheckpointSummary, type IEditCheckpointTurnInput, type IExecutionResult, type IForkExecutionOptions, type IInProcessSubagentRunnerDeps, type IInstalledPluginRecord, type IInstalledPluginsRegistry, type IInteractiveSessionEvents, type IInteractiveSessionOptions, type IInteractiveSessionShutdownOptions, type IKnownMarketplaceEntry, type IKnownMarketplacesRegistry, type ILegacyProviderSettings, type ILoadedBundlePlugin, type IMarketplaceClientOptions, type IMarketplaceManifest, type IMarketplacePluginEntry, type IMarketplaceSource, type IMemoryCandidate, type IMemoryEvent, type IMemoryPendingRecord, type IMemoryReference, type IPermissionsCommandState, type IPluginSettings, type IProjectMemorySummary, type IPromptExecutorOptions, type IPromptProvider, type IProviderCommandModuleOptions, type IProviderCommandSettingsAdapter, type IProviderProfileSettings, type IProviderSettingsBuildOptions, type IProviderSetupFlowState, type IProviderSetupInput, type IProviderSetupPatch, type IProviderSetupPromptStep, type IReversibleExecutionOptions, type IReversibleToolSafetyContext, type IReversibleToolSafetyInput, type IReversibleToolSafetyReport, type ISelfHostingVerificationPlan, type ISelfHostingVerificationPlanInput, type ISelfHostingVerificationStep, type ISkillExecutionCallbacks, type ISkillExecutionResult, type IStartupMemory, type IStatusLineCommandSettings, type ISubagentOptions, type ISubagentPromptOptions, type ISystemCommand, type ITaskContextFile, type ITaskSelectionOptions, type IToolState, type IToolSummary, type ITransportAdapter, type IUpdateTaskFileStatusOptions, type IUsageSnapshot, InteractiveSession, LANGUAGE_COMMAND_ARGUMENT_HINT, LANGUAGE_COMMAND_DESCRIPTION, MEMORY_COMMAND_ARGUMENT_HINT, MEMORY_COMMAND_DESCRIPTION, MEMORY_COMMAND_USAGE, MEMORY_INDEX_MAX_BYTES, MEMORY_INDEX_MAX_LINES, MODEL_COMMAND_ARGUMENT_HINT, MODEL_COMMAND_DESCRIPTION, MarketplaceClient, PERMISSIONS_COMMAND_DESCRIPTION, PERMISSION_MODE_ARGUMENT_HINT, PERMISSION_MODE_COMMAND_DESCRIPTION, PLUGIN_COMMAND_ARGUMENT_HINT, PLUGIN_COMMAND_DESCRIPTION, PluginCommandSource, PluginSettingsStore, ProjectMemoryStore, PromptExecutor, RECOMMENDED_RESPONSE_LANGUAGES, RELOAD_PLUGINS_COMMAND_DESCRIPTION, RENAME_COMMAND_DESCRIPTION, RENAME_COMMAND_USAGE, RESUME_COMMAND_DESCRIPTION, REWIND_COMMAND_ARGUMENT_HINT, REWIND_COMMAND_DESCRIPTION, STATUSLINE_COMMAND_ARGUMENT_HINT, STATUSLINE_COMMAND_DESCRIPTION, SkillCommandSource, type SkillPromptContext, SystemCommandExecutor, type TAutoCompactThreshold$1 as TAutoCompactThreshold, type TAutoCompactThresholdSource, type TBackgroundJobGroupEvent, type TBackgroundJobGroupEventListener, type TBackgroundJobGroupIdFactory, type TBackgroundJobGroupStatus, type TBackgroundJobWaitPolicy, type TCapabilityKind, type TCapabilitySafety, type TCommandEffect, type TCommandInteractionPrompt, type TCommandModuleSessionRequirement, type TCommandResultDataValue, type TEditCheckpointFileRestoreAction, type TEnabledPlugins, type TInteractiveEventName, type TInteractivePermissionHandler, type TMemoryCandidateStatus, type TMemoryType, type TPermissionResultValue, type TPluginInstallScope, type TPromptInput, type TProviderFactory, type TProviderSettingsDocument, type TProviderSetupFlowSubmitResult, type TProviderSetupType, type TRecommendedResponseLanguage, type TReversibleExecutionIsolation, type TReversibleRollbackLayer, type TReversibleSafetyStatus, type TReversibleSideEffect, type TSelfHostingLoopEvent, type TSelfHostingLoopState, type TSelfHostingVerificationPhase, type TSessionFactory, type TStatusLineCommandSettingsPatch, type TSubagentRunnerFactory, type TSystemCommandLifecycle, type TTaskFileStatus, VALID_PERMISSION_MODES, assembleSubagentPrompt, buildBackgroundCommandSubcommands, buildLanguageCommandSubcommands, buildMemoryCommandSubcommands, buildModelCommandSubcommands, buildPermissionModeSubcommands, buildPluginCommandSubcommands, buildProviderProfile, buildProviderSetupPatch, buildRewindCommandSubcommands, buildSkillPrompt, buildStatusLineCommandSubcommands, cancelCommandBackgroundTask, clearConversationHistory, closeCommandBackgroundTask, compactCommandContext, createAgentTool, createBackgroundProcessTool, createBuiltinCommandModule, createCommandExecutionTool, createCommandMemoryStores, createCommandPendingMemoryStore, createCommandProjectMemoryStore, createDefaultTools, createPluginRegistryReloadRequestedEffect, createPluginTuiRequestedEffect, createProviderSetupFlow, createQuery, createSessionExitRequestedEffect, createSessionPickerRequestedEffect, createSessionRenamedEffect, createSubagentLogger, createSubagentSession, createSystemCommands, discoverTaskFiles, evaluateReversibleToolSafety, executeSkill, formatCommandBackgroundTask, formatCommandBackgroundTaskList, formatCommandHelpMessage, formatCommandPermissionsMessage, formatEnvReference, formatInvalidPermissionModeMessage, formatLanguageUsageMessage, formatProviderSetupChoiceLabel, formatProviderSetupPromptLabel, formatProviderSetupSelectionPrompt, formatTaskContext, getBuiltInAgent, getForkWorkerSuffix, getProviderSetupStep, getSubagentSuffix, hasSensitiveCommandMemoryContent, hasUsableSecretReference, inspectCommandEditCheckpoint, isCommandMemoryType, isEnvReference, isMemoryType, isPermissionMode, isStatusLineCommandSettingsPatch, listCommandBackgroundTasks, listCommandEditCheckpoints, listCommandSessionAllowedTools, listCommandUsedMemoryReferences, loadTaskContext, mergeProviderPatch, parseCommandBackgroundLogCursor, parseFrontmatter, parseLanguageArgument, parsePermissionModeArgument, parseSessionNameArgument, parseTaskFile, planSelfHostingVerification, preprocessShellCommands, probeProviderProfile, projectPaths, promptForApproval, readAutoCompactThreshold, readAutoCompactThresholdSource, readCommandBackgroundTaskLog, readCommandContextState, readCommandPermissionMode, readCommandPermissionsState, readCommandSessionInfo, readCurrentGitBranch, recordCommandMemoryEvent, resetAutoCompactThresholdSetting, resolveEnvReference, resolvePermissionModeAdapter, resolvePluginCommandAdapter, resolveProviderSetupSelection, resolveSubagentLogDir, restoreCommandEditCheckpoint, retrieveAgentToolDeps, rollbackCommandEditCheckpoint, runProviderSetupPromptFlow, selectRelevantTasks, setCommandAutoCompactThreshold, setCurrentProvider, storeAgentToolDeps, submitProviderSetupValue, substituteVariables, summarizeBackgroundJobGroup, testProviderProfileCommand, transitionSelfHostingLoop, updateTaskFileStatus, upsertProviderProfile, userPaths, validateProviderProfile, validateProviderSetupValue, wrapEditCheckpointTools, wrapReversibleExecutionTools, writeAutoCompactThresholdSetting, writeCommandPermissionMode };