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

package/dist/node/index.d.cts

@@ -1,191 +1,1603 @@
-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 { ISessionReplayValidationResult, ICompactEvent, ITerminalOutput, ISessionLogger, TPermissionHandler, Session, FileSessionLogger } from '@robota-sdk/agent-sessions';
+import { TUniversalValue, TSessionEndReason, TPermissionMode, IToolWithEventService, IContextWindowState, IProviderProfileConfig, IProviderDefinition, TProviderSetupField, IProviderSetupStepDefinition, IProviderSetupHelpLink, IProviderProbeResult, IProviderModelCatalog, IHistoryEntry, TToolArgs, THooksConfig, IAIProvider, IHookTypeExecutor, IHookDefinition, IHookInput, IHookResult, TTrustLevel, TUniversalMessage, IToolSchema } 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, DEFAULT_BACKGROUND_TASK_LOG_PAGE_SIZE, IAgentBackgroundTaskRequest, IBackgroundTaskError, IBackgroundTaskHandle, IBackgroundTaskInput, IBackgroundTaskListFilter, IBackgroundTaskLogCursor, IBackgroundTaskLogPage, IBackgroundTaskManager, IBackgroundTaskManagerOptions, IBackgroundTaskRequest, IBackgroundTaskResult, IBackgroundTaskRunner, IBackgroundTaskStart, IBackgroundTaskState, IBaseBackgroundTaskRequest, ICreateLimitedOutputCaptureOptions, ILimitedOutputCapture, 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, appendPrefixedLogLines, createBackgroundTaskLogPage, createLimitedOutputCapture, createWorktreeSubagentRunner, getBackgroundTaskTransitions, isTerminalBackgroundTaskStatus, transitionBackgroundTaskStatus } from '@robota-sdk/agent-runtime';
+import { ISandboxClient, IWorkspaceManifest, createZodFunctionTool } 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 SDK-projected command 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: 'session-execution-started';
+} | {
+    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;
+    description?: string;
+    options: readonly ICommandChoicePromptOption[];
+    maxVisible?: number;
+} | {
+    kind: 'text';
+    title: string;
+    description?: 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 TPromptFileReferenceReason = 'manual' | 'prompt-reference';
+type TPromptFileReferenceDiagnosticCode = 'not-found' | 'outside-root' | 'directory-not-supported' | 'file-too-large' | 'total-too-large' | 'too-many-references' | 'max-depth' | 'circular-reference' | 'unreadable';
+interface IPromptFileReferenceToken {
+    original: string;
+    path: string;
+    index: number;
+}
+interface IPromptFileReferenceRecord {
+    originalReference: string;
+    sourcePath: string;
+    relativePath: string;
+    reason: TPromptFileReferenceReason;
+    depth: number;
+    byteLength: number;
+}
+interface IResolvedPromptFileReference extends IPromptFileReferenceRecord {
+    content: string;
+}
+interface IPromptFileReferenceDiagnostic {
+    code: TPromptFileReferenceDiagnosticCode;
+    severity: 'error';
+    reference: string;
+    message: string;
+    path?: string;
+}
+interface IPromptFileReferenceLimits {
+    maxDepth?: number;
+    maxReferences?: number;
+    maxFileBytes?: number;
+    maxTotalBytes?: number;
+}
+interface IPromptFileReferenceResolveOptions {
+    cwd: string;
+    limits?: IPromptFileReferenceLimits;
+    reason?: TPromptFileReferenceReason;
+}
+interface IResolvedPromptFileReferences {
+    references: IResolvedPromptFileReference[];
+    diagnostics: IPromptFileReferenceDiagnostic[];
+}
+interface IPromptFileReferenceHistoryData {
+    message: string;
+    references: IPromptFileReferenceRecord[];
+}
+
+type TContextReferenceLoadType = 'manual' | 'prompt-reference';
+type TContextReferenceStatus = 'active' | 'observed';
+interface IContextReferenceItem {
+    id: string;
+    sourcePath: string;
+    relativePath: string;
+    originalReference: string;
+    loadType: TContextReferenceLoadType;
+    status: TContextReferenceStatus;
+    byteLength: number;
+    loadedAt: string;
+    lastUsedAt?: string;
+}
+interface IContextReferenceInventoryLimits {
+    maxActiveReferences?: number;
+    maxActiveBytes?: number;
+    maxObservedReferences?: number;
+}
+interface IContextReferenceAddResult {
+    reference?: IContextReferenceItem;
+    evicted: IContextReferenceItem[];
+    diagnostics: string[];
+}
+interface IContextReferenceRemoveResult {
+    removed?: IContextReferenceItem;
+}
+interface IContextReferenceClearResult {
+    removed: IContextReferenceItem[];
+}
+interface IContextReferenceUpsertResult {
+    references: IContextReferenceItem[];
+    evicted: IContextReferenceItem[];
+}
+declare function createContextReferenceItem(record: IPromptFileReferenceRecord, loadType: TContextReferenceLoadType, status: TContextReferenceStatus, timestamp?: string): IContextReferenceItem;
+declare function upsertContextReference(references: readonly IContextReferenceItem[], item: IContextReferenceItem, limits?: IContextReferenceInventoryLimits): IContextReferenceUpsertResult;
+declare function removeContextReference(references: readonly IContextReferenceItem[], query: string): {
+    references: IContextReferenceItem[];
+    result: IContextReferenceRemoveResult;
+};
+declare function clearContextReferences(references: readonly IContextReferenceItem[]): IContextReferenceClearResult;
+declare function listActiveContextReferences(references: readonly IContextReferenceItem[]): IContextReferenceItem[];
+declare function toContextReferenceRecords(references: readonly IContextReferenceItem[]): IPromptFileReferenceRecord[];
+
+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>;
+/** List context reference inventory entries through the command host facade. */
+declare function listCommandContextReferences(context: ICommandHostContext): IContextReferenceItem[];
+/** Add a manual context reference through the command host facade. */
+declare function addCommandContextReference(context: ICommandHostContext, path: string): Promise<IContextReferenceAddResult>;
+/** Remove a context reference through the command host facade. */
+declare function removeCommandContextReference(context: ICommandHostContext, path: string): IContextReferenceRemoveResult;
+/** Clear all context references through the command host facade. */
+declare function clearCommandContextReferences(context: ICommandHostContext): IContextReferenceClearResult;
+
+interface ICommandListEntry {
+    name: string;
+    description: string;
+}
+interface ICommandSkillListEntry {
+    readonly name: string;
+    readonly description: string;
+    readonly source: string;
+    readonly modelInvocable: boolean;
+    readonly userInvocable: boolean;
+    readonly argumentHint?: string;
+    readonly context?: string;
+    readonly agent?: string;
+}
+type TCommandInvocationSource = 'user' | 'model';
+interface ICommandSkillActivationRequest {
+    readonly invocationSource: TCommandInvocationSource;
+    readonly displayInput?: string;
+    readonly rawInput?: 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 ICommandSessionReplayValidationReport {
+    logFile: string;
+    entryCount: number;
+    validation: ISessionReplayValidationResult;
+}
+interface ICommandHostContext {
+    clearConversationHistory?(): void;
+    validateCurrentSessionReplayLog?(): ICommandSessionReplayValidationReport;
+    getSession(): ICommandSessionRuntime;
+    getContextState(): IContextWindowState;
+    getAutoCompactThreshold(): TAutoCompactThreshold$1;
+    getAutoCompactThresholdSource?(): TAutoCompactThresholdSource;
+    setAutoCompactThreshold?(threshold: TAutoCompactThreshold$1, source?: TAutoCompactThresholdSource): void;
+    getCommandHostAdapters?(): ICommandHostAdapters;
+    compactContext(instructions?: string): Promise<void>;
+    listContextReferences?(): IContextReferenceItem[];
+    addContextReference?(path: string): Promise<IContextReferenceAddResult>;
+    removeContextReference?(path: string): IContextReferenceRemoveResult;
+    clearContextReferences?(): IContextReferenceClearResult;
+    getCwd(): string;
+    getCommandInvocationSource?(): TCommandInvocationSource;
+    listCommands?(): ICommandListEntry[];
+    listSkills?(): ICommandSkillListEntry[];
+    executeSkillCommandByName?(name: string, args: string, request: ICommandSkillActivationRequest): Promise<ICommandResult | null>;
+    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 deleteProviderProfile(settings: TProviderSettingsDocument, profileName: string, options?: {
+    replacementCurrentProvider?: 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;
+}
+
+interface IProviderProfileNameSuggestionInput {
+    type: string;
+    model?: string;
+}
+interface IProviderProfileNameSuggestionOptions {
+    existingProfileNames?: readonly string[];
+}
+declare function suggestProviderProfileName(input: IProviderProfileNameSuggestionInput, options?: IProviderProfileNameSuggestionOptions): string;
+declare function sanitizeProviderProfileName(value: string | undefined): string | undefined;
+
+type TProviderSetupType = string;
+type TPromptInput = (label: string, masked?: boolean) => Promise<string>;
+interface IProviderSetupPromptStep extends IProviderSetupStepDefinition {
+    key: TProviderSetupField;
+}
+interface IProviderSetupFlowState {
+    type: TProviderSetupType;
+    steps: readonly IProviderSetupPromptStep[];
+    setupHelpLinks: readonly IProviderSetupHelpLink[];
+    stepIndex: number;
+    values: Partial<Record<TProviderSetupField, string>>;
+    existingProfileNames: readonly string[];
+    profileName?: string;
+    setCurrent?: boolean;
+}
+interface IProviderSetupFlowOptions {
+    existingProfileNames?: readonly string[];
+    initialValues?: Partial<Record<TProviderSetupField, string>>;
+    profileName?: string;
+    setCurrent?: boolean;
+}
+type TProviderSetupFlowSubmitResult = {
+    status: 'next';
+    state: IProviderSetupFlowState;
+} | {
+    status: 'complete';
+    input: IProviderSetupInput;
+} | {
+    status: 'error';
+    state: IProviderSetupFlowState;
+    message: string;
+};
+declare function createProviderSetupFlow(type: TProviderSetupType, providerDefinitions: readonly IProviderDefinition[], options?: IProviderSetupFlowOptions): 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[], options?: IProviderSetupFlowOptions): Promise<IProviderSetupInput>;
+declare function formatProviderSetupPromptLabel(step: IProviderSetupPromptStep, setupHelpLinks?: readonly IProviderSetupHelpLink[]): string;
+declare function formatProviderSetupChoiceLabel(definition: IProviderDefinition): string;
+declare function formatProviderSetupHelpLinks(setupHelpLinks?: readonly IProviderSetupHelpLink[]): 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>";
+interface IModelCommandSettingsAdapter {
+    readMergedSettings(): TProviderSettingsDocument;
+}
+interface IModelCommandModuleOptions {
+    providerDefinitions: readonly IProviderDefinition[];
+    settings: IModelCommandSettingsAdapter;
+}
+interface IBuildModelCommandSubcommandsOptions {
+    source?: string;
+    providerDefinitions?: readonly IProviderDefinition[];
+    settings?: TProviderSettingsDocument;
+}
+interface IActiveProviderModelCatalogState {
+    providerType: string;
+    catalog?: IProviderModelCatalog;
+    refreshAttempted: boolean;
+    refreshMessage?: string;
+}
+interface IResolveActiveProviderModelCatalogStateOptions {
+    settings?: TProviderSettingsDocument;
+    providerDefinitions?: readonly IProviderDefinition[];
+    refresh?: boolean;
+}
+declare function buildModelCommandSubcommands(sourceOrOptions?: string | IBuildModelCommandSubcommandsOptions): ICommand[];
+declare function formatModelCommandUsageMessage(options?: {
+    settings?: TProviderSettingsDocument;
+    providerDefinitions?: readonly IProviderDefinition[];
+}): string;
+declare function formatModelCommandUsageMessageAsync(options?: IResolveActiveProviderModelCatalogStateOptions): Promise<string>;
+declare function resolveActiveProviderModelCatalog(settings: TProviderSettingsDocument | undefined, providerDefinitions?: readonly IProviderDefinition[]): IProviderModelCatalog | undefined;
+declare function resolveActiveProviderModelCatalogState(options: IResolveActiveProviderModelCatalogStateOptions): Promise<IActiveProviderModelCatalogState | undefined>;
+
+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/change permission mode and 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 VALIDATE_SESSION_COMMAND_DESCRIPTION = "Validate current session replay log";
+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 function validateCommandSessionReplayLog(context: ICommandHostContext): ICommandSessionReplayValidationReport;
+declare function formatCommandSessionReplayValidationReport(report: ICommandSessionReplayValidationReport): string;
+
+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[];
+
+/** 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>;
+
+/**
+ * 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>;
+
+type TSkillActivationSource = 'skill' | 'plugin';
+type TSkillActivationInvocation = 'user-slash' | 'model-tool';
+type TSkillActivationMode = 'inject' | 'fork';
+type TSkillActivationStatus = 'started' | 'completed' | 'failed';
+interface ISkillActivationEvent {
+    readonly type: 'skill-activation';
+    readonly skillName: string;
+    readonly source: TSkillActivationSource;
+    readonly invocation: TSkillActivationInvocation;
+    readonly mode: TSkillActivationMode;
+    readonly status: TSkillActivationStatus;
+    readonly timestamp: string;
+    readonly qualifiedName?: string;
+    readonly error?: string;
+}
+interface ISkillActivationHistoryData extends ISkillActivationEvent {
+    readonly message: string;
+}
+
+declare function buildPromptWithFileReferences(input: string, references: readonly IResolvedPromptFileReference[]): string;
+declare function hasBlockingPromptFileReferenceDiagnostics(diagnostics: readonly IPromptFileReferenceDiagnostic[]): boolean;
+declare function formatPromptFileReferenceDiagnostics(diagnostics: readonly IPromptFileReferenceDiagnostic[]): string;
+declare function toPromptFileReferenceRecords(references: readonly IResolvedPromptFileReference[]): IPromptFileReferenceRecord[];
+declare function createPromptFileReferenceHistoryEntry(references: readonly IResolvedPromptFileReference[]): IHistoryEntry<IPromptFileReferenceHistoryData>;
+
+declare function parsePromptFileReferences(input: string): IPromptFileReferenceToken[];
+
+declare function resolvePromptFileReferences(input: string, options: IPromptFileReferenceResolveOptions): Promise<IResolvedPromptFileReferences>;
+declare function resolvePromptFileReferencePaths(referencePaths: readonly string[], options: IPromptFileReferenceResolveOptions): Promise<IResolvedPromptFileReferences>;
+
+/**
+ * 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;
+    promptFileReferences?: IPromptFileReferenceRecord[];
+}
+/** 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;
+    skill_activation: (event: ISkillActivationEvent) => 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 +1605,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 +1765,110 @@ 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[];
+
+interface IInteractiveSessionRecord {
+    id: string;
+    name?: string;
+    cwd: string;
+    createdAt: string;
+    updatedAt: string;
+    messages: TUniversalMessage[];
+    history?: IHistoryEntry[];
+    systemPrompt?: string;
+    toolSchemas?: IToolSchema[];
+    backgroundTasks?: IBackgroundTaskState[];
+    backgroundTaskEvents?: TBackgroundTaskEvent[];
+    backgroundJobGroups?: IBackgroundJobGroupState[];
+    backgroundJobGroupEvents?: TBackgroundJobGroupEvent[];
+    skillActivationEvents?: ISkillActivationEvent[];
+    memoryEvents?: IMemoryEvent[];
+    usedMemoryReferences?: IMemoryReference[];
+    contextReferences?: IContextReferenceItem[];
+    sandboxSnapshotId?: string;
+}
+interface IInteractiveSessionStore {
+    save(session: IInteractiveSessionRecord): void;
+    load(id: string): IInteractiveSessionRecord | undefined;
+    list(): IInteractiveSessionRecord[];
+    delete(id: string): void;
+}
+interface IResumableSessionSummary {
+    id: string;
+    name?: string;
+    cwd: string;
+    updatedAt: string;
+    messageCount: number;
+    preview: string;
+}
+declare function createProjectSessionStore(cwd: string): IInteractiveSessionStore;
+declare function listResumableSessionSummaries(sessionStore: IInteractiveSessionStore | undefined, cwd: string): IResumableSessionSummary[];
+declare function resolveLatestSessionId(sessionStore: IInteractiveSessionStore | undefined, cwd: string): string | undefined;
+declare function resolveSessionIdByIdOrName(sessionStore: IInteractiveSessionStore | undefined, idOrName: string): string | undefined;
 
 /**
  * Session factory — assembles a fully-configured Session from config, context,
@@ -250,10 +1879,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 */
@@ -265,97 +1897,552 @@ interface ICreateSessionOptions {
     /** Maximum number of agentic turns per run() call. Undefined = unlimited. */
     maxTurns?: number;
     /** Optional session store for persistence */
-    sessionStore?: SessionStore;
+    sessionStore?: IInteractiveSessionStore;
     /** Inject a pre-constructed AI provider (used by tests to avoid real API calls) */
     provider?: IAIProvider;
     /** Custom permission handler (overrides terminal-based prompts, used by Ink UI) */
     permissionHandler?: TPermissionHandler;
     /** Callback for text deltas — enables streaming text to the UI in real-time */
     onTextDelta?: (delta: string) => void;
+    /** 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;
+    /** Optional provider sandbox client used by sandbox-aware built-in tools. */
+    sandboxClient?: ISandboxClient;
 }
-/**
- * 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[].
  */
-declare function createDefaultTools(): IToolWithEventService[];
+interface ICreateDefaultToolsOptions {
+    sandboxClient?: ISandboxClient;
+}
+declare function createDefaultTools(options?: ICreateDefaultToolsOptions): 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;
 
 /**
- * Create an AI provider from the resolved config.
- * Currently supports Anthropic only. Throws if no API key is available.
+ * 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
  */
-declare function createProvider(config: IResolvedConfig): IAIProvider;
 
 /**
- * query() — single entry point for running an AI agent conversation.
- * Automatically loads config, context, and project info.
+ * Create a FileSessionLogger for a subagent session.
+ *
+ * The logger writes JSONL files into a `subagents/` subdirectory under the
+ * parent session's log folder. The directory is created if it does not exist.
+ *
+ * @param parentSessionId - ID of the parent session (used as directory name)
+ * @param agentId - Unique identifier for this subagent run
+ * @param baseLogsDir - Root logs directory (e.g., `.robota/logs`)
+ * @returns A FileSessionLogger writing to the subagent directory
+ */
+declare function createSubagentLogger(parentSessionId: string, _agentId: string, baseLogsDir: string): FileSessionLogger;
+/**
+ * Resolve the subagent log directory path without creating it.
+ *
+ * Useful when the caller needs the path for display or configuration
+ * but does not want to create the directory immediately.
+ *
+ * @param parentSessionId - ID of the parent session
+ * @param baseLogsDir - Root logs directory
+ * @returns The resolved subagent log directory path
+ */
+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.
  */
 
-interface IQueryOptions {
+/** Standard construction: cwd + provider. Config/context loaded internally. */
+interface IInteractiveSessionStandardOptions {
+    cwd: string;
+    provider: IAIProvider;
+    permissionMode?: ICreateSessionOptions['permissionMode'];
+    maxTurns?: number;
+    permissionHandler?: TInteractivePermissionHandler;
+    sessionStore?: IInteractiveSessionStore;
+    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;
+    /** Optional provider sandbox client used by sandbox-aware built-in tools. */
+    sandboxClient?: ISandboxClient;
+    /** Fresh-session workspace manifest applied through the sandbox client. */
+    workspaceManifest?: IWorkspaceManifest;
+    /** Sandbox target root for workspace manifest entries. Defaults to /workspace. */
+    sandboxWorkspaceRoot?: string;
+    /** Provider sandbox snapshot id to restore before replaying saved messages. */
+    sandboxSnapshotId?: string;
+}
+/** Test/advanced construction: inject pre-built session directly. */
+interface IInteractiveSessionInjectedOptions {
+    session: Session;
     cwd?: string;
+    provider?: IAIProvider;
+    permissionMode?: ICreateSessionOptions['permissionMode'];
+    maxTurns?: number;
+    permissionHandler?: TInteractivePermissionHandler;
+    sessionStore?: IInteractiveSessionStore;
+    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 contextReferences;
+    private editCheckpointStore;
+    private resumeSessionId?;
+    private forkSession;
+    private backgroundTaskUnsubscribe;
+    private backgroundJobUnsubscribe;
+    private backgroundJobOrchestrator;
+    private readonly commandModules;
+    private readonly commandHostAdapters?;
+    private readonly skillCommandSource;
+    private skillActivationEvents;
+    private autoCompactThresholdSource;
+    private shuttingDown;
+    private shutdownPromise;
+    private readonly sandboxClient?;
+    private sandboxSnapshotId?;
+    private commandInvocationSource;
+    constructor(options: IInteractiveSessionOptions);
+    private configureInjectedSession;
+    private restoreSessionRecordIfNeeded;
+    private startAsyncInitializationIfNeeded;
+    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>;
+    private executeCommandWithInvocationSource;
+    executeModelCommand(name: string, args: string): Promise<ICommandResult | null>;
+    getCommandInvocationSource(): TCommandInvocationSource;
+    executeSkillCommandByName(name: string, args: string, request: ICommandSkillActivationRequest): Promise<ICommandResult | null>;
+    private executeUserResolvedSkillCommand;
+    listCommands(): Array<{
+        name: string;
+        description: string;
+    }>;
+    listSkills(): ICommandSkillListEntry[];
+    listModelInvocableCommands(): Array<{
+        name: string;
+        description: string;
+    }>;
+    getSkillActivationEvents(): ISkillActivationEvent[];
+    private findSkillCommand;
+    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;
+    listContextReferences(): IContextReferenceItem[];
+    addContextReference(path: string): Promise<IContextReferenceAddResult>;
+    removeContextReference(path: string): IContextReferenceRemoveResult;
+    clearContextReferences(): IContextReferenceClearResult;
+    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 executeSkillWithActivation;
+    private recordSkillActivation;
+    private recordSkillActivationEvent;
+    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 captureSandboxSnapshot;
+    private startForkSkillExecution;
+    private finishForkSkillExecution;
+    private recordForkSkillError;
+    private resolveForkAgentDefinition;
+    private runSkillInFork;
+    private applyForkSkillResult;
+    private executeForegroundCommand;
+    private executePrompt;
+    private recordContextReferenceUsage;
+    private recordPromptContextReferences;
+    private getEditCheckpointStore;
+    private beginEditCheckpointTurn;
+    private finalizeEditCheckpointTurn;
+    private handleTextDelta;
+    private handleCompactEvent;
+    private handleToolExecution;
+    private clearStreaming;
+    private flushStreaming;
+}
+
+/**
+ * createQuery() — factory that returns a prompt-only convenience function.
+ *
+ * Usage:
+ *   const query = createQuery({ provider });
+ *   const answer = await query('What files are here?');
+ */
+
+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 const BUILT_IN_AGENTS: IAgentDefinition[];
+/**
+ * Look up a built-in agent definition by name.
+ * Returns `undefined` if no built-in agent matches.
  */
-declare function loadConfig(cwd: string): Promise<IResolvedConfig>;
+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>;
+
+type TModelCommandDescriptor$1 = Pick<ICapabilityDescriptor, 'name' | 'description' | 'argumentHint'>;
+interface ICommandExecutionToolDeps {
+    isModelInvocable: (command: string) => boolean;
+    execute: (command: string, args: string) => Promise<ICommandResult | null>;
+    commandNames?: readonly string[];
+    commandDescriptors?: readonly TModelCommandDescriptor$1[];
+}
+declare function createCommandExecutionTool(deps: ICommandExecutionToolDeps): ReturnType<typeof createZodFunctionTool>;
+
+declare const MODEL_COMMAND_TOOL_PREFIX: "robota_command_";
+declare const PROVIDER_SAFE_TOOL_NAME_PATTERN: RegExp;
+type TModelCommandDescriptor = Pick<ICapabilityDescriptor, 'name' | 'description' | 'argumentHint'>;
+interface IProjectedModelCommandTool {
+    readonly commandName: string;
+    readonly toolName: string;
+    readonly description: string;
+    readonly descriptor: TModelCommandDescriptor;
+}
+interface IModelCommandToolProjection {
+    readonly commandTools: readonly IProjectedModelCommandTool[];
+    readonly toolNameToCommandName: ReadonlyMap<string, string>;
+    readonly commandNameToToolName: ReadonlyMap<string, string>;
+}
+interface IProjectedCommandExecutionToolsDeps {
+    isModelInvocable: (command: string) => boolean;
+    execute: (command: string, args: string) => Promise<ICommandResult | null>;
+    commandDescriptors: readonly TModelCommandDescriptor[];
+}
+declare function normalizeModelCommandName(command: string): string;
+declare function createProviderSafeModelCommandToolName(commandName: string): string;
+declare function createModelCommandToolProjection(commandDescriptors: readonly TModelCommandDescriptor[]): IModelCommandToolProjection;
+declare function formatProjectedModelCommandToolPromptDescription(projection: IProjectedModelCommandTool): string;
+declare function createProjectedCommandExecutionTools(deps: IProjectedCommandExecutionToolsDeps): Array<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 +2456,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 +2465,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[];
+}
+interface ITaskSelectionOptions {
+    currentBranch?: string;
+    maxTasks?: number;
 }
-/** 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 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 IActiveProviderModelCatalogState, 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 IBuildModelCommandSubcommandsOptions, 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 ICommandSessionReplayValidationReport, type ICommandSessionRuntime, type ICommandSettingsAdapter, type ICommandSettingsDocument, type ICommandSkillListEntry, type ICommandSource, type ICompactContextResult, type IContextReferenceAddResult, type IContextReferenceClearResult, type IContextReferenceInventoryLimits, type IContextReferenceItem, type IContextReferenceRemoveResult, type IContextReferenceUpsertResult, 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 IInteractiveSessionRecord, type IInteractiveSessionShutdownOptions, type IInteractiveSessionStore, 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 IModelCommandModuleOptions, type IModelCommandSettingsAdapter, type IModelCommandToolProjection, type IPermissionsCommandState, type IPluginSettings, type IProjectMemorySummary, type IProjectedCommandExecutionToolsDeps, type IProjectedModelCommandTool, type IPromptExecutorOptions, type IPromptFileReferenceDiagnostic, type IPromptFileReferenceHistoryData, type IPromptFileReferenceLimits, type IPromptFileReferenceRecord, type IPromptFileReferenceResolveOptions, type IPromptFileReferenceToken, type IPromptProvider, type IProviderCommandModuleOptions, type IProviderCommandSettingsAdapter, type IProviderProfileNameSuggestionInput, type IProviderProfileNameSuggestionOptions, type IProviderProfileSettings, type IProviderSettingsBuildOptions, type IProviderSetupFlowOptions, type IProviderSetupFlowState, type IProviderSetupInput, type IProviderSetupPatch, type IProviderSetupPromptStep, type IResolveActiveProviderModelCatalogStateOptions, type IResolvedPromptFileReference, type IResolvedPromptFileReferences, type IResumableSessionSummary, type IReversibleExecutionOptions, type IReversibleToolSafetyContext, type IReversibleToolSafetyInput, type IReversibleToolSafetyReport, type ISelfHostingVerificationPlan, type ISelfHostingVerificationPlanInput, type ISelfHostingVerificationStep, type ISkillActivationEvent, type ISkillActivationHistoryData, 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, MODEL_COMMAND_TOOL_PREFIX, MarketplaceClient, PERMISSIONS_COMMAND_DESCRIPTION, PERMISSION_MODE_ARGUMENT_HINT, PERMISSION_MODE_COMMAND_DESCRIPTION, PLUGIN_COMMAND_ARGUMENT_HINT, PLUGIN_COMMAND_DESCRIPTION, PROVIDER_SAFE_TOOL_NAME_PATTERN, 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 TContextReferenceLoadType, type TContextReferenceStatus, type TEditCheckpointFileRestoreAction, type TEnabledPlugins, type TInteractiveEventName, type TInteractivePermissionHandler, type TMemoryCandidateStatus, type TMemoryType, type TPermissionResultValue, type TPluginInstallScope, type TPromptFileReferenceDiagnosticCode, type TPromptFileReferenceReason, 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 TSkillActivationInvocation, type TSkillActivationMode, type TSkillActivationSource, type TSkillActivationStatus, type TStatusLineCommandSettingsPatch, type TSubagentRunnerFactory, type TSystemCommandLifecycle, type TTaskFileStatus, VALIDATE_SESSION_COMMAND_DESCRIPTION, VALID_PERMISSION_MODES, addCommandContextReference, assembleSubagentPrompt, buildBackgroundCommandSubcommands, buildLanguageCommandSubcommands, buildMemoryCommandSubcommands, buildModelCommandSubcommands, buildPermissionModeSubcommands, buildPluginCommandSubcommands, buildPromptWithFileReferences, buildProviderProfile, buildProviderSetupPatch, buildRewindCommandSubcommands, buildStatusLineCommandSubcommands, cancelCommandBackgroundTask, clearCommandContextReferences, clearContextReferences, clearConversationHistory, closeCommandBackgroundTask, compactCommandContext, createAgentTool, createBackgroundProcessTool, createBuiltinCommandModule, createCommandExecutionTool, createCommandMemoryStores, createCommandPendingMemoryStore, createCommandProjectMemoryStore, createContextReferenceItem, createDefaultTools, createModelCommandToolProjection, createPluginRegistryReloadRequestedEffect, createPluginTuiRequestedEffect, createProjectSessionStore, createProjectedCommandExecutionTools, createPromptFileReferenceHistoryEntry, createProviderSafeModelCommandToolName, createProviderSetupFlow, createQuery, createSessionExitRequestedEffect, createSessionPickerRequestedEffect, createSessionRenamedEffect, createSubagentLogger, createSubagentSession, createSystemCommands, deleteProviderProfile, discoverTaskFiles, evaluateReversibleToolSafety, executeSkill, formatCommandBackgroundTask, formatCommandBackgroundTaskList, formatCommandHelpMessage, formatCommandPermissionsMessage, formatCommandSessionReplayValidationReport, formatEnvReference, formatInvalidPermissionModeMessage, formatLanguageUsageMessage, formatModelCommandUsageMessage, formatModelCommandUsageMessageAsync, formatProjectedModelCommandToolPromptDescription, formatPromptFileReferenceDiagnostics, formatProviderSetupChoiceLabel, formatProviderSetupHelpLinks, formatProviderSetupPromptLabel, formatProviderSetupSelectionPrompt, formatTaskContext, getBuiltInAgent, getForkWorkerSuffix, getProviderSetupStep, getSubagentSuffix, hasBlockingPromptFileReferenceDiagnostics, hasSensitiveCommandMemoryContent, hasUsableSecretReference, inspectCommandEditCheckpoint, isCommandMemoryType, isEnvReference, isMemoryType, isPermissionMode, isStatusLineCommandSettingsPatch, listActiveContextReferences, listCommandBackgroundTasks, listCommandContextReferences, listCommandEditCheckpoints, listCommandSessionAllowedTools, listCommandUsedMemoryReferences, listResumableSessionSummaries, loadTaskContext, mergeProviderPatch, normalizeModelCommandName, parseCommandBackgroundLogCursor, parseFrontmatter, parseLanguageArgument, parsePermissionModeArgument, parsePromptFileReferences, parseSessionNameArgument, parseTaskFile, planSelfHostingVerification, preprocessShellCommands, probeProviderProfile, projectPaths, promptForApproval, readAutoCompactThreshold, readAutoCompactThresholdSource, readCommandBackgroundTaskLog, readCommandContextState, readCommandPermissionMode, readCommandPermissionsState, readCommandSessionInfo, readCurrentGitBranch, recordCommandMemoryEvent, removeCommandContextReference, removeContextReference, resetAutoCompactThresholdSetting, resolveActiveProviderModelCatalog, resolveActiveProviderModelCatalogState, resolveEnvReference, resolveLatestSessionId, resolvePermissionModeAdapter, resolvePluginCommandAdapter, resolvePromptFileReferencePaths, resolvePromptFileReferences, resolveProviderSetupSelection, resolveSessionIdByIdOrName, resolveSubagentLogDir, restoreCommandEditCheckpoint, retrieveAgentToolDeps, rollbackCommandEditCheckpoint, runProviderSetupPromptFlow, sanitizeProviderProfileName, selectRelevantTasks, setCommandAutoCompactThreshold, setCurrentProvider, storeAgentToolDeps, submitProviderSetupValue, substituteVariables, suggestProviderProfileName, summarizeBackgroundJobGroup, testProviderProfileCommand, toContextReferenceRecords, toPromptFileReferenceRecords, transitionSelfHostingLoop, updateTaskFileStatus, upsertContextReference, upsertProviderProfile, userPaths, validateCommandSessionReplayLog, validateProviderProfile, validateProviderSetupValue, wrapEditCheckpointTools, wrapReversibleExecutionTools, writeAutoCompactThresholdSetting, writeCommandPermissionMode };