@robota-sdk/agent-framework 3.0.0-beta.64

package/dist/node/index.d.ts

@@ -0,0 +1,2966 @@
+import { FileSessionLogger, ICompactEvent, ISessionLogger, ISessionReplayValidationResult, ITerminalOutput, Session, TPermissionHandler } from "@robota-sdk/agent-session";
+import { IAIProvider, IContextWindowState, IFileSystem, IFileSystemAsync, IHistoryEntry, IHookInput, IHookResult, IHookTypeExecutor, IProviderConfig, IProviderDefinition, IProviderDefinition as IProviderDefinition$1, IProviderModelCatalog, IProviderProbeResult, IProviderProfileConfig, ISession, ITerminalOutput as ITerminalOutput$1, ITerminalOutput as ITerminalOutput$2, IToolSchema, IToolWithEventService, THookDefinition, THooksConfig, TPermissionMode, TSessionEndReason, TToolArgs, TTrustLevel, TUniversalMessage, TUniversalValue, findProviderDefinition, formatEnvReference, getProviderCredentialRequirement, hasUsableSecretReference, isEnvReference, resolveEnvReference } from "@robota-sdk/agent-core";
+import { IConfigurableTransport, ITransportAdapter, ITransportAdapter as ITransportAdapter$1, ITransportConfig } from "@robota-sdk/agent-interface-transport";
+import { IAgentBackgroundTaskRequest, IBackgroundTaskError, IBackgroundTaskError as IBackgroundTaskError$1, IBackgroundTaskHandle, IBackgroundTaskInput, IBackgroundTaskListFilter, IBackgroundTaskLogCursor, IBackgroundTaskLogCursor as IBackgroundTaskLogCursor$1, IBackgroundTaskLogPage, IBackgroundTaskManager, IBackgroundTaskManager as IBackgroundTaskManager$1, IBackgroundTaskManagerOptions, IBackgroundTaskResult, IBackgroundTaskRunner, IBackgroundTaskStart, IBackgroundTaskState, IBackgroundTaskState as IBackgroundTaskState$1, IBaseBackgroundTaskRequest, ICreateLimitedOutputCaptureOptions, ILimitedOutputCapture, IPreparedSubagentWorktree, IProcessBackgroundTaskRequest, ISerializableProviderProfile, ISubagentJobHandle, ISubagentJobResult, ISubagentJobStart, ISubagentJobState, ISubagentManager, ISubagentManagerOptions, ISubagentRunner, ISubagentRunner as ISubagentRunner$1, ISubagentSpawnRequest, ISubagentWorktreeAdapter, ISubagentWorktreePrepareRequest, IWorktreeSubagentRunnerOptions, TBackgroundPermissionPolicy, TBackgroundPermissionPolicy as TBackgroundPermissionPolicy$1, TBackgroundPrimitive, TBackgroundPrimitive as TBackgroundPrimitive$1, TBackgroundTaskErrorCategory, TBackgroundTaskEvent, TBackgroundTaskEventListener, TBackgroundTaskIdFactory, TBackgroundTaskIsolation, TBackgroundTaskIsolation as TBackgroundTaskIsolation$1, TBackgroundTaskKind, TBackgroundTaskKind as TBackgroundTaskKind$1, TBackgroundTaskMode, TBackgroundTaskMode as TBackgroundTaskMode$1, TBackgroundTaskRequest, TBackgroundTaskRunnerEvent, TBackgroundTaskStatus, TBackgroundTaskStatus as TBackgroundTaskStatus$1, TBackgroundTaskTimeoutReason, TBackgroundTaskTransitionEvent, TSubagentJobMode, TSubagentJobStatus } from "@robota-sdk/agent-executor";
+import { ISandboxClient, IWorkspaceManifest, createZodFunctionTool } from "@robota-sdk/agent-tools";
+
+//#region src/background-tasks/background-job-orchestrator.d.ts
+type TBackgroundJobWaitPolicy = 'detached' | 'wait_all' | 'wait_any' | 'manual';
+type TBackgroundJobGroupStatus = 'running' | 'completed';
+interface IBackgroundJobResultEnvelope {
+  taskId: string;
+  label: string;
+  status: TBackgroundTaskStatus$1;
+  summary?: string;
+  outputRef?: string;
+  error?: IBackgroundTaskError$1;
+  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$1;
+  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;
+//#endregion
+//#region src/background-tasks/execution-workspace-types.d.ts
+declare const EXECUTION_ORIGIN_METADATA_KEYS: {
+  readonly kind: "executionOriginKind";
+  readonly sessionId: "executionOriginSessionId";
+  readonly turnId: "executionOriginTurnId";
+  readonly commandName: "executionOriginCommandName";
+  readonly toolCallId: "executionOriginToolCallId";
+  readonly skillId: "executionOriginSkillId";
+  readonly label: "executionOriginLabel";
+};
+type TExecutionEntryKind = 'main_thread' | 'background_task' | 'background_group';
+type TExecutionWorkspaceStatus = 'active' | 'idle' | TBackgroundTaskStatus$1;
+type TExecutionAttention = 'none' | 'unread' | 'failed' | 'permission' | 'completed';
+type TExecutionWorkspaceVisibility = 'default' | 'collapsed';
+type TExecutionControl = 'select' | 'cancel' | 'close' | 'send' | 'read_log' | 'wait';
+type TExecutionOriginKind = 'user_prompt' | 'slash_command' | 'model_command' | 'tool_call' | 'skill' | 'transport' | 'system';
+type TExecutionDetailRecordKind = 'message' | 'tool_activity' | 'process_output' | 'progress' | 'result' | 'error' | 'group_summary';
+type TExecutionWorkspaceUpdateCause = 'main_thread' | 'background_task' | 'background_group';
+interface IExecutionOrigin {
+  readonly kind: TExecutionOriginKind;
+  readonly sessionId: string;
+  readonly turnId?: string;
+  readonly commandName?: string;
+  readonly toolCallId?: string;
+  readonly skillId?: string;
+  readonly label?: string;
+}
+interface IExecutionWorkspaceEntry {
+  readonly id: string;
+  readonly sourceId: string;
+  readonly kind: TExecutionEntryKind;
+  readonly parentId?: string;
+  readonly groupId?: string;
+  readonly origin: IExecutionOrigin;
+  readonly taskKind?: TBackgroundTaskKind$1;
+  readonly status: TExecutionWorkspaceStatus;
+  readonly title: string;
+  readonly subtitle?: string;
+  readonly preview?: string;
+  readonly currentAction?: string;
+  readonly unread: boolean;
+  readonly attention: TExecutionAttention;
+  readonly visibility: TExecutionWorkspaceVisibility;
+  readonly updatedAt: string;
+  readonly controls: readonly TExecutionControl[];
+}
+interface IExecutionWorkspaceFilter {
+  readonly includeMainThread?: boolean;
+  readonly kinds?: readonly TExecutionEntryKind[];
+  readonly visibility?: readonly TExecutionWorkspaceVisibility[];
+}
+interface IExecutionWorkspaceSnapshot {
+  readonly sessionId: string;
+  readonly selectedEntryId?: string;
+  readonly updatedAt: string;
+  readonly entries: readonly IExecutionWorkspaceEntry[];
+}
+interface IExecutionWorkspaceSnapshotOptions {
+  readonly selectedEntryId?: string;
+  readonly filter?: IExecutionWorkspaceFilter;
+}
+interface IExecutionWorkspaceEvent {
+  readonly type: 'execution_workspace_updated';
+  readonly cause: TExecutionWorkspaceUpdateCause;
+  readonly entryId?: string;
+  readonly snapshot: IExecutionWorkspaceSnapshot;
+}
+interface IExecutionDetailCursor {
+  readonly offset: number;
+}
+interface IExecutionDetailRecord {
+  readonly id: string;
+  readonly kind: TExecutionDetailRecordKind;
+  readonly text: string;
+  readonly timestamp?: string;
+  readonly sourceId?: string;
+}
+interface IExecutionDetailPage {
+  readonly entryId: string;
+  readonly cursor?: IExecutionDetailCursor;
+  readonly nextCursor?: IExecutionDetailCursor;
+  readonly records: readonly IExecutionDetailRecord[];
+}
+interface ICreateMainThreadEntryInput {
+  readonly sessionId: string;
+  readonly isExecuting: boolean;
+  readonly hasPendingPrompt: boolean;
+  readonly historyLength: number;
+  readonly updatedAt: string;
+  readonly preview?: string;
+}
+interface ICreateExecutionWorkspaceSnapshotInput {
+  readonly sessionId: string;
+  readonly mainThread: ICreateMainThreadEntryInput;
+  readonly tasks: readonly IBackgroundTaskState$1[];
+  readonly groups: readonly IBackgroundJobGroupState[];
+  readonly selectedEntryId?: string;
+  readonly filter?: IExecutionWorkspaceFilter;
+}
+interface IExecutionWorkspaceEntryRef {
+  readonly kind: TExecutionEntryKind;
+  readonly sourceId: string;
+}
+interface ICreateMainThreadDetailPageInput {
+  readonly entryId: string;
+  readonly history: readonly IHistoryEntry[];
+  readonly cursor?: IExecutionDetailCursor;
+}
+interface ICreateLineDetailPageInput {
+  readonly entryId: string;
+  readonly lines: readonly string[];
+  readonly cursor?: IBackgroundTaskLogCursor$1;
+  readonly nextCursor?: IBackgroundTaskLogCursor$1;
+  readonly kind?: TExecutionDetailRecordKind;
+}
+declare function createMainThreadExecutionEntryId(sessionId: string): string;
+declare function createBackgroundTaskExecutionEntryId(taskId: string): string;
+declare function createBackgroundGroupExecutionEntryId(groupId: string): string;
+declare function parseExecutionWorkspaceEntryId(entryId: string): IExecutionWorkspaceEntryRef | undefined;
+declare function createExecutionOriginMetadata(origin: IExecutionOrigin): Record<string, TBackgroundPrimitive$1>;
+//#endregion
+//#region src/background-tasks/execution-workspace-projection.d.ts
+declare function createExecutionWorkspaceSnapshot(input: ICreateExecutionWorkspaceSnapshotInput): IExecutionWorkspaceSnapshot;
+//#endregion
+//#region src/background-tasks/execution-workspace-detail.d.ts
+declare function createMainThreadDetailPage(input: ICreateMainThreadDetailPageInput): IExecutionDetailPage;
+declare function createLineDetailPage(input: ICreateLineDetailPageInput): IExecutionDetailPage;
+//#endregion
+//#region src/background-tasks/execution-workspace-spawner.d.ts
+interface ISpawnAgentTaskRequest {
+  readonly label: string;
+  readonly agentType: string;
+  readonly prompt: string;
+  readonly mode?: TBackgroundTaskMode$1;
+  readonly parentTaskId?: string;
+  readonly depth?: number;
+  readonly cwd?: string;
+  readonly model?: string;
+  readonly isolation?: TBackgroundTaskIsolation$1;
+  readonly allowedTools?: readonly string[];
+  readonly disallowedTools?: readonly string[];
+  readonly permissionPolicy?: TBackgroundPermissionPolicy$1;
+  readonly timeoutMs?: number;
+  readonly idleTimeoutMs?: number;
+  readonly maxRuntimeMs?: number;
+  readonly outputLimitBytes?: number;
+  readonly maxTextDeltas?: number;
+  readonly repetitionWindow?: number;
+  readonly repetitionThreshold?: number;
+}
+interface ISpawnProcessTaskRequest {
+  readonly command: string;
+  readonly label?: string;
+  readonly mode?: TBackgroundTaskMode$1;
+  readonly parentTaskId?: string;
+  readonly depth?: number;
+  readonly cwd?: string;
+  readonly shell?: string;
+  readonly env?: Record<string, string>;
+  readonly stdin?: string;
+  readonly timeoutMs?: number;
+  readonly idleTimeoutMs?: number;
+  readonly maxRuntimeMs?: number;
+  readonly outputLimitBytes?: number;
+}
+interface IBackgroundTaskSpawnerGroupRequest {
+  readonly waitPolicy: IBackgroundJobGroupCreateRequest['waitPolicy'];
+  readonly taskIds: readonly string[];
+  readonly label?: string;
+}
+interface IExecutionWorkspaceTaskSpawner {
+  spawnAgent(request: ISpawnAgentTaskRequest): Promise<IBackgroundTaskState$1>;
+  spawnProcess(request: ISpawnProcessTaskRequest): Promise<IBackgroundTaskState$1>;
+  createGroup(request: IBackgroundTaskSpawnerGroupRequest): IBackgroundJobGroupState;
+}
+interface ICreateExecutionWorkspaceTaskSpawnerOptions {
+  readonly manager: IBackgroundTaskManager$1;
+  readonly groupOrchestrator: BackgroundJobOrchestrator;
+  readonly sessionId: string;
+  readonly cwd: string;
+  readonly origin: IExecutionOrigin;
+}
+declare function createExecutionWorkspaceTaskSpawner(options: ICreateExecutionWorkspaceTaskSpawnerOptions): IExecutionWorkspaceTaskSpawner;
+//#endregion
+//#region src/capabilities/types.d.ts
+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;
+}
+//#endregion
+//#region src/command-api/types.d.ts
+/** A command entry */
+interface ICommand {
+  /** Command name without slash (e.g., "mode") — used for invocation */
+  name: string;
+  /** User-friendly display label (e.g., "Interaction Mode"). Falls back to `name` if not set. */
+  displayName?: 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[];
+}
+//#endregion
+//#region src/command-api/statusline/statusline-command-api.d.ts
+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;
+//#endregion
+//#region src/command-api/effects.d.ts
+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: 'settings-tui-requested';
+} | {
+  type: 'session-picker-requested';
+} | {
+  type: 'session-renamed';
+  name: string;
+} | {
+  type: 'conversation-history-cleared';
+} | {
+  type: 'session-execution-started';
+} | {
+  type: 'statusline-settings-patch';
+  patch: TStatusLineCommandSettingsPatch;
+} | {
+  type: 'agent-switcher-requested';
+};
+//#endregion
+//#region src/command-api/interactions.d.ts
+/** 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;
+}
+//#endregion
+//#region src/command-api/command-result.d.ts
+type TCommandResultDataValue = TUniversalValue | Record<string, unknown> | readonly Record<string, unknown>[];
+/** 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, unknown>;
+  /** Typed host effects requested by the command */
+  effects?: readonly TCommandEffect[];
+  /** Command-owned follow-up prompt and continuation */
+  interaction?: ICommandInteraction;
+}
+//#endregion
+//#region src/agents/agent-definition-types.d.ts
+/**
+ * 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[];
+}
+//#endregion
+//#region src/config/config-types.d.ts
+/**
+ * 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?: 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;
+  /** Transport enable/disable + options: transport name -> { enabled, options } */
+  transports?: Record<string, {
+    enabled?: boolean;
+    options?: Record<string, unknown>;
+  }>;
+}
+//#endregion
+//#region src/context/context-file-tracker.d.ts
+/** A single context file entry tracked with its content hash. */
+interface IContextFileEntry {
+  /** Absolute path to the file. */
+  filePath: string;
+  /** Content as read at load time. */
+  content: string;
+  /** SHA-256 hex digest of `content`. */
+  contentHash: string;
+}
+//#endregion
+//#region src/context/context-loader.d.ts
+interface ILoadedContext {
+  /** Concatenated content of all AGENTS.md files found (root-first) */
+  agentsMd: string;
+  /** Concatenated content of all CLAUDE.md files found (root-first) */
+  claudeMd: string;
+  /** 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;
+  /** Per-file entries for all AGENTS.md files, root-first. Present for staleness detection. */
+  agentsFileEntries?: IContextFileEntry[];
+  /** Per-file entries for all CLAUDE.md files, root-first. Present for staleness detection. */
+  claudeFileEntries?: IContextFileEntry[];
+}
+//#endregion
+//#region src/assembly/create-subagent-session.d.ts
+/** 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;
+//#endregion
+//#region src/subagents/in-process-subagent-runner.d.ts
+interface IInProcessSubagentRunnerDeps {
+  config: IResolvedConfig;
+  context: ILoadedContext;
+  tools: IToolWithEventService[];
+  terminal: ITerminalOutput$1;
+  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$1;
+declare function createInProcessSubagentRunner(deps: IInProcessSubagentRunnerDeps): ISubagentRunner$1;
+//#endregion
+//#region src/command-api/plugin/plugin-command-api.d.ts
+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[];
+//#endregion
+//#region src/command-api/host-adapters.d.ts
+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;
+}
+//#endregion
+//#region src/checkpoints/edit-checkpoint-types.d.ts
+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;
+}
+//#endregion
+//#region src/checkpoints/edit-checkpoint-store.d.ts
+interface IEditCheckpointStoreOptions {
+  cwd: string;
+  now?: () => Date;
+}
+declare class EditCheckpointStore {
+  private readonly fs;
+  private readonly fsAsync;
+  private readonly cwd;
+  private readonly rootDir;
+  private readonly now;
+  private activeTurn;
+  constructor(options: IEditCheckpointStoreOptions, fs?: IFileSystem, fsAsync?: IFileSystemAsync);
+  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;
+}
+//#endregion
+//#region src/checkpoints/edit-checkpoint-tools.d.ts
+declare function wrapEditCheckpointTools(tools: readonly IToolWithEventService[], recorder: IEditCheckpointRecorder): IToolWithEventService[];
+//#endregion
+//#region src/memory/project-memory-store.d.ts
+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;
+}
+//#endregion
+//#region src/memory/automatic-memory-types.d.ts
+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>;
+}
+//#endregion
+//#region src/context/prompt-file-reference-types.d.ts
+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;
+  fsAsync?: IFileSystemAsync;
+}
+interface IResolvedPromptFileReferences {
+  references: IResolvedPromptFileReference[];
+  diagnostics: IPromptFileReferenceDiagnostic[];
+}
+interface IPromptFileReferenceHistoryData {
+  message: string;
+  references: IPromptFileReferenceRecord[];
+}
+//#endregion
+//#region src/context/context-reference-inventory.d.ts
+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[];
+//#endregion
+//#region src/command-api/context/context-command-api.d.ts
+type TAutoCompactThreshold = 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;
+/** 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, source: TAutoCompactThresholdSource): void;
+/** Persist an automatic compact policy value through the host settings adapter, when present. */
+declare function writeAutoCompactThresholdSetting(context: ICommandHostContext, threshold: TAutoCompactThreshold): 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;
+//#endregion
+//#region src/command-api/host-context.d.ts
+interface ICommandListEntry {
+  name: string;
+  /** User-friendly display label. Falls back to `name` if not set. */
+  displayName?: 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): void;
+}
+interface ICommandSessionReplayValidationReport {
+  logFile: string;
+  entryCount: number;
+  validation: ISessionReplayValidationResult;
+}
+interface ICommandHostContext {
+  clearConversationHistory?(): void;
+  validateCurrentSessionReplayLog?(): ICommandSessionReplayValidationReport;
+  getAgentJobCapability?(): IAgentJobHostContext | undefined;
+  getSession(): ICommandSessionRuntime;
+  getContextState(): IContextWindowState;
+  getAutoCompactThreshold(): TAutoCompactThreshold;
+  getAutoCompactThresholdSource?(): TAutoCompactThresholdSource;
+  setAutoCompactThreshold?(threshold: TAutoCompactThreshold, 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>;
+}
+interface IAgentJobHostContext {
+  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>;
+  sendAgentJob(jobId: string, prompt: string): Promise<void>;
+  cancelAgentJob(jobId: string, reason?: string): Promise<void>;
+  closeAgentJob(jobId: string): Promise<void>;
+  createBackgroundJobGroup(input: Omit<IBackgroundJobGroupCreateRequest, 'parentSessionId'>): IBackgroundJobGroupState;
+  waitBackgroundJobGroup(groupId: string): Promise<IBackgroundJobGroupState>;
+  readBackgroundTaskLog(taskId: string, cursor?: IBackgroundTaskLogCursor): Promise<IBackgroundTaskLogPage>;
+}
+//#endregion
+//#region src/command-api/contracts.d.ts
+type TSystemCommandLifecycle = 'inline' | 'blocking' | 'background';
+/** A user-visible command with descriptor metadata and execute logic. */
+interface ISystemCommand {
+  name: string;
+  /** User-friendly display label (e.g., "Interaction Mode"). Falls back to `name` if not set. */
+  displayName?: string;
+  description: string;
+  modelInvocable?: boolean;
+  userInvocable?: boolean;
+  argumentHint?: string;
+  safety?: TCapabilitySafety;
+  subcommands?: readonly ICommand[];
+  lifecycle?: TSystemCommandLifecycle;
+  /**
+   * Whether executing this command requires explicit user permission/confirmation.
+   * - `false`: runs immediately without any approval gate
+   * - `true`: user confirmation is required before execution
+   * - `undefined` (default): derived from `safety` — `'read-only'` → false, others → true
+   */
+  requiresPermission?: boolean;
+  execute(context: ICommandHostContext, args: string): Promise<ICommandResult> | ICommandResult;
+}
+//#endregion
+//#region src/command-api/command-module.d.ts
+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[];
+}
+//#endregion
+//#region src/command-api/provider/provider-settings.d.ts
+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$1[];
+}
+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;
+//#endregion
+//#region src/command-api/provider/provider-command-types.d.ts
+interface IProviderCommandSettingsAdapter {
+  readMergedSettings(): TProviderSettingsDocument;
+  readTargetSettings(): TProviderSettingsDocument;
+  writeTargetSettings(settings: TProviderSettingsDocument): void;
+}
+interface IProviderCommandModuleOptions {
+  providerDefinitions: readonly IProviderDefinition$1[];
+  settings: IProviderCommandSettingsAdapter;
+}
+//#endregion
+//#region src/command-api/provider/provider-profile-names.d.ts
+interface IProviderProfileNameSuggestionInput {
+  type: string;
+}
+interface IProviderProfileNameSuggestionOptions {
+  existingProfileNames?: readonly string[];
+}
+declare function suggestProviderProfileName(input: IProviderProfileNameSuggestionInput, options?: IProviderProfileNameSuggestionOptions): string;
+declare function sanitizeProviderProfileName(value: string | undefined): string | undefined;
+//#endregion
+//#region src/command-api/provider/provider-command-probe.d.ts
+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>;
+//#endregion
+//#region src/command-api/provider/settings-check.d.ts
+type TSettingsCheck = 'missing' | 'valid' | 'corrupt' | 'incomplete';
+declare function checkSettingsDocument(settings: TProviderSettingsDocument, providerDefinitions?: readonly IProviderDefinition$1[]): TSettingsCheck;
+//#endregion
+//#region src/command-api/provider/provider-merge.d.ts
+declare function readMergedProviderSettingsFromPaths(paths: readonly string[], fs?: IFileSystem): TProviderSettingsDocument;
+declare function mergeSettings(base: TProviderSettingsDocument, override: TProviderSettingsDocument): TProviderSettingsDocument;
+declare function mergeProviders(base: TProviderSettingsDocument['providers'], override: TProviderSettingsDocument['providers']): TProviderSettingsDocument['providers'];
+declare function resolveActiveProvider(settings: TProviderSettingsDocument, providerOverride: string | undefined, providerDefinitions: readonly IProviderDefinition$1[]): IProviderConfig | undefined;
+//#endregion
+//#region src/command-api/help/help-command-api.d.ts
+declare const HELP_COMMAND_DESCRIPTION = "Show available commands";
+declare function formatCommandHelpMessage(context: ICommandHostContext): string;
+//#endregion
+//#region src/command-api/background/background-command-api.d.ts
+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>;
+//#endregion
+//#region src/command-api/model/model-command-api.d.ts
+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$1[];
+  settings: IModelCommandSettingsAdapter;
+}
+interface IBuildModelCommandSubcommandsOptions {
+  source?: string;
+  providerDefinitions?: readonly IProviderDefinition$1[];
+  settings?: TProviderSettingsDocument;
+}
+interface IActiveProviderModelCatalogState {
+  providerType: string;
+  catalog?: IProviderModelCatalog;
+  refreshAttempted: boolean;
+  refreshMessage?: string;
+}
+interface IResolveActiveProviderModelCatalogStateOptions {
+  settings?: TProviderSettingsDocument;
+  providerDefinitions?: readonly IProviderDefinition$1[];
+  refresh?: boolean;
+}
+declare function buildModelCommandSubcommands(sourceOrOptions?: string | IBuildModelCommandSubcommandsOptions): ICommand[];
+declare function formatModelCommandUsageMessage(options?: {
+  settings?: TProviderSettingsDocument;
+  providerDefinitions?: readonly IProviderDefinition$1[];
+}): string;
+declare function formatModelCommandUsageMessageAsync(options?: IResolveActiveProviderModelCatalogStateOptions): Promise<string>;
+declare function resolveActiveProviderModelCatalog(settings: TProviderSettingsDocument | undefined, providerDefinitions?: readonly IProviderDefinition$1[]): IProviderModelCatalog | undefined;
+declare function resolveActiveProviderModelCatalogState(options: IResolveActiveProviderModelCatalogStateOptions): Promise<IActiveProviderModelCatalogState | undefined>;
+//#endregion
+//#region src/command-api/language/language-command-api.d.ts
+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;
+//#endregion
+//#region src/command-api/permissions/permission-mode-command-api.d.ts
+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;
+//#endregion
+//#region src/command-api/session/session-command-api.d.ts
+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;
+//#endregion
+//#region src/command-api/checkpoint/rewind-command-api.d.ts
+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>;
+//#endregion
+//#region src/command-api/memory/memory-command-api.d.ts
+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;
+//#endregion
+//#region src/commands/command-registry.d.ts
+/** 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[];
+}
+//#endregion
+//#region src/commands/builtin-source.d.ts
+/** 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;
+//#endregion
+//#region src/commands/skill-source.d.ts
+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 readonly fs;
+  private cachedCommands;
+  constructor(cwd: string, home?: string, fs?: IFileSystem);
+  getCommands(): ICommand[];
+  getModelInvocableSkills(): ICommand[];
+  getUserInvocableSkills(): ICommand[];
+}
+//#endregion
+//#region src/plugins/marketplace-types.d.ts
+/**
+ * Shared types for marketplace client and registry.
+ */
+/** Source specification for a marketplace. */
+type TMarketplaceSource = {
+  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: TMarketplaceSource;
+  installLocation: string;
+  lastUpdated: string;
+}
+/** Shape of known_marketplaces.json. */
+type TKnownMarketplacesRegistry = Record<string, IKnownMarketplaceEntry>;
+/** Exec function type for running shell commands. Injected at composition root. */
+type TExecFn = (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;
+  /** Shell exec adapter — must be provided at composition root (e.g., execSync). */
+  exec: TExecFn;
+}
+//#endregion
+//#region src/plugins/plugin-settings-store.d.ts
+/** Persisted marketplace source entry. */
+interface IPersistedMarketplaceSource {
+  source: TMarketplaceSource;
+}
+/** 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;
+  private readonly fs;
+  constructor(settingsPath: string, fs?: IFileSystem);
+  /** 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: TMarketplaceSource): void;
+  /** Remove a marketplace source. */
+  removeMarketplaceSource(name: string): void;
+  private getEnabledPluginsFrom;
+  private getMarketplaceSourcesFrom;
+}
+//#endregion
+//#region src/plugins/bundle-plugin-types.d.ts
+/**
+ * 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>;
+//#endregion
+//#region src/plugins/bundle-plugin-loader.d.ts
+/** Loader for directory-based bundle plugins from the cache directory. */
+declare class BundlePluginLoader {
+  private readonly pluginsDir;
+  private readonly enabledPlugins;
+  private readonly fs;
+  constructor(pluginsDir: string, enabledPlugins?: TEnabledPlugins, fs?: IFileSystem);
+  /** 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 if the manifest structure is invalid. */
+  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 from `.mcp.json` at the plugin root if present. */
+  private loadMcpConfig;
+  /** Load agent definitions from agents/ directory if present. */
+  private loadAgents;
+}
+//#endregion
+//#region src/plugins/marketplace-client.d.ts
+/** Manages marketplace registries via shallow git clones. */
+declare class MarketplaceClient {
+  private readonly pluginsDir;
+  private readonly exec;
+  private readonly marketplacesDir;
+  private readonly registryPath;
+  private readonly fs;
+  constructor(options: IMarketplaceClientOptions & {
+    fs?: IFileSystem;
+  });
+  /**
+   * 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: TMarketplaceSource): 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: TMarketplaceSource;
+    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;
+}
+//#endregion
+//#region src/plugins/bundle-plugin-installer.d.ts
+/** 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 TInstalledPluginsRegistry = Record<string, IInstalledPluginRecord>;
+/** 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;
+  /** Shell exec adapter — must be provided at composition root (e.g., execSync). */
+  exec: TExecFn;
+  /** File system adapter for testability. */
+  fs?: IFileSystem;
+}
+/** 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;
+  private readonly fs;
+  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(): TInstalledPluginsRegistry;
+  /** 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;
+}
+//#endregion
+//#region src/commands/plugin-source.d.ts
+/**
+ * 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[];
+}
+//#endregion
+//#region src/commands/system-command-executor.d.ts
+/** 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;
+  /** Resolve whether a command requires permission confirmation. */
+  resolveRequiresPermission(command: ISystemCommand): boolean;
+  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;
+}
+//#endregion
+//#region src/commands/system-command.d.ts
+/** Built-in system commands. */
+declare function createSystemCommands(): ISystemCommand[];
+//#endregion
+//#region src/utils/skill-prompt.d.ts
+/** Shell exec function for skill preprocessing — injected from composition root. */
+type TShellExecFn = (command: string) => string;
+/** 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.
+ * If no exec function is provided, shell patterns are replaced with empty string.
+ */
+declare function preprocessShellCommands(content: string, exec?: TShellExecFn): Promise<string>;
+//#endregion
+//#region src/commands/skill-executor.d.ts
+/** 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>;
+  /** Shell exec function for preprocessing `` !`cmd` `` patterns — injected from composition root. */
+  shellExec?: TShellExecFn;
+}
+/** 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>;
+//#endregion
+//#region src/commands/skill-activation-events.d.ts
+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;
+}
+//#endregion
+//#region src/context/prompt-file-reference-format.d.ts
+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>;
+//#endregion
+//#region src/context/prompt-file-reference-parser.d.ts
+declare function parsePromptFileReferences(input: string): IPromptFileReferenceToken[];
+//#endregion
+//#region src/context/prompt-file-reference-resolver.d.ts
+declare function resolvePromptFileReferences(input: string, options: IPromptFileReferenceResolveOptions): Promise<IResolvedPromptFileReferences>;
+declare function resolvePromptFileReferencePaths(referencePaths: readonly string[], options: IPromptFileReferenceResolveOptions): Promise<IResolvedPromptFileReferences>;
+//#endregion
+//#region src/interactive/types.d.ts
+/** 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;
+  execution_workspace_event: (event: IExecutionWorkspaceEvent) => void;
+  user_message: (content: string) => void;
+  /** Emitted when a context file (AGENTS.md or CLAUDE.md) is refreshed due to staleness. */
+  context_file_refreshed: (event: IContextFileRefreshedEvent) => void;
+}
+/** Emitted when a context file is found stale and re-read before a turn. */
+interface IContextFileRefreshedEvent {
+  filePath: string;
+}
+type TInteractiveEventName = keyof IInteractiveSessionEvents;
+//#endregion
+//#region src/interactive/i-interactive-session.d.ts
+/** Minimal session surface consumed by transport adapters and test factories. */
+interface IInteractiveSession {
+  /** True once the underlying session has been initialized. */
+  readonly isInitialized?: boolean;
+  submit(input: string, displayInput?: string, rawInput?: string): Promise<void>;
+  abort(): void;
+  cancelQueue(): void;
+  shutdown(options?: {
+    reason?: string;
+    message?: string;
+  }): Promise<void>;
+  isExecuting(): boolean;
+  getPendingPrompt(): string | null;
+  getMessages(): TUniversalMessage[];
+  getContextState(): IContextWindowState;
+  getSession(): {
+    getSessionId(): string;
+  };
+  getCwd(): string;
+  executeCommand(name: string, args: string): Promise<ICommandResult | null>;
+  listCommands(): ICommandListEntry[];
+  on<E extends TInteractiveEventName>(event: E, handler: IInteractiveSessionEvents[E]): void;
+  off<E extends TInteractiveEventName>(event: E, handler: IInteractiveSessionEvents[E]): void;
+  listBackgroundTasks(filter?: IBackgroundTaskListFilter): IBackgroundTaskState[];
+  getBackgroundTask(taskId: string): IBackgroundTaskState | undefined;
+  cancelBackgroundTask(taskId: string, reason?: string): Promise<void>;
+  closeBackgroundTask(taskId: string): Promise<void>;
+  sendBackgroundTask(taskId: string, input: IBackgroundTaskInput): Promise<void>;
+  readBackgroundTaskLog(taskId: string, cursor?: IBackgroundTaskLogCursor): Promise<IBackgroundTaskLogPage>;
+  listBackgroundJobGroups(): IBackgroundJobGroupState[];
+  getBackgroundJobGroup(groupId: string): IBackgroundJobGroupState | undefined;
+  createBackgroundJobGroup(input: Omit<IBackgroundJobGroupCreateRequest, 'parentSessionId'>): IBackgroundJobGroupState;
+  waitBackgroundJobGroup(groupId: string): Promise<IBackgroundJobGroupState>;
+  getExecutionWorkspaceSnapshot(options?: IExecutionWorkspaceSnapshotOptions): IExecutionWorkspaceSnapshot;
+  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>;
+  sendAgentJob(jobId: string, prompt: string): Promise<void>;
+  cancelAgentJob(jobId: string, reason?: string): Promise<void>;
+  closeAgentJob(jobId: string): Promise<void>;
+}
+//#endregion
+//#region src/context/project-detector.d.ts
+type TProjectType = 'node' | 'python' | 'rust' | 'go' | 'unknown';
+type TPackageManager = 'pnpm' | 'yarn' | 'npm' | 'bun';
+type TLanguage = 'typescript' | 'javascript' | 'python' | 'rust' | 'go' | 'unknown';
+interface IProjectInfo {
+  type: TProjectType;
+  name?: string;
+  packageManager?: TPackageManager;
+  language: TLanguage;
+}
+//#endregion
+//#region src/context/system-prompt-builder.d.ts
+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[];
+}
+//#endregion
+//#region src/interactive/session-persistence.d.ts
+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, fs?: IFileSystem): 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;
+//#endregion
+//#region src/reversible-execution/reversible-execution-policy.d.ts
+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[];
+//#endregion
+//#region src/hooks/prompt-executor.d.ts
+/** 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: THookDefinition, input: IHookInput): Promise<IHookResult>;
+}
+//#endregion
+//#region src/hooks/agent-executor.d.ts
+/** 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: THookDefinition, input: IHookInput): Promise<IHookResult>;
+}
+//#endregion
+//#region src/assembly/create-session-types.d.ts
+type TAutoCompactThreshold$1 = 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 */
+  terminal: ITerminalOutput;
+  /** Project metadata for system prompt */
+  projectInfo?: IProjectInfo;
+  /** Initial permission mode (defaults to config.defaultTrustLevel → mode mapping) */
+  permissionMode?: TPermissionMode;
+  /** Maximum number of agentic turns per run() call. Undefined = unlimited. */
+  maxTurns?: number;
+  /** Optional session store for persistence */
+  sessionStore?: 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$1;
+  /** 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;
+  /** Name reported to the underlying Robota agent config. Defaults to 'agent'. */
+  agentName?: string;
+}
+//#endregion
+//#region src/assembly/create-tools.d.ts
+/**
+ * Create the default set of CLI tools.
+ * Returns the 8 standard tools as IToolWithEventService[].
+ */
+interface ICreateDefaultToolsOptions {
+  sandboxClient?: ISandboxClient;
+}
+declare function createDefaultTools(options?: ICreateDefaultToolsOptions): IToolWithEventService[];
+//#endregion
+//#region src/assembly/subagent-prompts.d.ts
+/**
+ * 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;
+//#endregion
+//#region src/assembly/subagent-logger.d.ts
+/**
+ * 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, fs?: IFileSystem): 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;
+//#endregion
+//#region src/interactive/interactive-session-options.d.ts
+/** 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;
+  /** Override config language (e.g., "ko", "en"). Injected into system prompt. */
+  language?: 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;
+  /** Shell exec function for preprocessing `` !`cmd` `` patterns in skills — injected from composition root. */
+  shellExec?: TShellExecFn;
+  /** 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;
+  /** Name reported to the underlying Robota agent config. Defaults to 'agent'. */
+  agentName?: 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 TInteractiveSessionOptions = IInteractiveSessionStandardOptions | IInteractiveSessionInjectedOptions;
+//#endregion
+//#region src/interactive/interactive-session-background-tracker.d.ts
+interface IBackgroundTrackerState {
+  tasks: IBackgroundTaskState[];
+  taskEvents: TBackgroundTaskEvent[];
+  groups: IBackgroundJobGroupState[];
+  groupEvents: TBackgroundJobGroupEvent[];
+}
+declare class SessionBackgroundTaskTracker {
+  private readonly getManager;
+  private readonly onChanged;
+  private readonly emitTaskEvent;
+  private readonly emitGroupEvent;
+  private readonly persistSession;
+  private backgroundTasks;
+  private backgroundTaskEvents;
+  private backgroundJobGroups;
+  private backgroundJobGroupEvents;
+  private backgroundTaskUnsubscribe;
+  private backgroundJobUnsubscribe;
+  private backgroundJobOrchestrator;
+  constructor(getManager: () => IBackgroundTaskManager | undefined, onChanged: (cause: TExecutionWorkspaceUpdateCause, entryId?: string) => void, emitTaskEvent: (event: TBackgroundTaskEvent) => void, emitGroupEvent: (event: TBackgroundJobGroupEvent) => void, persistSession: () => void);
+  subscribe(session: Session): void;
+  dispose(): void;
+  restoreState(state: IBackgroundTrackerState): void;
+  getState(): IBackgroundTrackerState;
+  getManagerOrThrow(): IBackgroundTaskManager;
+  getOrchestratorOrThrow(sessionId: string): BackgroundJobOrchestrator;
+  cancelTask(taskId: string, reason?: string): Promise<void>;
+  closeTask(taskId: string): Promise<void>;
+  sendTask(taskId: string, input: IBackgroundTaskInput): Promise<void>;
+  readTaskLog(taskId: string, cursor?: IBackgroundTaskLogCursor): Promise<IBackgroundTaskLogPage>;
+  listTasks(filter?: IBackgroundTaskListFilter): IBackgroundTaskState[];
+  getTask(taskId: string): IBackgroundTaskState | undefined;
+  createGroup(input: Omit<IBackgroundJobGroupCreateRequest, 'parentSessionId'>, sessionId: string): IBackgroundJobGroupState;
+  listGroups(sessionId: string): IBackgroundJobGroupState[];
+  getGroup(groupId: string, sessionId: string): IBackgroundJobGroupState | undefined;
+  waitGroup(groupId: string, sessionId: string): Promise<IBackgroundJobGroupState>;
+  readTaskDetail(entryId: string, taskId: string, cursor?: IExecutionDetailCursor): Promise<IExecutionDetailPage>;
+  readGroupDetail(entryId: string, groupId: string, sessionId: string): IExecutionDetailPage;
+  getTaskSnapshots(): IBackgroundTaskState[];
+  getGroupSnapshots(): IBackgroundJobGroupState[];
+  private subscribeGroupEvents;
+  private recordTaskEvent;
+  private recordGroupEvent;
+}
+//#endregion
+//#region src/interactive/interactive-session-history-tracker.d.ts
+interface IHistoryTrackerState {
+  history: IHistoryEntry[];
+  memoryEvents: IMemoryEvent[];
+  usedMemoryReferences: IMemoryReference[];
+  contextReferences: IContextReferenceItem[];
+  skillActivationEvents: ISkillActivationEvent[];
+}
+declare class SessionHistoryTracker {
+  private readonly cwd;
+  private readonly getSessionId;
+  private readonly getExecuting;
+  private readonly persistSession;
+  private readonly emitSkillActivation;
+  private history;
+  private editCheckpointStore;
+  private memoryEvents;
+  private usedMemoryReferences;
+  private contextReferences;
+  private skillActivationEvents;
+  constructor(cwd: string, getSessionId: () => string, getExecuting: () => boolean, persistSession: () => void, emitSkillActivation: (event: ISkillActivationEvent) => void, editCheckpointStore?: EditCheckpointStore | null);
+  restoreState(state: IHistoryTrackerState): void;
+  getState(): IHistoryTrackerState;
+  append(entry: IHistoryEntry): void;
+  getHistory(): IHistoryEntry[];
+  clearHistory(): void;
+  resetUsedMemoryReferences(): void;
+  recordContextReferenceUsage(records: readonly IPromptFileReferenceRecord[]): void;
+  recordPromptContextReferences(records: readonly IPromptFileReferenceRecord[]): void;
+  listEditCheckpoints(): IEditCheckpointSummary[];
+  inspectEditCheckpoint(checkpointId: string): IEditCheckpointInspection;
+  restoreEditCheckpoint(checkpointId: string): Promise<IEditCheckpointRestoreResult>;
+  rollbackEditCheckpoint(checkpointId: string): Promise<IEditCheckpointRestoreResult>;
+  beginEditCheckpointTurn(prompt: string): Promise<void>;
+  finalizeEditCheckpointTurn(): Promise<void>;
+  setEditCheckpointStore(store: EditCheckpointStore): void;
+  getUsedMemoryReferences(): IMemoryReference[];
+  recordMemoryEvent(event: IMemoryEvent): void;
+  listContextReferences(): IContextReferenceItem[];
+  addContextReference(path: string): Promise<IContextReferenceAddResult>;
+  removeContextReference(path: string): IContextReferenceRemoveResult;
+  clearContextReferences(): IContextReferenceClearResult;
+  getSkillActivationEvents(): ISkillActivationEvent[];
+  recordSkillActivationEvent(event: ISkillActivationEvent, appendHistory: boolean): void;
+  private getCheckpointStore;
+}
+//#endregion
+//#region src/interactive/interactive-session-skill-router.d.ts
+declare class SessionSkillRouter {
+  private readonly getSession;
+  private readonly getSessionId;
+  private readonly onSubmit;
+  private readonly onApplyResult;
+  private readonly recordSkillActivation;
+  private readonly runSkillInFork;
+  /** Called when a fork-context skill needs full lifecycle management (executing flag etc.) */
+  private readonly onForkSkill;
+  /** Called for blocking commands — wraps execution with thinking/executing lifecycle */
+  private readonly onBlockingCommand;
+  private readonly shellExec?;
+  readonly commandExecutor: SystemCommandExecutor;
+  private readonly skillCommandSource;
+  private readonly commandHostAdapters?;
+  private commandInvocationSource;
+  constructor(commandModules: readonly ICommandModule[], cwd: string, commandHostAdapters: ICommandHostAdapters | undefined, getSession: () => ICommandHostContext, getSessionId: () => string, onSubmit: (prompt: string, displayInput?: string, rawInput?: string) => Promise<void>, onApplyResult: (result: string) => Promise<void>, recordSkillActivation: (event: ISkillActivationEvent, appendHistory: boolean) => void, runSkillInFork: (content: string, options: IForkExecutionOptions) => Promise<string>, /** Called when a fork-context skill needs full lifecycle management (executing flag etc.) */
+
+  onForkSkill: (skill: ICommand, args: string, displayInput: string | undefined, qualifiedName: string | undefined, invocation: ISkillActivationEvent['invocation']) => Promise<ISkillExecutionResult>, /** Called for blocking commands — wraps execution with thinking/executing lifecycle */
+
+  onBlockingCommand: (execute: () => Promise<ICommandResult>) => Promise<ICommandResult>, shellExec?: TShellExecFn | undefined);
+  getCommandInvocationSource(): TCommandInvocationSource;
+  getCommandHostAdapters(): ICommandHostAdapters;
+  listCommands(): Array<{
+    name: string;
+    displayName?: string;
+    description: string;
+  }>;
+  listSkills(): ICommandSkillListEntry[];
+  listModelInvocableCommands(): Array<{
+    name: string;
+    description: string;
+  }>;
+  findSkillCommand(name: string): ICommand | undefined;
+  executeCommand(name: string, args: string): Promise<ICommandResult | null>;
+  executeCommandWithSource(source: TCommandInvocationSource, command: ISystemCommand, args: string): Promise<ICommandResult>;
+  executeModelCommand(name: string, args: string): Promise<ICommandResult | null>;
+  executeSkillCommandByName(name: string, args: string, request: ICommandSkillActivationRequest): Promise<ICommandResult | null>;
+  executeUserResolvedSkillCommand(skill: ICommand, args: string, displayInput: string | undefined, rawInput: string | undefined, invocation: ISkillActivationEvent['invocation']): Promise<ISkillExecutionResult>;
+  executeSkillWithActivation(skill: ICommand, args: string, invocation: ISkillActivationEvent['invocation'], qualifiedName?: string): Promise<ISkillExecutionResult>;
+  private emitSkillActivation;
+  private executeForegroundCommand;
+}
+//#endregion
+//#region src/interactive/interactive-session-init.d.ts
+/** Return value of createInteractiveSession — session plus staleness tracking data. */
+interface ICreatedInteractiveSession {
+  session: Session;
+  /** Per-file entries for AGENTS.md files loaded at startup. Used for staleness detection. */
+  agentsFileEntries: IContextFileEntry[];
+  /** Per-file entries for CLAUDE.md files loaded at startup. Used for staleness detection. */
+  claudeFileEntries: IContextFileEntry[];
+  /** Rebuilds the system message given updated agentsMd and claudeMd strings. */
+  rebuildSystemMessage: (agentsMd: string, claudeMd: string) => string;
+}
+//#endregion
+//#region src/interactive/interactive-session-execution-controller.d.ts
+interface IExecutionControllerCallbacks {
+  getSession: () => Session;
+  getSessionOrThrow: () => Session;
+  getCwd: () => string;
+  getContextState: () => IContextWindowState;
+  getExecutionWorkspaceSnapshot: () => IExecutionWorkspaceSnapshot;
+  emit: <E extends string>(event: E, ...args: unknown[]) => void;
+  persistSession: () => void;
+}
+declare class SessionExecutionController {
+  private readonly histTracker;
+  private readonly skillRouter;
+  private readonly callbacks;
+  executing: boolean;
+  streamingText: string;
+  flushTimer: ReturnType<typeof setTimeout> | null;
+  activeTools: IToolState[];
+  pendingPrompt: string | null;
+  pendingDisplayInput: string | undefined;
+  pendingRawInput: string | undefined;
+  shuttingDown: boolean;
+  constructor(histTracker: SessionHistoryTracker, skillRouter: SessionSkillRouter, callbacks: IExecutionControllerCallbacks);
+  clearPendingQueue(): void;
+  clearStreaming(): void;
+  flushStreaming(): void;
+  handleTextDelta(delta: string): void;
+  handleCompactEvent(event: ICompactEvent): void;
+  handleToolExecution(event: {
+    type: 'start' | 'end';
+    toolName: string;
+    toolArgs?: TToolArgs;
+    success?: boolean;
+    denied?: boolean;
+    toolResultData?: string;
+  }): void;
+  emitExecutionWorkspaceUpdated(cause: TExecutionWorkspaceUpdateCause, entryId?: string): void;
+  private drainPendingQueue;
+  executePrompt(input: string, displayInput: string | undefined, rawInput: string | undefined, agentsFileEntries: IContextFileEntry[], claudeFileEntries: IContextFileEntry[], rebuildSystemMessage: ICreatedInteractiveSession['rebuildSystemMessage'] | null, setEntries: (agents: IContextFileEntry[], claude: IContextFileEntry[]) => void, submit: (p: string, d?: string, r?: string) => Promise<void>): Promise<void>;
+  executeForkSkillCommand(skill: ICommand, args: string, displayInput: string | undefined, qualifiedName: string | undefined, invocation: ISkillActivationEvent['invocation'], submit: (p: string, d?: string, r?: string) => Promise<void>): Promise<ISkillExecutionResult>;
+  executeForegroundCommand(execute: () => Promise<ICommandResult>, submit: (p: string, d?: string, r?: string) => Promise<void>): Promise<ICommandResult>;
+  applyForkSkillResult(result: string): Promise<void>;
+}
+//#endregion
+//#region src/tools/agent-tool.d.ts
+/** 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;
+/**
+ * Create an agent tool instance with deps captured in closure.
+ *
+ * Each session gets its own tool instance — no shared mutable state.
+ */
+declare function createAgentTool(deps: IAgentToolDeps): ReturnType<typeof createZodFunctionTool>;
+//#endregion
+//#region src/interactive/interactive-session-agent-jobs.d.ts
+interface ISpawnAgentJobInput {
+  agentType: string;
+  label: string;
+  mode: 'foreground' | 'background';
+  prompt: string;
+  model?: string;
+  isolation?: TBackgroundTaskIsolation;
+}
+//#endregion
+//#region src/interactive/interactive-session-base.d.ts
+declare abstract class InteractiveSessionBase {
+  protected abstract readonly bgTracker: SessionBackgroundTaskTracker;
+  protected abstract readonly histTracker: SessionHistoryTracker;
+  protected abstract readonly skillRouter: SessionSkillRouter;
+  protected abstract readonly execCtrl: SessionExecutionController;
+  protected abstract getSessionOrThrow(): Session;
+  protected abstract ensureInitialized(): Promise<void>;
+  protected abstract getCwd(): string;
+  isExecuting(): boolean;
+  getPendingPrompt(): string | null;
+  getStreamingText(): string;
+  getActiveTools(): IToolState[];
+  cancelQueue(): void;
+  executeCommand(name: string, args: string): Promise<ICommandResult | null>;
+  executeModelCommand(name: string, args: string): Promise<ICommandResult | null>;
+  getCommandInvocationSource(): TCommandInvocationSource;
+  executeSkillCommandByName(name: string, args: string, request: ICommandSkillActivationRequest): Promise<ICommandResult | null>;
+  listCommands(): Array<{
+    name: string;
+    displayName?: string;
+    description: string;
+  }>;
+  listSkills(): ICommandSkillListEntry[];
+  listModelInvocableCommands(): Array<{
+    name: string;
+    description: string;
+  }>;
+  getCommandHostAdapters(): ICommandHostAdapters;
+  getSkillActivationEvents(): ISkillActivationEvent[];
+  getContextState(): IContextWindowState;
+  compactContext(instructions?: string): Promise<void>;
+  getFullHistory(): IHistoryEntry[];
+  getMessages(): TUniversalMessage[];
+  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>;
+  getExecutionWorkspaceSnapshot(options?: IExecutionWorkspaceSnapshotOptions): IExecutionWorkspaceSnapshot;
+  listExecutionWorkspaceEntries(filter?: IExecutionWorkspaceFilter): IExecutionWorkspaceEntry[];
+  getExecutionWorkspaceEntry(entryId: string): IExecutionWorkspaceEntry | undefined;
+  readExecutionWorkspaceDetail(entryId: string, cursor?: IExecutionDetailCursor): Promise<IExecutionDetailPage>;
+  createExecutionWorkspaceTaskSpawner(origin: IExecutionOrigin): IExecutionWorkspaceTaskSpawner;
+  listAgentDefinitions(): Array<{
+    name: string;
+    description: string;
+  }>;
+  listAgentJobs(): ISubagentJobState[];
+  spawnAgentJob(input: ISpawnAgentJobInput): 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>;
+}
+//#endregion
+//#region src/interactive/interactive-session.d.ts
+interface IInteractiveSessionShutdownOptions {
+  reason?: TSessionEndReason;
+  message?: string;
+}
+declare class InteractiveSession extends InteractiveSessionBase implements ISession, IAgentJobHostContext, IInteractiveSession {
+  private session;
+  private readonly listeners;
+  private initialized;
+  private initPromise;
+  private sessionStore?;
+  private sessionName?;
+  private cwd?;
+  private pendingRestoreMessages;
+  private resumeSessionId?;
+  private forkSession;
+  private autoCompactThresholdSource;
+  private shutdownPromise;
+  private readonly sandboxClient?;
+  private sandboxSnapshotId?;
+  private agentsFileEntries;
+  private claudeFileEntries;
+  private rebuildSystemMessage;
+  protected readonly bgTracker: SessionBackgroundTaskTracker;
+  protected readonly histTracker: SessionHistoryTracker;
+  protected readonly skillRouter: SessionSkillRouter;
+  protected readonly execCtrl: SessionExecutionController;
+  constructor(options: TInteractiveSessionOptions);
+  private configureInjectedSession;
+  private restoreSessionRecordIfNeeded;
+  private startAsyncInitializationIfNeeded;
+  private initializeAsync;
+  protected ensureInitialized(): Promise<void>;
+  protected getSessionOrThrow(): Session;
+  getCwd(): string;
+  get sessionId(): string;
+  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>;
+  abort(): void;
+  shutdown(options?: IInteractiveSessionShutdownOptions): Promise<void>;
+  get isInitialized(): boolean;
+  getAutoCompactThresholdSource(): TAutoCompactThresholdSource;
+  getAutoCompactThreshold(): number | false;
+  getSession(): Session;
+  getAgentJobCapability(): IAgentJobHostContext;
+  setAutoCompactThreshold(threshold: TAutoCompactThreshold, source?: TAutoCompactThresholdSource): void;
+  clearConversationHistory(): void;
+  getName(): string | undefined;
+  attachTransport(transport: ITransportAdapter$1<IInteractiveSession>): void;
+  setName(name: string): void;
+  private getBackgroundTaskManager;
+  private captureSandboxSnapshot;
+  private persistCurrentSession;
+}
+//#endregion
+//#region src/query.d.ts
+interface ICreateQueryOptions {
+  /** AI provider instance (required). */
+  provider: IAIProvider;
+  /** Working directory. Defaults to process.cwd(). */
+  cwd?: string;
+  /** Permission mode. Defaults to 'bypassPermissions' for programmatic use. */
+  permissionMode?: TPermissionMode;
+  /** Maximum agentic turns per query. */
+  maxTurns?: number;
+  /** Permission handler callback. */
+  permissionHandler?: TInteractivePermissionHandler;
+  /** Streaming text callback. */
+  onTextDelta?: (delta: string) => void;
+}
+/**
+ * Create a prompt-only query function bound to a provider.
+ *
+ * ```typescript
+ * import { createQuery } from '@robota-sdk/agent-framework';
+ * 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 createQuery(options: ICreateQueryOptions): (prompt: string) => Promise<string>;
+//#endregion
+//#region src/user-local/storage.d.ts
+declare const USER_LOCAL_STORAGE_CATEGORIES: readonly ["preferences", "view-state", "memory-projections", "task-associations", "workflow-metadata", "inspection-index"];
+type TUserLocalStorageCategory = (typeof USER_LOCAL_STORAGE_CATEGORIES)[number];
+interface IUserLocalStorageCategoryDefinition {
+  readonly category: TUserLocalStorageCategory;
+  readonly purpose: string;
+  readonly mayExecuteCommands: false;
+}
+interface IUserLocalStorageItemSummary {
+  readonly root: string;
+  readonly category: TUserLocalStorageCategory;
+  readonly key: string;
+  readonly summary: string;
+  readonly source: string;
+  readonly scope: string;
+  readonly storageLocation: string;
+  readonly createdAt?: string;
+  readonly lastUsedAt?: string;
+  readonly enabled: boolean;
+  readonly deleteAvailable: boolean;
+  readonly disableAvailable: boolean;
+}
+interface IUserLocalStorageCategoryProjection {
+  readonly category: TUserLocalStorageCategory;
+  readonly purpose: string;
+  readonly mayExecuteCommands: false;
+  readonly storageLocation: string;
+  readonly itemCount: number;
+  readonly items: readonly IUserLocalStorageItemSummary[];
+}
+interface IUserLocalStorageInspection {
+  readonly root: string;
+  readonly activeRepositoryRoot: string;
+  readonly categories: readonly IUserLocalStorageCategoryProjection[];
+  readonly generatedAt: string;
+}
+interface IResolveUserLocalStorageRootOptions {
+  readonly activeRepositoryRoot: string;
+  readonly homeDir?: string;
+  readonly storageRoot?: string;
+  readonly fsAsync?: IFileSystemAsync;
+}
+interface IInspectUserLocalStorageOptions extends IResolveUserLocalStorageRootOptions {
+  readonly now?: () => Date;
+  readonly createDirectories?: boolean;
+}
+declare const USER_LOCAL_STORAGE_CATEGORY_DEFINITIONS: readonly IUserLocalStorageCategoryDefinition[];
+declare function resolveUserLocalStorageRoot(options: IResolveUserLocalStorageRootOptions): Promise<string>;
+declare function inspectUserLocalStorage(options: IInspectUserLocalStorageOptions): Promise<IUserLocalStorageInspection>;
+//#endregion
+//#region src/user-local/memory-types.d.ts
+declare const USER_LOCAL_MEMORY_CATEGORIES: readonly ["view-preference", "last-visible-cwd", "background-selection", "task-association", "display-preference", "inspection-choice"];
+type TUserLocalMemoryCategory = (typeof USER_LOCAL_MEMORY_CATEGORIES)[number];
+type TUserLocalMemoryCommandExecutionEffect = 'none';
+interface IUserLocalMemoryItemProjection {
+  readonly root: string;
+  readonly category: TUserLocalMemoryCategory;
+  readonly key: string;
+  readonly summary: string;
+  readonly valueSummary: string;
+  readonly source: string;
+  readonly scope: string;
+  readonly storageLocation: string;
+  readonly createdAt: string;
+  readonly lastUsedAt: string;
+  readonly enabled: boolean;
+  readonly displayNavigationRule: string;
+  readonly commandExecutionEffect: TUserLocalMemoryCommandExecutionEffect;
+  readonly deleteAvailable: true;
+  readonly disableAvailable: true;
+}
+interface IUserLocalMemoryListProjection {
+  readonly root: string;
+  readonly activeRepositoryRoot: string;
+  readonly items: readonly IUserLocalMemoryItemProjection[];
+}
+interface IUserLocalMemorySetOptions extends IResolveUserLocalStorageRootOptions {
+  readonly category: TUserLocalMemoryCategory;
+  readonly key: string;
+  readonly value: string;
+  readonly summary: string;
+  readonly source: string;
+  readonly scope?: string;
+  readonly now?: () => Date;
+}
+interface IUserLocalMemoryItemOptions extends IResolveUserLocalStorageRootOptions {
+  readonly category: TUserLocalMemoryCategory;
+  readonly key: string;
+  readonly now?: () => Date;
+}
+interface IUserLocalMemoryListOptions extends IResolveUserLocalStorageRootOptions {
+  readonly now?: () => Date;
+}
+interface IUserLocalMemoryDeleteResult {
+  readonly category: TUserLocalMemoryCategory;
+  readonly key: string;
+  readonly deleted: boolean;
+}
+//#endregion
+//#region src/user-local/memory.d.ts
+declare function setUserLocalMemoryItem(options: IUserLocalMemorySetOptions): Promise<IUserLocalMemoryItemProjection>;
+declare function listUserLocalMemoryItems(options: IUserLocalMemoryListOptions): Promise<IUserLocalMemoryListProjection>;
+declare function inspectUserLocalMemoryItem(options: IUserLocalMemoryItemOptions): Promise<IUserLocalMemoryItemProjection>;
+declare function disableUserLocalMemoryItem(options: IUserLocalMemoryItemOptions): Promise<IUserLocalMemoryItemProjection>;
+declare function deleteUserLocalMemoryItem(options: IUserLocalMemoryItemOptions): Promise<IUserLocalMemoryDeleteResult>;
+declare function readEnabledUserLocalMemoryItem(options: IUserLocalMemoryItemOptions): Promise<IUserLocalMemoryItemProjection | null>;
+//#endregion
+//#region src/self-hosting/self-hosting-verification.d.ts
+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;
+//#endregion
+//#region src/agents/built-in-agents.d.ts
+/**
+ * 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 getBuiltInAgent(name: string): IAgentDefinition | undefined;
+//#endregion
+//#region src/tools/command-execution-tool.d.ts
+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>;
+//#endregion
+//#region src/tools/model-command-tool-projection.d.ts
+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>>;
+//#endregion
+//#region src/tools/background-process-tool.d.ts
+interface IBackgroundProcessToolDeps {
+  backgroundTaskManager: IBackgroundTaskManager;
+  cwd?: string;
+  parentSessionId?: string;
+  metadata?: Record<string, TBackgroundPrimitive>;
+}
+declare function createBackgroundProcessTool(deps: IBackgroundProcessToolDeps): ReturnType<typeof createZodFunctionTool>;
+//#endregion
+//#region src/paths.d.ts
+/**
+ * Standard Robota storage paths.
+ *
+ * All CLI runtime data lives under .robota/ (project) or ~/.robota/ (user).
+ * .agents/ is read-only from CLI's perspective (owned by AGENTS.md standard).
+ */
+/** Project-level .robota/ paths (relative to cwd). */
+declare function projectPaths(cwd: string): {
+  settings: string;
+  settingsLocal: string;
+  logs: string;
+  sessions: string;
+  memory: string;
+  checkpoints: string;
+};
+/** User-level ~/.robota/ paths. */
+declare function userPaths(): {
+  settings: string;
+  sessions: string;
+};
+//#endregion
+//#region src/context/task-context.d.ts
+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;
+}
+interface IUpdateTaskFileStatusOptions {
+  now?: Date;
+  progressMessage?: string;
+}
+declare function readCurrentGitBranch(cwd: string, fs?: IFileSystem): string | undefined;
+declare function discoverTaskFiles(cwd: string, fs?: IFileSystem): string[];
+declare function parseTaskFile(taskPath: string, cwd: string, fs?: IFileSystem): ITaskContextFile;
+declare function selectRelevantTasks(tasks: readonly ITaskContextFile[], options?: ITaskSelectionOptions): ITaskContextFile[];
+declare function formatTaskContext(tasks: readonly ITaskContextFile[]): string;
+declare function loadTaskContext(cwd: string, options?: ITaskSelectionOptions, fs?: IFileSystem): string;
+declare function updateTaskFileStatus(taskPath: string, status: TTaskFileStatus, options?: IUpdateTaskFileStatusOptions, fs?: IFileSystem): void;
+//#endregion
+//#region src/permissions/permission-prompt.d.ts
+declare function promptForApproval(terminal: ITerminalOutput$2, toolName: string, toolArgs: TToolArgs): Promise<boolean>;
+//#endregion
+//#region src/testing/create-test-interactive-session.d.ts
+/** Creates a stub IInteractiveSession for use in tests. All methods return sensible defaults.
+ *  Pass overrides to spy on or replace specific methods. */
+declare function createTestInteractiveSession(overrides?: Partial<IInteractiveSession>): IInteractiveSession;
+//#endregion
+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, EXECUTION_ORIGIN_METADATA_KEYS, EXIT_COMMAND_DESCRIPTION, EditCheckpointStore, HELP_COMMAND_DESCRIPTION, type IActiveProviderModelCatalogState, type IAgentBackgroundTaskRequest, type IAgentDefinition, type IAgentExecutorOptions, type IAgentJobHostContext, type IAgentSession, type IAgentToolDeps, type IAppendMemoryInput, type IAppendMemoryResult, type IBackgroundJobGroupCreateRequest, type IBackgroundJobGroupState, type IBackgroundJobGroupSummary, type IBackgroundJobOrchestratorOptions, type IBackgroundJobResultEnvelope, type IBackgroundProcessToolDeps, type IBackgroundTaskError, type IBackgroundTaskHandle, type IBackgroundTaskInput, type IBackgroundTaskListFilter, type IBackgroundTaskLogCursor, type IBackgroundTaskLogPage, type IBackgroundTaskManager, type IBackgroundTaskManagerOptions, type IBackgroundTaskResult, type IBackgroundTaskRunner, type IBackgroundTaskSpawnerGroupRequest, type IBackgroundTaskStart, type IBackgroundTaskState, type IBaseBackgroundTaskRequest, 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 IConfigurableTransport, type IContextFileRefreshedEvent, type IContextReferenceAddResult, type IContextReferenceClearResult, type IContextReferenceInventoryLimits, type IContextReferenceItem, type IContextReferenceRemoveResult, type IContextReferenceUpsertResult, type ICreateExecutionWorkspaceSnapshotInput, type ICreateExecutionWorkspaceTaskSpawnerOptions, type ICreateLimitedOutputCaptureOptions, type ICreateLineDetailPageInput, type ICreateMainThreadDetailPageInput, type ICreateMainThreadEntryInput, type ICreateQueryOptions, type IDiffLine, type IEditCheckpointFileInspection, type IEditCheckpointFileRecord, type IEditCheckpointInspection, type IEditCheckpointInspectionPlan, type IEditCheckpointManifest, type IEditCheckpointRecorder, type IEditCheckpointRestoreResult, type IEditCheckpointSummary, type IEditCheckpointTurnInput, type IExecutionDetailCursor, type IExecutionDetailPage, type IExecutionDetailRecord, type IExecutionOrigin, type IExecutionResult, type IExecutionWorkspaceEntry, type IExecutionWorkspaceEntryRef, type IExecutionWorkspaceEvent, type IExecutionWorkspaceFilter, type IExecutionWorkspaceSnapshot, type IExecutionWorkspaceSnapshotOptions, type IExecutionWorkspaceTaskSpawner, type IForkExecutionOptions, type IInProcessSubagentRunnerDeps, type IInspectUserLocalStorageOptions, type IInstalledPluginRecord, type IInteractiveSession, type IInteractiveSessionEvents, type IInteractiveSessionRecord, type IInteractiveSessionShutdownOptions, type IInteractiveSessionStore, type IKnownMarketplaceEntry, type ILegacyProviderSettings, type ILimitedOutputCapture, type ILoadedBundlePlugin, type IMarketplaceClientOptions, type IMarketplaceManifest, type IMarketplacePluginEntry, type IMemoryCandidate, type IMemoryEvent, type IMemoryPendingRecord, type IMemoryReference, type IModelCommandModuleOptions, type IModelCommandSettingsAdapter, type IModelCommandToolProjection, type IPermissionsCommandState, type IPluginSettings, type IPreparedSubagentWorktree, type IProcessBackgroundTaskRequest, 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 IProviderDefinition, type IProviderProfileNameSuggestionInput, type IProviderProfileNameSuggestionOptions, type IProviderProfileSettings, type IProviderSettingsBuildOptions, type IProviderSetupInput, type IProviderSetupPatch, type IResolveActiveProviderModelCatalogStateOptions, type IResolveUserLocalStorageRootOptions, type IResolvedPromptFileReference, type IResolvedPromptFileReferences, type IResumableSessionSummary, type IReversibleExecutionOptions, type IReversibleToolSafetyContext, type IReversibleToolSafetyInput, type IReversibleToolSafetyReport, type ISelfHostingVerificationPlan, type ISelfHostingVerificationPlanInput, type ISelfHostingVerificationStep, type ISerializableProviderProfile, type ISkillActivationEvent, type ISkillActivationHistoryData, type ISkillExecutionCallbacks, type ISkillExecutionResult, type ISpawnAgentTaskRequest, type ISpawnProcessTaskRequest, type IStartupMemory, type IStatusLineCommandSettings, type ISubagentJobHandle, type ISubagentJobResult, type ISubagentJobStart, type ISubagentJobState, type ISubagentManager, type ISubagentManagerOptions, type ISubagentOptions, type ISubagentPromptOptions, type ISubagentRunner, type ISubagentSpawnRequest, type ISubagentWorktreeAdapter, type ISubagentWorktreePrepareRequest, type ISystemCommand, type ITaskContextFile, type ITaskSelectionOptions, type IToolState, type IToolSummary, type ITransportAdapter, type ITransportConfig, type IUpdateTaskFileStatusOptions, type IUsageSnapshot, type IUserLocalMemoryDeleteResult, type IUserLocalMemoryItemOptions, type IUserLocalMemoryItemProjection, type IUserLocalMemoryListOptions, type IUserLocalMemoryListProjection, type IUserLocalMemorySetOptions, type IUserLocalStorageCategoryDefinition, type IUserLocalStorageCategoryProjection, type IUserLocalStorageInspection, type IUserLocalStorageItemSummary, type IWorktreeSubagentRunnerOptions, 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, type TAutoCompactThresholdSource, type TBackgroundJobGroupEvent, type TBackgroundJobGroupEventListener, type TBackgroundJobGroupIdFactory, type TBackgroundJobGroupStatus, type TBackgroundJobWaitPolicy, type TBackgroundPermissionPolicy, type TBackgroundPrimitive, type TBackgroundTaskErrorCategory, type TBackgroundTaskEvent, type TBackgroundTaskEventListener, type TBackgroundTaskIdFactory, type TBackgroundTaskIsolation, type TBackgroundTaskKind, type TBackgroundTaskMode, type TBackgroundTaskRequest, type TBackgroundTaskRunnerEvent, type TBackgroundTaskStatus, type TBackgroundTaskTimeoutReason, type TBackgroundTaskTransitionEvent, type TCapabilityKind, type TCapabilitySafety, type TCommandEffect, type TCommandInteractionPrompt, type TCommandModuleSessionRequirement, type TCommandResultDataValue, type TContextReferenceLoadType, type TContextReferenceStatus, type TEditCheckpointFileRestoreAction, type TEnabledPlugins, type TExecutionAttention, type TExecutionControl, type TExecutionDetailRecordKind, type TExecutionEntryKind, type TExecutionOriginKind, type TExecutionWorkspaceStatus, type TExecutionWorkspaceUpdateCause, type TExecutionWorkspaceVisibility, type TInstalledPluginsRegistry, type TInteractiveEventName, type TInteractivePermissionHandler, type TInteractiveSessionOptions, type TKnownMarketplacesRegistry, type TMarketplaceSource, type TMemoryCandidateStatus, type TMemoryType, type TPermissionResultValue, type TPluginInstallScope, type TPromptFileReferenceDiagnosticCode, type TPromptFileReferenceReason, type TProviderFactory, type TProviderSettingsDocument, type TRecommendedResponseLanguage, type TReversibleExecutionIsolation, type TReversibleRollbackLayer, type TReversibleSafetyStatus, type TReversibleSideEffect, type TSelfHostingLoopEvent, type TSelfHostingLoopState, type TSelfHostingVerificationPhase, type TSessionFactory, type TSettingsCheck, type TShellExecFn, type TSkillActivationInvocation, type TSkillActivationMode, type TSkillActivationSource, type TSkillActivationStatus, type TStatusLineCommandSettingsPatch, type TSubagentJobMode, type TSubagentJobStatus, type TSubagentRunnerFactory, type TSystemCommandLifecycle, type TTaskFileStatus, type TUserLocalMemoryCategory, type TUserLocalMemoryCommandExecutionEffect, type TUserLocalStorageCategory, USER_LOCAL_MEMORY_CATEGORIES, USER_LOCAL_STORAGE_CATEGORIES, USER_LOCAL_STORAGE_CATEGORY_DEFINITIONS, VALIDATE_SESSION_COMMAND_DESCRIPTION, VALID_PERMISSION_MODES, addCommandContextReference, assembleSubagentPrompt, buildBackgroundCommandSubcommands, buildLanguageCommandSubcommands, buildMemoryCommandSubcommands, buildModelCommandSubcommands, buildPermissionModeSubcommands, buildPluginCommandSubcommands, buildPromptWithFileReferences, buildProviderProfile, buildProviderSetupPatch, buildRewindCommandSubcommands, buildStatusLineCommandSubcommands, cancelCommandBackgroundTask, checkSettingsDocument, clearCommandContextReferences, clearContextReferences, clearConversationHistory, closeCommandBackgroundTask, compactCommandContext, createAgentTool, createBackgroundGroupExecutionEntryId, createBackgroundProcessTool, createBackgroundTaskExecutionEntryId, createBuiltinCommandModule, createCommandExecutionTool, createCommandMemoryStores, createCommandPendingMemoryStore, createCommandProjectMemoryStore, createContextReferenceItem, createDefaultTools, createExecutionOriginMetadata, createExecutionWorkspaceSnapshot, createExecutionWorkspaceTaskSpawner, createInProcessSubagentRunner, createLineDetailPage, createMainThreadDetailPage, createMainThreadExecutionEntryId, createModelCommandToolProjection, createPluginRegistryReloadRequestedEffect, createPluginTuiRequestedEffect, createProjectSessionStore, createProjectedCommandExecutionTools, createPromptFileReferenceHistoryEntry, createProviderSafeModelCommandToolName, createQuery, createSessionExitRequestedEffect, createSessionPickerRequestedEffect, createSessionRenamedEffect, createSubagentLogger, createSubagentSession, createSystemCommands, createTestInteractiveSession, deleteProviderProfile, deleteUserLocalMemoryItem, disableUserLocalMemoryItem, discoverTaskFiles, evaluateReversibleToolSafety, executeSkill, findProviderDefinition, formatCommandBackgroundTask, formatCommandBackgroundTaskList, formatCommandHelpMessage, formatCommandPermissionsMessage, formatCommandSessionReplayValidationReport, formatEnvReference, formatInvalidPermissionModeMessage, formatLanguageUsageMessage, formatModelCommandUsageMessage, formatModelCommandUsageMessageAsync, formatProjectedModelCommandToolPromptDescription, formatPromptFileReferenceDiagnostics, formatTaskContext, getBuiltInAgent, getForkWorkerSuffix, getProviderCredentialRequirement, getSubagentSuffix, hasBlockingPromptFileReferenceDiagnostics, hasSensitiveCommandMemoryContent, hasUsableSecretReference, inspectCommandEditCheckpoint, inspectUserLocalMemoryItem, inspectUserLocalStorage, isCommandMemoryType, isEnvReference, isMemoryType, isPermissionMode, isStatusLineCommandSettingsPatch, listActiveContextReferences, listCommandBackgroundTasks, listCommandContextReferences, listCommandEditCheckpoints, listCommandSessionAllowedTools, listCommandUsedMemoryReferences, listResumableSessionSummaries, listUserLocalMemoryItems, loadTaskContext, mergeProviderPatch, mergeProviders, mergeSettings, normalizeModelCommandName, parseCommandBackgroundLogCursor, parseExecutionWorkspaceEntryId, parseFrontmatter, parseLanguageArgument, parsePermissionModeArgument, parsePromptFileReferences, parseSessionNameArgument, parseTaskFile, planSelfHostingVerification, preprocessShellCommands, probeProviderProfile, projectPaths, promptForApproval, readAutoCompactThreshold, readAutoCompactThresholdSource, readCommandBackgroundTaskLog, readCommandContextState, readCommandPermissionMode, readCommandPermissionsState, readCommandSessionInfo, readCurrentGitBranch, readEnabledUserLocalMemoryItem, readMergedProviderSettingsFromPaths, recordCommandMemoryEvent, removeCommandContextReference, removeContextReference, resetAutoCompactThresholdSetting, resolveActiveProvider, resolveActiveProviderModelCatalog, resolveActiveProviderModelCatalogState, resolveEnvReference, resolveLatestSessionId, resolvePermissionModeAdapter, resolvePluginCommandAdapter, resolvePromptFileReferencePaths, resolvePromptFileReferences, resolveSessionIdByIdOrName, resolveSubagentLogDir, resolveUserLocalStorageRoot, restoreCommandEditCheckpoint, retrieveAgentToolDeps, rollbackCommandEditCheckpoint, sanitizeProviderProfileName, selectRelevantTasks, setCommandAutoCompactThreshold, setCurrentProvider, setUserLocalMemoryItem, storeAgentToolDeps, substituteVariables, suggestProviderProfileName, summarizeBackgroundJobGroup, testProviderProfileCommand, toContextReferenceRecords, toPromptFileReferenceRecords, transitionSelfHostingLoop, updateTaskFileStatus, upsertContextReference, upsertProviderProfile, userPaths, validateCommandSessionReplayLog, validateProviderProfile, wrapEditCheckpointTools, wrapReversibleExecutionTools, writeAutoCompactThresholdSetting, writeCommandPermissionMode };
+//# sourceMappingURL=index.d.ts.map