@robota-sdk/agent-framework 3.0.0-beta.75 → 3.0.0-beta.77

package/dist/node/index-BeYNnJed.d.ts

@@ -0,0 +1,2656 @@
+import { IBackgroundJobGroupCreateRequest, IBackgroundJobGroupCreateRequest as IBackgroundJobGroupCreateRequest$1, IBackgroundJobGroupState, IBackgroundJobGroupState as IBackgroundJobGroupState$1, IBackgroundJobGroupSummary, IBackgroundTaskInput, IBackgroundTaskListFilter, IBackgroundTaskLogCursor, IBackgroundTaskLogPage, IBackgroundTaskState, ICapabilityDescriptor, ICommand, ICommandListEntry, ICommandPluginAdapter, ICommandPluginAdapter as ICommandPluginAdapter$1, ICommandResult as ICommandResult$1, ICommandSource, ICompactEvent, IContextReferenceItem, ICreateExecutionWorkspaceSnapshotInput, ICreateLineDetailPageInput, ICreateMainThreadDetailPageInput, IExecutionDetailCursor, IExecutionDetailPage, IExecutionOrigin, IExecutionOrigin as IExecutionOrigin$1, IExecutionResult, IExecutionWorkspaceEntry, IExecutionWorkspaceEntryRef, IExecutionWorkspaceFilter, IExecutionWorkspaceSnapshot, IExecutionWorkspaceSnapshotOptions, IGoalState, IInteractiveSession, IInteractiveSessionEvents as IInteractiveSessionEvents$1, IInteractiveSessionStore, IMemoryEvent, IMemoryReference, IPromptFileReferenceRecord, IResumableSessionSummary, ISkillActivationEvent, IStatusLineCommandSettings, ISubagentJobState, ITerminalHandoff, IToolState, IToolSummary, ITransportAdapter, TBackgroundJobGroupEvent, TBackgroundJobGroupEventListener, TBackgroundJobGroupIdFactory, TBackgroundPermissionPolicy, TBackgroundPrimitive, TBackgroundTaskEvent, TBackgroundTaskIsolation, TBackgroundTaskMode, TCapabilitySafety, TCommandEffect, TContextReferenceLoadType, TContextReferenceStatus, TExecutionWorkspaceUpdateCause, TGoalStopReason, TInteractiveEventName as TInteractiveEventName$1, TInteractivePermissionHandler, TMemoryType, TPermissionResultValue, TPromptFileReferenceReason, TStatusLineCommandSettingsPatch, TTurnSource } from "@robota-sdk/agent-interface-transport";
+import { IAIProvider, IContextWindowState, IFileSystem, IFileSystemAsync, IHistoryEntry, IHookInput, IHookResult, IHookTypeExecutor, IProviderDefinition, IProviderDefinitionConfig, IProviderProbeResult, IProviderProfileConfig, ISession, ITerminalOutput, IToolWithEventService, IUserInteraction, THookDefinition, THooksConfig, TModelEffort, TPermissionMode, TSessionEndReason, TToolArgs, TUniversalMessage, TUniversalValue, formatEnvReference, hasUsableSecretReference, isEnvReference, resolveEnvReference } from "@robota-sdk/agent-core";
+import { IBackgroundTaskHandle, IBackgroundTaskManager, IBackgroundTaskManager as IBackgroundTaskManager$1, IBackgroundTaskManagerOptions, IBackgroundTaskRunner as IBackgroundTaskRunner$1, IBackgroundTaskStart, ICreateLimitedOutputCaptureOptions, ILimitedOutputCapture, IPreparedSubagentWorktree, ISubagentJobHandle, ISubagentJobResult, ISubagentJobStart, ISubagentManager, ISubagentManagerOptions, ISubagentRunner, ISubagentRunner as ISubagentRunner$1, ISubagentSpawnRequest, ISubagentWorktreeAdapter, ISubagentWorktreePrepareRequest, IWorktreeSubagentRunnerOptions, TBackgroundTaskIdFactory, TBackgroundTaskRunnerEvent, TBackgroundTaskTransitionEvent } from "@robota-sdk/agent-executor";
+import { FileSessionLogger, ISessionLogger, ISessionReplayValidationResult, ITerminalOutput as ITerminalOutput$1, Session, TPermissionHandler, TPermissionResult } from "@robota-sdk/agent-session";
+import { ISandboxClient, IWorkspaceManifest, createZodFunctionTool } from "@robota-sdk/agent-tools";
+//#region src/command-api/org-policy/org-policy-types.d.ts
+interface IOrgPolicy {
+  /** Allowed provider profile names. Undefined = all allowed. */
+  allowedProviders?: string[];
+  /** Slash command names blocked by policy (without leading slash). */
+  blockedCommands?: string[];
+  /** If true, API keys must be stored as env references ($ENV:VAR), not plaintext. */
+  requireApiKeyFromEnv?: boolean;
+  /** Shown in policy violation messages so users know who to contact. */
+  adminContact?: string;
+}
+//#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";
+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$1;
+}
+//#endregion
+//#region src/background-tasks/background-job-orchestrator.d.ts
+interface IBackgroundJobOrchestratorOptions {
+  manager: IBackgroundTaskManager;
+  now?: () => string;
+  idFactory?: TBackgroundJobGroupIdFactory;
+  initialGroups?: readonly IBackgroundJobGroupState[];
+}
+declare class BackgroundJobOrchestrator {
+  private readonly manager;
+  private readonly now;
+  private readonly idFactory;
+  private readonly unsubscribeManager;
+  private readonly listeners;
+  private readonly groups;
+  private sequence;
+  constructor(options: IBackgroundJobOrchestratorOptions);
+  createGroup(request: IBackgroundJobGroupCreateRequest): IBackgroundJobGroupState;
+  listGroups(): IBackgroundJobGroupState[];
+  getGroup(groupId: string): IBackgroundJobGroupState | undefined;
+  waitGroup(groupId: string): Promise<IBackgroundJobGroupState>;
+  subscribe(listener: TBackgroundJobGroupEventListener): () => void;
+  dispose(): void;
+  private nextGroupId;
+  private restoreGroup;
+  private createRecord;
+  private captureExistingTerminalTasks;
+  private handleTaskEvent;
+  private captureTask;
+  private evaluateCompletion;
+  private emit;
+}
+declare function summarizeBackgroundJobGroup(group: IBackgroundJobGroupState): IBackgroundJobGroupSummary;
+//#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";
+};
+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>;
+//#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;
+  readonly parentTaskId?: string;
+  readonly depth?: number;
+  readonly cwd?: string;
+  readonly model?: string;
+  readonly isolation?: TBackgroundTaskIsolation;
+  readonly allowedTools?: readonly string[];
+  readonly disallowedTools?: readonly string[];
+  readonly permissionPolicy?: TBackgroundPermissionPolicy;
+  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;
+  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$1['waitPolicy'];
+  readonly taskIds: readonly string[];
+  readonly label?: string;
+}
+interface IExecutionWorkspaceTaskSpawner {
+  spawnAgent(request: ISpawnAgentTaskRequest): Promise<IBackgroundTaskState>;
+  spawnProcess(request: ISpawnProcessTaskRequest): Promise<IBackgroundTaskState>;
+  createGroup(request: IBackgroundTaskSpawnerGroupRequest): IBackgroundJobGroupState$1;
+}
+interface ICreateExecutionWorkspaceTaskSpawnerOptions {
+  readonly manager: IBackgroundTaskManager;
+  readonly groupOrchestrator: BackgroundJobOrchestrator;
+  readonly sessionId: string;
+  readonly cwd: string;
+  readonly origin: IExecutionOrigin$1;
+}
+declare function createExecutionWorkspaceTaskSpawner(options: ICreateExecutionWorkspaceTaskSpawnerOptions): IExecutionWorkspaceTaskSpawner;
+//#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/context/prompt-file-reference-types.d.ts
+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 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
+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/goal/goal-controller.d.ts
+declare const DEFAULT_GOAL_MAX_ITERATIONS = 25;
+declare const DEFAULT_GOAL_NO_PROGRESS_LIMIT = 2;
+/** Parsed structured completion signal emitted by the agent via the goal-status tool. */
+interface IGoalSignal {
+  status: 'continue' | 'satisfied';
+  reason: string;
+}
+/** The controller's decision after a goal-driven turn completes. */
+type TGoalDecision = {
+  action: 'continue';
+  prompt: string;
+  goal: IGoalState;
+} | {
+  action: 'stop';
+  reason: TGoalStopReason;
+  goal: IGoalState;
+};
+/** Options for {@link GoalController.start}. */
+interface IGoalStartOptions {
+  maxIterations?: number;
+  noProgressLimit?: number;
+}
+/** Injected seams so the controller stays deterministic and testable. */
+interface IGoalControllerDeps {
+  now: () => string;
+  createId: () => string;
+}
+/**
+ * Read the structured completion signal from a finished turn's tool summaries. Returns the LAST
+ * `report_goal_status` call's validated payload, or `null` when the agent did not signal. The
+ * payload is schema-validated at the tool layer, so this is deterministic — never prose parsing.
+ */
+declare function extractGoalSignal(toolSummaries: readonly IToolSummary[]): IGoalSignal | null;
+declare class GoalController {
+  private readonly deps;
+  private goal;
+  private consecutiveIdleTurns;
+  private noProgressLimit;
+  constructor(deps?: IGoalControllerDeps);
+  getState(): IGoalState | null;
+  isActive(): boolean;
+  /**
+   * Begin pursuing a new goal. Throws on an empty objective. Returns the seeded state and the
+   * first-turn prompt the caller should submit.
+   */
+  start(objective: string, options?: IGoalStartOptions): {
+    goal: IGoalState;
+    prompt: string;
+  };
+  /** Restore a persisted goal on resume. Only an `active` goal resumes pursuit. */
+  restore(goal: IGoalState, noProgressLimit?: number): void;
+  /** User-requested cancellation. Returns the stopped state, or `null` when no goal is active. */
+  cancel(): IGoalState | null;
+  /**
+   * Advance the goal after a goal-driven turn completes. Returns the next decision, or `null`
+   * when no goal is active (the caller should ignore non-goal turns).
+   */
+  onTurnComplete(result: IExecutionResult): TGoalDecision | null;
+  private stop;
+}
+//#endregion
+//#region src/goal/goal-status-tool.d.ts
+/** Tool name the agent calls to report goal status. Vendor-neutral, generic. */
+declare const GOAL_SIGNAL_TOOL_NAME = "report_goal_status";
+/**
+ * Create the goal completion-signal tool. Included in the session tool set only when goal
+ * pursuit is enabled (interactive sessions). The agent must call it only while pursuing an
+ * assigned goal; outside a goal it is a harmless no-op acknowledgement.
+ */
+declare function createGoalStatusTool(): IToolWithEventService;
+//#endregion
+//#region src/goal/goal-prompts.d.ts
+/** The prompt that kicks off goal pursuit (first iteration). */
+declare function buildGoalStartPrompt(objective: string): string;
+/** The continuation prompt for each subsequent goal-driven turn. */
+declare function buildGoalContinuationPrompt(goal: IGoalState): string;
+//#endregion
+//#region src/memory/project-memory-store.d.ts
+declare const MEMORY_INDEX_MAX_LINES = 200;
+declare const MEMORY_INDEX_MAX_BYTES: number;
+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;
+}
+//#endregion
+//#region src/command-api/context/context-command-api.d.ts
+type TAutoCompactThreshold$1 = number | false;
+declare const DEFAULT_AUTO_COMPACT_THRESHOLD = 0.835;
+declare const AUTO_COMPACT_THRESHOLD_SETTINGS_KEY = "autoCompactThreshold";
+interface ICompactContextResult {
+  before: IContextWindowState;
+  after: IContextWindowState;
+  beforeMessageCount: number;
+  afterMessageCount: number;
+}
+/** Read context-window state through the command host facade. */
+declare function readCommandContextState(context: ICommandHostContext): IContextWindowState;
+/** Read the effective automatic compact policy through the command host facade. */
+declare function readAutoCompactThreshold(context: ICommandHostContext): TAutoCompactThreshold$1;
+/** Read the source of the effective automatic compact policy. */
+declare function readAutoCompactThresholdSource(context: ICommandHostContext): TAutoCompactThresholdSource;
+/** Update the active session's automatic compact policy through the command host facade. */
+declare function setCommandAutoCompactThreshold(context: ICommandHostContext, threshold: TAutoCompactThreshold$1, source: TAutoCompactThresholdSource): void;
+/** Persist an automatic compact policy value through the host settings adapter, when present. */
+declare function writeAutoCompactThresholdSetting(context: ICommandHostContext, threshold: TAutoCompactThreshold$1): boolean;
+/** Remove the persisted automatic compact policy through the host settings adapter, when present. */
+declare function resetAutoCompactThresholdSetting(context: ICommandHostContext): boolean;
+/** Run manual compaction through the command host facade and return before/after state. */
+declare function compactCommandContext(context: ICommandHostContext, instructions?: string): Promise<ICompactContextResult>;
+/** List context reference inventory entries through the command host facade. */
+declare function listCommandContextReferences(context: ICommandHostContext): IContextReferenceItem[];
+/** Add a manual context reference through the command host facade. */
+declare function addCommandContextReference(context: ICommandHostContext, path: string): Promise<IContextReferenceAddResult>;
+/** Remove a context reference through the command host facade. */
+declare function removeCommandContextReference(context: ICommandHostContext, path: string): IContextReferenceRemoveResult;
+/** Clear all context references through the command host facade. */
+declare function clearCommandContextReferences(context: ICommandHostContext): IContextReferenceClearResult;
+//#endregion
+//#region src/command-api/host-context.d.ts
+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';
+/**
+ * Live model re-application options (PRESET-013). Carries the model group a preset switch may
+ * re-apply to a running session; `maxOutputTokens` maps to the agent's `maxTokens` channel.
+ */
+interface IModelReapplyOptions {
+  model?: string;
+  effort?: TModelEffort;
+  temperature?: number;
+  maxOutputTokens?: number;
+}
+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;
+  getFullHistory(): IHistoryEntry[];
+  getHistory(): TUniversalMessage[];
+  setAutoCompactThreshold?(threshold: TAutoCompactThreshold$1): void;
+  getSessionTokenUsage?(): {
+    inputTokens: number;
+    outputTokens: number;
+  } | undefined;
+  getModelId?(): string | undefined;
+  /**
+   * Re-apply model/effort/temperature/maxOutputTokens to the live session (PRESET-013).
+   * May be async: the runtime ensures the agent is fully initialized before mutating its model
+   * configuration, so callers must await the result.
+   */
+  applyModelOptions?(options: IModelReapplyOptions): void | Promise<void>;
+  /** Read the active preset id (PRESET-011 runtime state). */
+  getActivePresetId?(): string;
+  /** Set the active preset id (PRESET-011 runtime state — pure state, no option re-application). */
+  setActivePresetId?(id: string): void;
+  /** Toggle subagent dispatch live for the running session (PRESET-016 runtime gate). */
+  setParallelSubagentsEnabled?(enabled: boolean): void;
+}
+interface ICommandSessionReplayValidationReport {
+  logFile: string;
+  entryCount: number;
+  validation: ISessionReplayValidationResult;
+}
+interface ICommandHostContext {
+  clearConversationHistory?(): void;
+  validateCurrentSessionReplayLog?(): ICommandSessionReplayValidationReport;
+  getAgentJobCapability?(): IAgentJobHostContext | undefined;
+  /**
+   * CMD-004: the injected "ask the user" port, or undefined when no interactive renderer is attached.
+   * A command solicits a structured answer via `getUserInteraction()?.ask(request)`; absence means no
+   * human is available (headless/automation, or a model-invoked command) — the command must handle it
+   * as a cancellation, never a silent guess.
+   */
+  getUserInteraction?(): IUserInteraction | undefined;
+  getSession(): ICommandSessionRuntime;
+  /** PRESET-014 — re-apply a preset persona to the live system prompt. */
+  applyPersona?(persona: string): void;
+  /** PRESET-017 — toggle the verify-before-done self-verification section on the live prompt. */
+  applySelfVerification?(enabled: boolean): void;
+  /** PRESET-015 — re-apply command-module selection to the live session. */
+  applyCommandModuleSelection?(enabled: readonly string[] | undefined, disabled: readonly string[] | undefined): void;
+  getContextState(): IContextWindowState;
+  getAutoCompactThreshold(): TAutoCompactThreshold$1;
+  getAutoCompactThresholdSource?(): TAutoCompactThresholdSource;
+  setAutoCompactThreshold?(threshold: TAutoCompactThreshold$1, source?: TAutoCompactThresholdSource): void;
+  getCommandHostAdapters?(): ICommandHostAdapters;
+  compactContext(instructions?: string): Promise<void>;
+  listContextReferences?(): IContextReferenceItem[];
+  addContextReference?(path: string): Promise<IContextReferenceAddResult>;
+  removeContextReference?(path: string): IContextReferenceRemoveResult;
+  clearContextReferences?(): IContextReferenceClearResult;
+  getCwd(): string;
+  getCommandInvocationSource?(): TCommandInvocationSource;
+  listCommands?(): ICommandListEntry[];
+  listSkills?(): ICommandSkillListEntry[];
+  executeSkillCommandByName?(name: string, args: string, request: ICommandSkillActivationRequest): Promise<ICommandResult$1 | 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>;
+  /** GOAL-001 — assign and begin pursuing an autonomous goal. */
+  setGoal?(objective: string, options?: IGoalStartOptions): Promise<IGoalState>;
+  /** GOAL-001 — the current goal state, or null when no goal has been set. */
+  getGoalState?(): IGoalState | null;
+  /** GOAL-001 — cancel an in-flight goal; returns the stopped state or null. */
+  cancelGoal?(): IGoalState | null;
+  /**
+   * TERM-001 — whether the active transport can hand the real terminal to a child process. `false`
+   * (or `runWithTerminal` absent) when there is no interactive TTY (e.g. headless).
+   */
+  canHandoffTerminal?(): boolean;
+  /**
+   * TERM-001 — suspend the display, run `fn` (which spawns a child with inherited stdio), then
+   * restore the display. Exclusive (one handoff at a time) and abort-safe; rejects without running
+   * `fn` when a handoff is not possible. The framework owns this orchestration; the transport
+   * implements the underlying suspend/resume.
+   */
+  runWithTerminal?<T>(fn: () => Promise<T>): Promise<T>;
+}
+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$1, 'parentSessionId'>): IBackgroundJobGroupState$1;
+  waitBackgroundJobGroup(groupId: string): Promise<IBackgroundJobGroupState$1>;
+  /**
+   * FLOW-005: schedule a recurring/one-shot agent wake. On each cron fire the agent loop
+   * re-enters with `agentInstruction` (FLOW-001/002). `cronExpression` may be a standard cron
+   * string or an ISO timestamp (one-shot).
+   */
+  spawnScheduledWake(input: {
+    label: string;
+    cronExpression: string;
+    agentInstruction: string;
+  }): Promise<IBackgroundTaskState>;
+  /**
+   * FLOW-005: monitor a process's output and wake the agent with `agentInstruction` when a
+   * line matches `matchPattern` (FLOW-004).
+   */
+  spawnMonitorWake(input: {
+    label: string;
+    command: string;
+    matchPattern: string;
+    agentInstruction: string;
+  }): Promise<IBackgroundTaskState>;
+  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;
+  /** Optional usage example shown in /help output (e.g., "/compact Summarize the context"). */
+  example?: 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$1> | ICommandResult$1;
+}
+//#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[];
+  /** Environment map for configure-time checks (test seam, default: process.env). */
+  env?: Record<string, string | undefined>;
+}
+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[];
+  settings: IProviderCommandSettingsAdapter;
+  orgPolicy?: IOrgPolicy;
+}
+//#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$1>;
+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[]): TSettingsCheck;
+declare function checkSettingsFile(filePath: string, providerDefinitions?: readonly IProviderDefinition[]): TSettingsCheck;
+//#endregion
+//#region src/command-api/provider/provider-configuration.d.ts
+interface IProviderSwitchOptions {
+  knownProviders?: Record<string, IProviderProfileSettings>;
+}
+interface IActiveModelChangeOptions {
+  settingsPaths?: readonly string[];
+  providerOverride?: string | undefined;
+}
+interface IProviderSettingsWriteTargetOptions {
+  settingsPaths?: readonly string[];
+}
+interface IActiveModelChangeResult {
+  settingsPath: string;
+  settings: TProviderSettingsDocument;
+  profileName?: string;
+}
+declare function resolveProviderSettingsWriteTargetPath(cwd: string, options?: IProviderSettingsWriteTargetOptions): string;
+declare function applyProviderConfiguration(settingsPath: string, input: IProviderSetupInput, options?: IProviderSettingsBuildOptions): TProviderSettingsDocument;
+declare function applyProviderSwitch(settingsPath: string, profileName: string, options?: IProviderSwitchOptions): TProviderSettingsDocument;
+declare function applyActiveModelChange(cwd: string, modelId: string, options?: IActiveModelChangeOptions): IActiveModelChangeResult;
+//#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[]): IProviderDefinitionConfig | undefined;
+//#endregion
+//#region src/command-api/provider/provider-factory.d.ts
+interface IReadProviderSettingsOptions {
+  providerOverride?: string;
+  providerDefinitions?: readonly IProviderDefinition[];
+  /** Environment map for env-default synthesis (test seam, default: process.env). */
+  env?: Record<string, string | undefined>;
+}
+/**
+ * Missing or unusable provider configuration at session start.
+ * Typed so callers can map it to a distinct exit code without message matching.
+ */
+declare class ProviderConfigError extends Error {
+  constructor(message: string);
+}
+declare function readMergedProviderSettings(cwd: string): TProviderSettingsDocument;
+/**
+ * Zero-config fallback: synthesize an in-memory provider config from the first
+ * definition (in order) whose defaults are complete — `$ENV:` apiKey reference with the
+ * referenced variable set, plus a default model. Settings profiles always win; nothing
+ * is persisted. Returns undefined when no definition qualifies.
+ */
+declare function resolveEnvDefaultProvider(providerDefinitions: readonly IProviderDefinition[], env?: Record<string, string | undefined>): IProviderDefinitionConfig | undefined;
+declare function readProviderSettings(cwd: string, options?: IReadProviderSettingsOptions): IProviderDefinitionConfig;
+declare function createProviderFromSettings(cwd: string, modelOverride?: string, options?: IReadProviderSettingsOptions): IAIProvider;
+//#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/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/preset/preset-application.d.ts
+/**
+ * Resolved-preset option subset that can be re-applied to a *live* session.
+ *
+ * This is a framework-owned shape. The agent-preset package's `IResolvedPresetOptions` satisfies it
+ * structurally, so a consumer can hand a `resolvePreset(...)` result straight to
+ * {@link applyPresetToSession} without framework importing agent-preset (no dependency cycle).
+ *
+ * PRESET-012 carries the permission/trust group (`permissionMode`); PRESET-013 adds the model group
+ * (`model`, `effort`, `temperature`, `maxOutputTokens`); PRESET-014 adds the `persona` block,
+ * re-applied to the live system prompt; PRESET-015 adds the command-module selection group
+ * (`enabledCommandModules`/`disabledCommandModules`), re-filtered against the session-start set.
+ */
+interface IPresetApplicationOptions {
+  permissionMode?: TPermissionMode;
+  model?: string;
+  effort?: TModelEffort;
+  temperature?: number;
+  maxOutputTokens?: number;
+  /** PRESET-014 — preset persona re-applied to the live system prompt. */
+  persona?: string;
+  /** PRESET-015 — allowlist of command-module names to keep on the live session. */
+  enabledCommandModules?: readonly string[];
+  /** PRESET-015 — denylist of command-module names to remove from the live session. */
+  disabledCommandModules?: readonly string[];
+  /** PRESET-016 — runtime gate toggle for subagent dispatch on the live session. */
+  enableParallelSubagents?: boolean;
+  /** PRESET-017 — toggle the verify-before-done self-verification section on the live prompt. */
+  selfVerification?: boolean;
+}
+/** Outcome of {@link applyPresetToSession}: which option groups were re-applied vs. skipped. */
+interface IPresetApplicationResult {
+  /** Option-group keys whose value was present and applied to the live session. */
+  readonly applied: readonly string[];
+  /** Option-group keys absent from the resolved options (left untouched). */
+  readonly skipped: readonly string[];
+}
+/**
+ * Re-apply a resolved preset to a live session and record it as the active preset.
+ *
+ * This is the single entry point for live preset switching. It first records the active preset id
+ * (PRESET-011 runtime state) — the runtime's `setActivePresetId` is optional, so it is invoked
+ * defensively. It then re-applies each option group it owns; PRESET-012 applies the permission
+ * posture via the existing `writeCommandPermissionMode` seam, and PRESET-013 re-applies the model
+ * group (`model`/`effort`/`temperature`/`maxOutputTokens`) via the runtime's optional
+ * `applyModelOptions`. PRESET-014 re-applies the `persona` group via the host context's optional
+ * `applyPersona` seam. PRESET-015 re-applies the command-module selection group via the host
+ * context's optional `applyCommandModuleSelection` seam. PRESET-016 toggles the parallel-subagents
+ * runtime gate via the runtime's optional `setParallelSubagentsEnabled` seam. PRESET-017 toggles
+ * the verify-before-done self-verification section via the host context's optional
+ * `applySelfVerification` seam. Groups absent from `options` are left untouched and reported under
+ * `skipped`.
+ */
+declare function applyPresetToSession(context: ICommandHostContext, presetId: string, options: IPresetApplicationOptions): Promise<IPresetApplicationResult>;
+//#endregion
+//#region src/config/settings-io.d.ts
+type TSettingsData = Record<string, TUniversalValue>;
+declare function getUserSettingsPath(): string;
+type TSettingsScope = 'user' | 'project-local';
+declare function resolveSettingsPathForScope(cwd: string, scope: TSettingsScope | undefined): string;
+/**
+ * CLI-069: missing file → empty defaults (non-error); an EXISTING file that
+ * fails to parse throws SettingsParseError — no warn-and-continue masking.
+ */
+declare function readSettings(path: string): TSettingsData;
+declare function writeSettings(path: string, settings: TSettingsData): void;
+declare function updateModelInSettings(settingsPath: string, modelId: string): void;
+declare function deleteSettings(path: string): boolean;
+//#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";
+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;
+declare function readStatusLineSettings(settings: TSettingsData): IStatusLineCommandSettings;
+declare function applyStatusLineSettings(settingsPath: string, patch: TStatusLineCommandSettingsPatch): IStatusLineCommandSettings;
+//#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 token usage and estimated cost. /cost budget <amount> sets a monthly budget.";
+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;
+  /** Replace the entire command set (used by live preset command-module re-selection — PRESET-015). */
+  replaceCommands(commands: readonly ISystemCommand[]): void;
+  /** Execute a command by name. Returns null if command not found. */
+  execute(name: string, session: ICommandHostContext, args: string): Promise<ICommandResult$1 | 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$1>;
+  /** List all registered commands. */
+  listCommands(): ISystemCommand[];
+  listModelInvocableCommands(): ICapabilityDescriptor[];
+  isModelInvocable(name: string): boolean;
+  executeModelInvocable(name: string, session: ICommandHostContext, args: string): Promise<ICommandResult$1 | 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 ISkillPromptContext {
+  /** 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?: ISkillPromptContext): 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?: ISkillPromptContext): Promise<ISkillExecutionResult>;
+//#endregion
+//#region src/commands/skill-activation-events.d.ts
+interface ISkillActivationHistoryData extends ISkillActivationEvent {
+  readonly message: string;
+}
+//#endregion
+//#region src/interactive/interactive-session-background-tracker.d.ts
+interface IBackgroundTrackerState {
+  tasks: IBackgroundTaskState[];
+  taskEvents: TBackgroundTaskEvent[];
+  groups: IBackgroundJobGroupState$1[];
+  groupEvents: TBackgroundJobGroupEvent[];
+}
+declare class SessionBackgroundTaskTracker {
+  private readonly getManager;
+  private readonly onChanged;
+  private readonly emitTaskEvent;
+  private readonly emitGroupEvent;
+  private readonly persistSession;
+  private readonly onWake?;
+  private readonly appendSystemNote?;
+  private readonly appendHistoryEntry?;
+  private backgroundTasks;
+  private backgroundTaskEvents;
+  private backgroundJobGroups;
+  private backgroundJobGroupEvents;
+  private backgroundTaskUnsubscribe;
+  private backgroundJobUnsubscribe;
+  private backgroundJobOrchestrator;
+  constructor(getManager: () => IBackgroundTaskManager$1 | undefined, onChanged: (cause: TExecutionWorkspaceUpdateCause, entryId?: string) => void, emitTaskEvent: (event: TBackgroundTaskEvent) => void, emitGroupEvent: (event: TBackgroundJobGroupEvent) => void, persistSession: () => void, onWake?: ((instruction: string, taskId: string) => void) | undefined, appendSystemNote?: ((message: string) => void) | undefined, appendHistoryEntry?: ((entry: IHistoryEntry) => void) | undefined);
+  subscribe(session: Session): void;
+  /**
+   * FLOW-003: re-spawn restored sleeping scheduled wakes so they fire again after a resume,
+   * and surface a one-time note for any whose fire time elapsed while the CLI was closed.
+   */
+  private reArmRestoredSchedules;
+  dispose(): void;
+  restoreState(state: IBackgroundTrackerState): void;
+  getState(): IBackgroundTrackerState;
+  getManagerOrThrow(): IBackgroundTaskManager$1;
+  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$1, 'parentSessionId'>, sessionId: string): IBackgroundJobGroupState$1;
+  listGroups(sessionId: string): IBackgroundJobGroupState$1[];
+  getGroup(groupId: string, sessionId: string): IBackgroundJobGroupState$1 | undefined;
+  waitGroup(groupId: string, sessionId: string): Promise<IBackgroundJobGroupState$1>;
+  readTaskDetail(entryId: string, taskId: string, cursor?: IExecutionDetailCursor): Promise<IExecutionDetailPage>;
+  readGroupDetail(entryId: string, groupId: string, sessionId: string): IExecutionDetailPage;
+  getTaskSnapshots(): IBackgroundTaskState[];
+  getGroupSnapshots(): IBackgroundJobGroupState$1[];
+  private subscribeGroupEvents;
+  private recordTaskEvent;
+  /**
+   * ANALYTICS-001 (Phase 2): when a background agent task completes with token usage, append a
+   * source-attributed usage-summary to the parent history so the usage report attributes those tokens
+   * to that task (not the main thread).
+   */
+  private recordCompletedTaskUsage;
+  private recordGroupEvent;
+}
+//#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$1;
+  /** 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;
+    executionId?: 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;
+  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;
+    executionId?: string;
+  }) => void;
+  customAgentRegistry?: (name: string) => IAgentDefinition | undefined;
+}
+type TSubagentRunnerFactory = (deps: IInProcessSubagentRunnerDeps) => ISubagentRunner;
+declare function createInProcessSubagentRunner(deps: IInProcessSubagentRunnerDeps): ISubagentRunner;
+//#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$1;
+  /** 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[];
+  /** PRESET-016 — runtime gate; when present and returns false, subagent dispatch is refused. */
+  isParallelSubagentsEnabled?: () => boolean;
+}
+/** 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/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/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 readonly emitMemoryEvent;
+  private history;
+  private editCheckpointStore;
+  private memoryEvents;
+  private usedMemoryReferences;
+  private contextReferences;
+  private systemContextReferences;
+  private skillActivationEvents;
+  constructor(cwd: string, getSessionId: () => string, getExecuting: () => boolean, persistSession: () => void, emitSkillActivation: (event: ISkillActivationEvent) => void, emitMemoryEvent: (event: IMemoryEvent) => 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;
+  recordSystemContextFiles(entries: readonly IContextFileEntry[]): void;
+  listContextReferences(): IContextReferenceItem[];
+  listInjectionContextReferences(): 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/session-persistence.d.ts
+declare function createProjectSessionStore(cwd: string, fs?: IFileSystem): IInteractiveSessionStore;
+/**
+ * User-level session store (`~/.robota/sessions`). Symmetric to {@link createProjectSessionStore};
+ * there is no user-level replay-log directory, so it reads persisted records only.
+ */
+declare function createUserSessionStore(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/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 {
+  /**
+   * Preset persona block (portable personality/behaviour). When set and non-blank it is
+   * composed as a `source: 'persona'` section with priority 5; empty/undefined adds no section.
+   */
+  persona?: string;
+  /**
+   * PRESET-017: when true, a concise verify-before-done directive is composed as a
+   * `source: 'self-verification'` section with priority 6; false/undefined adds no section.
+   */
+  selfVerification?: boolean;
+  /** 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 permission mode — the value the permission gate enforces */
+  permissionMode: TPermissionMode;
+  /** 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/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/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/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/assembly/create-session-types.d.ts
+type TAutoCompactThreshold = number | false;
+/** Options for the createSession factory */
+interface ICreateSessionOptions {
+  /** Resolved CLI configuration (model, API key, permissions) */
+  config: IResolvedConfig;
+  /** Working directory used for project context, skills, and agent definitions. */
+  cwd?: string;
+  /** Loaded AGENTS.md / CLAUDE.md context */
+  context: ILoadedContext;
+  /** Terminal I/O for permission prompts */
+  terminal: ITerminalOutput$1;
+  /** 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;
+  /**
+   * Injected "ask the user" port (CMD-005): forwarded into the session/agent so model-invoked tools
+   * (AskUserQuestion) can solicit a structured answer. Absent headless.
+   */
+  ask?: IUserInteraction['ask'];
+  /** 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$1, toolName: string, toolArgs: TToolArgs) => Promise<TPermissionResult>;
+  /** Additional tools to register beyond the defaults (e.g. agent-tool) */
+  additionalTools?: IToolWithEventService[];
+  /** GOAL-001: include the `report_goal_status` completion-signal tool (interactive sessions). */
+  includeGoalTool?: boolean;
+  /** Additional background task runners composed by the runtime shell. */
+  backgroundTaskRunners?: IBackgroundTaskRunner$1[];
+  /** 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;
+  /**
+   * Preset execution capability: when true the assembly turns on `enableAgentRuntime`
+   * so subagent/background dispatch is active for this session. Threaded from the
+   * preset's `enableParallelSubagents` flag.
+   */
+  enableParallelSubagents?: boolean;
+  /**
+   * Preset execution capability: when true the framework composes a verify-before-done
+   * self-verification section into the system prompt (PRESET-017), as a normal
+   * priority-sorted `source: 'self-verification'` section.
+   */
+  selfVerification?: 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;
+    executionId?: string;
+  }) => void;
+  /** Callback when context is compacted */
+  onCompact?: (summary: string) => void;
+  /** Callback with structured compaction metadata */
+  onCompactEvent?: (event: ICompactEvent) => void;
+  /** Instructions to include in the compaction prompt (e.g. from CLAUDE.md) */
+  compactInstructions?: string;
+  /** Auto-compact threshold as a 0-1 fraction. Set false to disable automatic compaction. */
+  autoCompactThreshold?: TAutoCompactThreshold;
+  /** Custom system prompt builder function */
+  systemPromptBuilder?: (params: ISystemPromptParams) => string;
+  /** Custom tool descriptions for the system prompt */
+  toolDescriptions?: string[];
+  /** Session logger — injected for pluggable session event logging. */
+  sessionLogger?: ISessionLogger;
+  /** Provider factory for prompt hook executors (DI). */
+  providerFactory?: TProviderFactory;
+  /** Session factory for agent hook executors (DI). */
+  sessionFactory?: TSessionFactory;
+  /** Additional hook type executors beyond the defaults (prompt, agent). */
+  additionalHookExecutors?: IHookTypeExecutor[];
+  /** Override session ID (used when resuming a session to reuse the original ID) */
+  sessionId?: string;
+  /** Pre-approved tool names — added to permissions.allow as ToolName(*) patterns. */
+  allowedTools?: string[];
+  /** Denied tool names — added to permissions.deny as ToolName(*) patterns. denied > allowed. */
+  deniedTools?: string[];
+  /** Override the model from config. When set, takes precedence over config.provider.model. */
+  model?: string;
+  /**
+   * Reasoning-effort dial for this session, threaded to the provider request builder.
+   * Resolved from a preset's `effort` (PRESET-008). When unset, the framework→provider
+   * seam defaults it to `'high'`. Native-effort providers map it onto their request
+   * parameter; providers without native effort ignore it as a documented no-op.
+   */
+  effort?: TModelEffort;
+  /** Text to append to the generated system prompt. */
+  appendSystemPrompt?: string;
+  /** Preset persona block composed as a `source: 'persona'` system-prompt section (priority 5). */
+  persona?: string;
+  /** Model command execution bridge. */
+  modelCommandExecutor?: (command: string, args: string) => Promise<ICommandResult$1 | 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;
+  /** Active preset id selected at startup (PRESET-011 runtime state). Defaults to 'default'. */
+  activePresetId?: string;
+  /** Request structured output from the provider for this session. */
+  responseFormat?: {
+    type: 'text' | 'json_object';
+  };
+}
+/** Result of createSession — session instance plus a system-message rebuilder for context refresh. */
+interface ICreateSessionResult {
+  session: Session;
+  /**
+   * Rebuild the system message using updated context strings.
+   * Called by staleness detection when AGENTS.md or CLAUDE.md files change between turns.
+   * PRESET-014: an optional `overrides.persona` re-applies a preset persona to the live prompt;
+   * PRESET-017: an optional `overrides.selfVerification` toggles the verify-before-done section.
+   * Either override is retained for subsequent (override-less) rebuilds.
+   */
+  rebuildSystemMessage: (agentsMd: string, claudeMd: string, overrides?: {
+    persona?: string;
+    selfVerification?: boolean;
+  }) => string;
+}
+//#endregion
+//#region src/assembly/create-tools.d.ts
+/**
+ * Create the default set of CLI tools.
+ * Returns the standard tools as IToolWithEventService[].
+ */
+interface ICreateDefaultToolsOptions {
+  sandboxClient?: ISandboxClient;
+  cwd?: string;
+}
+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[];
+  /** Denied tool names — added to permissions.deny. denied > allowed. */
+  deniedTools?: string[];
+  /** Override the model from config. When set, takes precedence over config.provider.model. */
+  model?: string;
+  /** Text to append to the system prompt. */
+  appendSystemPrompt?: string;
+  /** Preset persona block composed as a `source: 'persona'` system-prompt section (priority 5). */
+  persona?: string;
+  /** Replace the entire system prompt with this string. Takes precedence over the default builder. */
+  systemPrompt?: string;
+  /** Override config language (e.g., "ko", "en"). Injected into system prompt. */
+  language?: string;
+  /** Runtime-composed background task runners. */
+  backgroundTaskRunners?: IBackgroundTaskRunner$1[];
+  /** 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;
+  /**
+   * TERM-001: transport-provided terminal-handoff capability. When present, the session can hand the
+   * real terminal to a child process (e.g. `/shell`, `$EDITOR`) and restore the display. Absent /
+   * `canHandoffTerminal === false` for transports with no interactive TTY (headless).
+   */
+  terminalHandoff?: ITerminalHandoff;
+  /**
+   * CMD-004: transport-provided "ask the user" handler. When present, commands can solicit a
+   * structured answer (confirm/select/multi/text) through the interaction channel. Absent for
+   * non-interactive transports — the session then treats an ask as `cancelled`, never a silent guess.
+   */
+  askHandler?: IUserInteraction['ask'];
+  /** Model-visible command descriptors derived from the composed command executor. */
+  commandDescriptors?: readonly ICapabilityDescriptor[];
+  /** Provider definitions for hot-swap via /provider switch. */
+  providerDefinitions?: readonly import('@robota-sdk/agent-core').IProviderDefinition[];
+  /** Model command execution bridge. */
+  modelCommandExecutor?: (command: string, args: string) => Promise<ICommandResult$1 | 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;
+  /** Active preset id selected at startup (PRESET-011 runtime state). Defaults to 'default'. */
+  activePresetId?: string;
+  /** Preset execution capability: activate agent runtime + subagent/background dispatch. */
+  enableParallelSubagents?: boolean;
+  /** Preset execution capability: run a post-task self-verification step. */
+  selfVerification?: boolean;
+  /** Organization policy for enforcing provider restrictions, command blocks, and API key rules. */
+  orgPolicy?: IOrgPolicy;
+  /** Additional tools registered alongside the default CLI tools. */
+  additionalTools?: IToolWithEventService[];
+  /** Request structured output from the provider for this session. */
+  responseFormat?: {
+    type: 'text' | 'json_object';
+  };
+}
+/** 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;
+  /** TERM-001: transport-provided terminal-handoff capability (see standard options). */
+  terminalHandoff?: ITerminalHandoff;
+  /** CMD-004: transport-provided "ask the user" handler (see standard options). */
+  askHandler?: IUserInteraction['ask'];
+}
+/** Union of standard and injected construction options. */
+type TInteractiveSessionOptions = IInteractiveSessionStandardOptions | IInteractiveSessionInjectedOptions;
+//#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. PRESET-014: an
+   * optional `overrides.persona` re-applies a preset persona to the live prompt; PRESET-017: an
+   * optional `overrides.selfVerification` toggles the verify-before-done section. Either override
+   * is retained for subsequent (override-less) rebuilds.
+   */
+  rebuildSystemMessage: (agentsMd: string, claudeMd: string, overrides?: {
+    persona?: string;
+    selfVerification?: boolean;
+  }) => string;
+}
+//#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;
+  /** Command modules received at construction — retained for live re-selection (PRESET-015). */
+  private readonly allCommandModules;
+  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$1>) => Promise<ICommandResult$1>, shellExec?: TShellExecFn | undefined);
+  /** PRESET-015 — re-filter the session's command modules and rebuild the executor live. */
+  reapplyCommandModuleSelection(enabled: readonly string[] | undefined, disabled: readonly string[] | undefined): void;
+  getCommandInvocationSource(): TCommandInvocationSource;
+  getCommandHostAdapters(): ICommandHostAdapters;
+  listCommands(): Array<{
+    name: string;
+    displayName?: string;
+    description: string;
+    example?: string;
+  }>;
+  listSkills(): ICommandSkillListEntry[];
+  listModelInvocableCommands(): Array<{
+    name: string;
+    description: string;
+  }>;
+  findSkillCommand(name: string): ICommand | undefined;
+  executeCommand(name: string, args: string): Promise<ICommandResult$1 | null>;
+  executeCommandWithSource(source: TCommandInvocationSource, command: ISystemCommand, args: string): Promise<ICommandResult$1>;
+  executeModelCommand(name: string, args: string): Promise<ICommandResult$1 | null>;
+  executeSkillCommandByName(name: string, args: string, request: ICommandSkillActivationRequest): Promise<ICommandResult$1 | 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-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;
+}
+/** Options threaded through submit/executePrompt for non-user turns (FLOW-002). */
+interface ITurnOptions {
+  turnSource?: TTurnSource;
+  /** When set, the in-flight wake for this background task id is cleared on turn completion. */
+  wakeTaskId?: string;
+}
+/** A submit callback that optionally carries turn options (default = user turn). */
+type TSubmitFn = (prompt: string, displayInput?: string, rawInput?: string, options?: ITurnOptions) => Promise<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;
+  pendingTurnOptions: ITurnOptions;
+  shuttingDown: boolean;
+  /** FLOW-002: background task ids with an in-flight wake turn (coalesces duplicate wakes). */
+  readonly wakeTaskIds: Set<string>;
+  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;
+    executionId?: 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: TSubmitFn, turnOptions?: ITurnOptions): 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$1>, submit: (p: string, d?: string, r?: string) => Promise<void>): Promise<ICommandResult$1>;
+  applyForkSkillResult(result: string): Promise<void>;
+}
+//#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(): SessionExecutionController['activeTools'];
+  cancelQueue(): void;
+  executeCommand(name: string, args: string): Promise<ICommandResult$1 | null>;
+  executeModelCommand(name: string, args: string): Promise<ICommandResult$1 | null>;
+  getCommandInvocationSource(): TCommandInvocationSource;
+  executeSkillCommandByName(name: string, args: string, request: ICommandSkillActivationRequest): Promise<ICommandResult$1 | null>;
+  listCommands(): Array<{
+    name: string;
+    displayName?: string;
+    description: string;
+    example?: 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$1, 'parentSessionId'>): IBackgroundJobGroupState$1;
+  listBackgroundJobGroups(): IBackgroundJobGroupState$1[];
+  getBackgroundJobGroup(groupId: string): IBackgroundJobGroupState$1 | undefined;
+  waitBackgroundJobGroup(groupId: string): Promise<IBackgroundJobGroupState$1>;
+  getExecutionWorkspaceSnapshot(options?: IExecutionWorkspaceSnapshotOptions): IExecutionWorkspaceSnapshot;
+  listExecutionWorkspaceEntries(filter?: IExecutionWorkspaceFilter): IExecutionWorkspaceEntry[];
+  getExecutionWorkspaceEntry(entryId: string): IExecutionWorkspaceEntry | undefined;
+  readExecutionWorkspaceDetail(entryId: string, cursor?: IExecutionDetailCursor): Promise<IExecutionDetailPage>;
+  createExecutionWorkspaceTaskSpawner(origin: IExecutionOrigin$1): 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>;
+  spawnScheduledWake(input: {
+    label: string;
+    cronExpression: string;
+    agentInstruction: string;
+  }): Promise<IBackgroundTaskState>;
+  spawnMonitorWake(input: {
+    label: string;
+    command: string;
+    matchPattern: string;
+    agentInstruction: string;
+  }): Promise<IBackgroundTaskState>;
+}
+//#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;
+  private providerDefinitions;
+  private orgPolicy;
+  protected readonly bgTracker: SessionBackgroundTaskTracker;
+  protected readonly histTracker: SessionHistoryTracker;
+  protected readonly skillRouter: SessionSkillRouter;
+  protected readonly execCtrl: SessionExecutionController;
+  /** GOAL-001: autonomous objective-pursuit controller (inert until a goal is set). */
+  private readonly goalController;
+  /** GOAL-001: origin of the most recently started turn — gates goal-loop advancement. */
+  private currentTurnSource;
+  /** TERM-001: transport-provided terminal-handoff capability (undefined when none). */
+  private readonly terminalHandoff?;
+  /** CMD-004: transport-provided "ask the user" handler (undefined when no interactive renderer). */
+  private readonly askHandler?;
+  /** TERM-001: guards handoff exclusivity (one handoff at a time). */
+  private terminalHandoffActive;
+  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$1>(event: E, handler: IInteractiveSessionEvents$1[E]): void;
+  off<E extends TInteractiveEventName$1>(event: E, handler: IInteractiveSessionEvents$1[E]): void;
+  private emit;
+  submit(input: string, displayInput?: string, rawInput?: string, options?: ITurnOptions): Promise<void>;
+  /**
+   * FLOW-002: re-enter the agent loop with a non-user turn triggered by a background wake
+   * (a scheduled fire or, later, a monitor match). Coalesces by source task id so repeated
+   * wakes for the same task while one is still in flight collapse to a single turn.
+   */
+  requestWakeup(instruction: string, sourceTaskId: string): boolean;
+  abort(): void;
+  shutdown(options?: IInteractiveSessionShutdownOptions): Promise<void>;
+  get isInitialized(): boolean;
+  getAutoCompactThresholdSource(): TAutoCompactThresholdSource;
+  getAutoCompactThreshold(): number | false;
+  getSession(): Session;
+  /**
+   * PRESET-014: re-apply a preset persona to the live system prompt. Recomposes the system
+   * message from the currently tracked AGENTS.md/CLAUDE.md entries (the same content the staleness
+   * refresh uses) plus the new persona, then propagates it to the session. No-op before init,
+   * when the rebuild closure is not yet available.
+   */
+  applyPersona(persona: string): void;
+  /**
+   * PRESET-017: toggle the verify-before-done self-verification section on the live system prompt.
+   * Recomposes the system message from the currently tracked AGENTS.md/CLAUDE.md entries plus the
+   * new selfVerification flag, then propagates it to the session. No-op before init, when the
+   * rebuild closure is not yet available.
+   */
+  applySelfVerification(enabled: boolean): void;
+  /**
+   * PRESET-015: re-apply a preset's command-module selection to the live session by delegating to
+   * the skill router, which re-filters the session-start module set and rebuilds the executor.
+   */
+  applyCommandModuleSelection(enabled: readonly string[] | undefined, disabled: readonly string[] | undefined): void;
+  getAgentJobCapability(): IAgentJobHostContext;
+  /**
+   * CMD-004: the injected "ask the user" port, or undefined when no interactive renderer is attached
+   * (headless/automation) — a command must treat absence as "no human available", never a silent
+   * guess. The model-invocation guard lives in {@link createUserInteractionPort}.
+   */
+  getUserInteraction(): IUserInteraction | undefined;
+  /**
+   * TERM-001: whether the active transport can hand the real terminal to a child process. False
+   * when no handoff capability was injected or its `canHandoffTerminal` is false (e.g. headless).
+   */
+  canHandoffTerminal(): boolean;
+  /**
+   * TERM-001: suspend the display, run `fn` (which spawns a child with inherited stdio), then
+   * restore. The framework owns the ORCHESTRATION: it enforces exclusivity (one handoff at a time)
+   * and fast-fails when no interactive terminal is available, instead of hanging. The transport
+   * implements the underlying suspend/resume; the caller's `fn` spawns whatever child it wants — the
+   * framework stays platform-neutral and never spawns a shell.
+   */
+  runWithTerminal<T>(fn: () => Promise<T>): Promise<T>;
+  setAutoCompactThreshold(threshold: TAutoCompactThreshold$1, source?: TAutoCompactThresholdSource): void;
+  clearConversationHistory(): void;
+  getName(): string | undefined;
+  attachTransport(transport: ITransportAdapter<IInteractiveSession>): void;
+  setName(name: string): void;
+  private getBackgroundTaskManager;
+  /**
+   * Surface an error that happened OUTSIDE the turn boundary (background task, catalog
+   * refresh, persistence, un-caught promise) into the conversation (ERR-001 G1). The entry
+   * carries `metadata.kind: 'error'` so transports render it as a styled error block, and the
+   * 'error' event drives transport error state. The session stays fully usable.
+   */
+  reportBackgroundError(error: Error, source?: string): void;
+  private captureSandboxSnapshot;
+  private persistCurrentSession;
+  /**
+   * GOAL-001: assign an autonomous goal and begin pursuing it. The agent takes follow-up turns
+   * on its own until it signals the goal satisfied or a bound fires (max iterations, no-progress,
+   * or {@link cancelGoal}). Returns the seeded goal state. Throws on an empty objective.
+   */
+  setGoal(objective: string, options?: IGoalStartOptions): Promise<IGoalState>;
+  /** GOAL-001: the current goal state, or `null` when no goal has been set. */
+  getGoalState(): IGoalState | null;
+  /** GOAL-001: cancel an in-flight goal. Returns the stopped state, or `null` when none is active. */
+  cancelGoal(): IGoalState | null;
+  /** GOAL-001: schedule the next goal-driven turn via the FLOW-002 wakeup primitive. */
+  private scheduleGoalTurn;
+  /** GOAL-001: advance the goal loop after an agent-driven turn completes. */
+  private handleGoalTurnComplete;
+  /** GOAL-001: after a resume, continue pursuing a restored active goal once initialized. */
+  private resumeGoalIfActive;
+  private switchProvider;
+  executeCommand(name: string, args: string): Promise<ICommandResult$1 | null>;
+}
+//#endregion
+//#region src/interactive/session-naming.d.ts
+/**
+ * Generate a short session title from the first user message using the active provider.
+ * Falls back to a sanitized form of the message when the model returns nothing usable.
+ */
+declare function generateSessionName(provider: IAIProvider, firstMessage: string): Promise<string>;
+//#endregion
+export { IPreparedSubagentWorktree as $, IBackgroundTaskManager$1 as $a, IMemoryCandidate as $i, updateModelInSettings as $n, applyProviderConfiguration as $r, parseFrontmatter as $t, IAgentExecutorOptions as A, toContextReferenceRecords as Aa, ICapabilityDescriptor as Ai, RESUME_COMMAND_DESCRIPTION as An, ICommandSettingsAdapter as Ao, closeCommandBackgroundTask as Ar, createSystemCommands as At, resolveSessionIdByIdOrName as B, wrapEditCheckpointTools as Ba, ICompactContextResult as Bi, DEFAULT_STATUS_LINE_COMMAND_SETTINGS as Bn, IOrgPolicy as Bo, createProviderFromSettings as Br, IBundlePluginManifest as Bt, evaluateReversibleToolSafety as C, IContextReferenceInventoryLimits as Ca, setCurrentProvider as Ci, rollbackCommandEditCheckpoint as Cn, BackgroundJobOrchestrator as Co, buildLanguageCommandSubcommands as Cr, ISkillExecutionCallbacks as Ct, PromptExecutor as D, createContextReferenceItem as Da, TCommandModuleSessionRequirement as Di, ICommandSessionInfo as Dn, ICommandPermissionModeAdapter as Do, BACKGROUND_COMMAND_USAGE as Dr, TShellExecFn as Dt, IPromptProvider as E, clearContextReferences as Ea, ICommandModule as Ei, EXIT_COMMAND_DESCRIPTION as En, ICommandHostAdapters as Eo, BACKGROUND_COMMAND_DESCRIPTION as Er, ISkillPromptContext as Et, IInteractiveSessionStore as F, IPromptFileReferenceResolveOptions as Fa, ICommandSkillListEntry as Fi, createSessionRenamedEffect as Fn, buildPluginCommandSubcommands as Fo, readCommandBackgroundTaskLog as Fr, IInstalledPluginRecord as Ft, createPromptFileReferenceHistoryEntry as G, IEditCheckpointInspectionPlan as Ga, listCommandContextReferences as Gi, isStatusLineCommandSettingsPatch as Gn, mergeSettings as Gr, PluginSettingsStore as Gt, resolvePromptFileReferences as H, IEditCheckpointFileInspection as Ha, addCommandContextReference as Hi, STATUSLINE_COMMAND_DESCRIPTION as Hn, readProviderSettings as Hr, ILoadedBundlePlugin as Ht, createProjectSessionStore as I, IPromptFileReferenceToken as Ia, IModelReapplyOptions as Ii, formatCommandSessionReplayValidationReport as In, createPluginRegistryReloadRequestedEffect as Io, HELP_COMMAND_DESCRIPTION as Ir, TInstalledPluginsRegistry as It, toPromptFileReferenceRecords as J, IEditCheckpointRestoreResult as Ja, readCommandContextState as Ji, TSettingsScope as Jn, IActiveModelChangeOptions as Jr, IMarketplaceManifest as Jt, formatPromptFileReferenceDiagnostics as K, IEditCheckpointManifest as Ka, readAutoCompactThreshold as Ki, readStatusLineSettings as Kn, readMergedProviderSettingsFromPaths as Kr, IKnownMarketplaceEntry as Kt, createUserSessionStore as L, IResolvedPromptFileReference as La, TAutoCompactThresholdSource as Li, parseSessionNameArgument as Ln, createPluginTuiRequestedEffect as Lo, formatCommandHelpMessage as Lr, MarketplaceClient as Lt, TSessionFactory as M, IPromptFileReferenceDiagnostic as Ma, ICommandHostContext as Mi, clearConversationHistory as Mn, PLUGIN_COMMAND_ARGUMENT_HINT as Mo, formatCommandBackgroundTaskList as Mr, PluginCommandSource as Mt, TInteractivePermissionHandler as N, IPromptFileReferenceHistoryData as Na, ICommandSessionReplayValidationReport as Ni, createSessionExitRequestedEffect as Nn, PLUGIN_COMMAND_DESCRIPTION as No, listCommandBackgroundTasks as Nr, BundlePluginInstaller as Nt, TProviderFactory as O, listActiveContextReferences as Oa, ISystemCommand as Oi, RENAME_COMMAND_DESCRIPTION as On, ICommandPickerAdapter as Oo, buildBackgroundCommandSubcommands as Or, preprocessShellCommands as Ot, TPermissionResultValue as P, IPromptFileReferenceLimits as Pa, ICommandSessionRuntime as Pi, createSessionPickerRequestedEffect as Pn, RELOAD_PLUGINS_COMMAND_DESCRIPTION as Po, parseCommandBackgroundLogCursor as Pr, IBundlePluginInstallerOptions as Pt, storeAgentToolDeps as Q, IBackgroundTaskHandle as Qa, writeAutoCompactThresholdSetting as Qi, resolveSettingsPathForScope as Qn, applyActiveModelChange as Qr, SkillCommandSource as Qt, listResumableSessionSummaries as R, IResolvedPromptFileReferences as Ra, AUTO_COMPACT_THRESHOLD_SETTINGS_KEY as Ri, readCommandSessionInfo as Rn, resolvePluginCommandAdapter as Ro, IReadProviderSettingsOptions as Rr, BundlePluginLoader as Rt, TReversibleSideEffect as S, IContextReferenceClearResult as Sa, mergeProviderPatch as Si, restoreCommandEditCheckpoint as Sn, parseExecutionWorkspaceEntryId as So, TRecommendedResponseLanguage as Sr, IForkExecutionOptions as St, IPromptExecutorOptions as T, IContextReferenceUpsertResult as Ta, validateProviderProfile as Ti, COST_COMMAND_DESCRIPTION as Tn, summarizeBackgroundJobGroup as To, parseLanguageArgument as Tr, executeSkill as Tt, parsePromptFileReferences as U, IEditCheckpointFileRecord as Ua, clearCommandContextReferences as Ui, applyStatusLineSettings as Un, resolveEnvDefaultProvider as Ur, TEnabledPlugins as Ut, resolvePromptFileReferencePaths as V, EditCheckpointStore as Va, TAutoCompactThreshold$1 as Vi, STATUSLINE_COMMAND_ARGUMENT_HINT as Vn, readMergedProviderSettings as Vr, IBundleSkill as Vt, buildPromptWithFileReferences as W, IEditCheckpointInspection as Wa, compactCommandContext as Wi, buildStatusLineCommandSubcommands as Wn, mergeProviders as Wr, IPluginSettings as Wt, createAgentTool as X, IEditCheckpointTurnInput as Xa, resetAutoCompactThresholdSetting as Xi, getUserSettingsPath as Xn, IProviderSettingsWriteTargetOptions as Xr, TKnownMarketplacesRegistry as Xt, IAgentToolDeps as Y, IEditCheckpointSummary as Ya, removeCommandContextReference as Yi, deleteSettings as Yn, IActiveModelChangeResult as Yr, IMarketplacePluginEntry as Yt, retrieveAgentToolDeps as Z, TEditCheckpointFileRestoreAction as Za, setCommandAutoCompactThreshold as Zi, readSettings as Zn, IProviderSwitchOptions as Zr, TMarketplaceSource as Zt, IReversibleToolSafetyInput as _, IGoalSignal as _a, IProviderSetupPatch as _i, REWIND_COMMAND_ARGUMENT_HINT as _n, EXECUTION_ORIGIN_METADATA_KEYS as _o, resolvePermissionModeAdapter as _r, formatEnvReference as _t, TInteractiveSessionOptions as a, IStartupMemory as aa, probeProviderProfile as ai, ICommandProjectMemoryStore as an, TBackgroundTaskIdFactory as ao, PERMISSIONS_COMMAND_DESCRIPTION as ar, ISubagentRunner$1 as at, TReversibleRollbackLayer as b, extractGoalSignal as ba, buildProviderSetupPatch as bi, inspectCommandEditCheckpoint as bn, createExecutionOriginMetadata as bo, LANGUAGE_COMMAND_DESCRIPTION as br, resolveEnvReference as bt, ISubagentPromptOptions as c, ProjectMemoryStore as ca, IProviderProfileNameSuggestionOptions as ci, MEMORY_COMMAND_USAGE as cn, IBackgroundTaskSpawnerGroupRequest as co, VALID_PERMISSION_MODES as cr, ISubagentWorktreePrepareRequest as ct, getSubagentSuffix as d, buildGoalStartPrompt as da, IProviderCommandModuleOptions as di, createCommandPendingMemoryStore as dn, ISpawnAgentTaskRequest as do, formatInvalidPermissionModeMessage as dr, TSubagentRunnerFactory as dt, IMemoryPendingRecord as ea, applyProviderSwitch as ei, BuiltinCommandSource as en, IBackgroundTaskManagerOptions as eo, writeSettings as er, ISubagentJobHandle as et, createDefaultTools as f, GOAL_SIGNAL_TOOL_NAME as fa, IProviderCommandSettingsAdapter as fi, createCommandProjectMemoryStore as fn, ISpawnProcessTaskRequest as fo, isPermissionMode as fr, createInProcessSubagentRunner as ft, IReversibleToolSafetyContext as g, GoalController as ga, IProviderSetupInput as gi, recordCommandMemoryEvent as gn, createExecutionWorkspaceSnapshot as go, readCommandPermissionsState as gr, IAgentDefinition as gt, IReversibleExecutionOptions as h, DEFAULT_GOAL_NO_PROGRESS_LIMIT as ha, IProviderSettingsBuildOptions as hi, listCommandUsedMemoryReferences as hn, createMainThreadDetailPage as ho, readCommandPermissionMode as hr, IResolvedConfig as ht, IInteractiveSession as i, IProjectMemorySummary as ia, checkSettingsFile as ii, ICommandPendingMemoryStore as in, ILimitedOutputCapture as io, IPermissionsCommandState as ir, ISubagentManagerOptions as it, IAgentSession as j, upsertContextReference as ja, IAgentJobHostContext as ji, VALIDATE_SESSION_COMMAND_DESCRIPTION as jn, ICommandSettingsDocument as jo, formatCommandBackgroundTask as jr, SystemCommandExecutor as jt, AgentExecutor as k, removeContextReference as ka, TSystemCommandLifecycle as ki, RENAME_COMMAND_USAGE as kn, ICommandProcessAdapter as ko, cancelCommandBackgroundTask as kr, substituteVariables as kt, assembleSubagentPrompt as l, isMemoryType as la, sanitizeProviderProfileName as li, buildMemoryCommandSubcommands as ln, ICreateExecutionWorkspaceTaskSpawnerOptions as lo, buildPermissionModeSubcommands as lr, IWorktreeSubagentRunnerOptions as lt, ICreateSessionResult as m, DEFAULT_GOAL_MAX_ITERATIONS as ma, IProviderProfileSettings as mi, isCommandMemoryType as mn, createLineDetailPage as mo, parsePermissionModeArgument as mr, createSubagentSession as mt, IInteractiveSessionShutdownOptions as n, IAppendMemoryInput as na, TSettingsCheck as ni, CommandRegistry as nn, IBackgroundTaskStart as no, IPresetApplicationResult as nr, ISubagentJobStart as nt, createSubagentLogger as o, MEMORY_INDEX_MAX_BYTES as oa, testProviderProfileCommand as oi, MEMORY_COMMAND_ARGUMENT_HINT as on, TBackgroundTaskRunnerEvent as oo, PERMISSION_MODE_ARGUMENT_HINT as or, ISubagentSpawnRequest as ot, ICreateSessionOptions as p, createGoalStatusTool as pa, ILegacyProviderSettings as pi, hasSensitiveCommandMemoryContent as pn, createExecutionWorkspaceTaskSpawner as po, listCommandSessionAllowedTools as pr, ISubagentOptions as pt, hasBlockingPromptFileReferenceDiagnostics as q, IEditCheckpointRecorder as qa, readAutoCompactThresholdSource as qi, TSettingsData as qn, resolveActiveProvider as qr, IMarketplaceClientOptions as qt, InteractiveSession as r, IAppendMemoryResult as ra, checkSettingsDocument as ri, ICommandMemoryStores as rn, ICreateLimitedOutputCaptureOptions as ro, applyPresetToSession as rr, ISubagentManager as rt, resolveSubagentLogDir as s, MEMORY_INDEX_MAX_LINES as sa, IProviderProfileNameSuggestionInput as si, MEMORY_COMMAND_DESCRIPTION as sn, TBackgroundTaskTransitionEvent as so, PERMISSION_MODE_COMMAND_DESCRIPTION as sr, ISubagentWorktreeAdapter as st, generateSessionName as t, TMemoryCandidateStatus as ta, resolveProviderSettingsWriteTargetPath as ti, createBuiltinCommandModule as tn, IBackgroundTaskRunner$1 as to, IPresetApplicationOptions as tr, ISubagentJobResult as tt, getForkWorkerSuffix as u, buildGoalContinuationPrompt as ua, suggestProviderProfileName as ui, createCommandMemoryStores as un, IExecutionWorkspaceTaskSpawner as uo, formatCommandPermissionsMessage as ur, IInProcessSubagentRunnerDeps as ut, IReversibleToolSafetyReport as v, IGoalStartOptions as va, TProviderSettingsDocument as vi, REWIND_COMMAND_DESCRIPTION as vn, createBackgroundGroupExecutionEntryId as vo, writeCommandPermissionMode as vr, hasUsableSecretReference as vt, wrapReversibleExecutionTools as w, IContextReferenceRemoveResult as wa, upsertProviderProfile as wi, CLEAR_COMMAND_DESCRIPTION as wn, IBackgroundJobOrchestratorOptions as wo, formatLanguageUsageMessage as wr, ISkillExecutionResult as wt, TReversibleSafetyStatus as x, IContextReferenceAddResult as xa, deleteProviderProfile as xi, listCommandEditCheckpoints as xn, createMainThreadExecutionEntryId as xo, RECOMMENDED_RESPONSE_LANGUAGES as xr, ISkillActivationHistoryData as xt, TReversibleExecutionIsolation as y, TGoalDecision as ya, buildProviderProfile as yi, buildRewindCommandSubcommands as yn, createBackgroundTaskExecutionEntryId as yo, LANGUAGE_COMMAND_ARGUMENT_HINT as yr, isEnvReference as yt, resolveLatestSessionId as z, TPromptFileReferenceDiagnosticCode as za, DEFAULT_AUTO_COMPACT_THRESHOLD as zi, validateCommandSessionReplayLog as zn, ICommandResult$1 as zo, ProviderConfigError as zr, IBundlePluginFeatures as zt };
+//# sourceMappingURL=index-BeYNnJed.d.ts.map